How to move from Vercel/Netlify to a VPS

For a successful migration from Vercel or Netlify to your own server, it is enough to rent a VPS with specs starting from 2 GB RAM and 2 vCPUs (costing from $6–10/mo), set up Docker containerization for Next.js or SvelteKit, and use Nginx as a reverse proxy—this will allow you to reduce hosting costs by 5–10 times while maintaining high performance.

Why are developers choosing to migrate from Vercel and Netlify in 2026?

Moving from popular PaaS (Platform as a Service) platforms to your own virtual servers is driven not only by cost savings but also by the desire for full control over infrastructure. The main problem with Vercel and Netlify lies in "invisible" limits. As soon as your project grows beyond the hobby tier, you face massive bills for Bandwidth, Serverless function execution time, and the number of optimized images.

Vercel migration often becomes a necessity when Bandwidth costs reach $40 for every additional 100 GB. At the same time, a modern VPS offers terabytes of traffic for a fixed cost. If you have already encountered similar issues, you might find the experience of those who moved from Heroku to VPS useful, as the cost optimization logic is identical here.

Main reasons for migration:

• Traffic Costs: On a VPS, you pay for a port or a fixed volume (e.g., 4–10 TB), whereas on Edge platforms, every gigabyte over the limit costs dozens of times more.
• Cold Starts: Serverless functions "sleep" when there is no traffic. On a VPS, your Node.js application runs 24/7, ensuring an instant response.
• Environment Limitations: On Vercel, you are limited by function execution time (usually 15–30 seconds on the Pro plan). On a VPS, you can run long-running background tasks, parsers, or ML scripts.
• Vendor Lock-in: Using platform-specific features (Edge Middleware, Image Optimization API) ties you to the platform. Switching to a jamstack vps architecture makes the project portable.

Cost Comparison: Jamstack Platforms vs. VPS

To understand the real benefits of a Netlify migration, let's look at a comparison table of features and prices. We will compare a typical Next.js project with average traffic (500 GB/mo) and the need to optimize 5,000 images.

For many teams, hosting for an MVP startup starts with Vercel due to its convenience, but VPS remains the economically sound choice for scaling. As traffic grows, the price difference can reach hundreds or even thousands of dollars per month.

Technical Preparation for Vercel Migration for Next.js

Next.js is Vercel's flagship framework, but it works perfectly on any server. The key to a successful migration is using standalone mode. By default, Next.js creates a massive .next folder during build, which requires all node_modules to be present. Standalone mode bundles only the necessary files, reducing the Docker image size from 1 GB to 150–200 MB.

Configuring next.config.js

Add the following option to your configuration file:

module.exports = {
  output: 'standalone',
}

After running npm run build, Next.js will create a .next/standalone folder containing a server.js file. This is a self-sufficient Node.js application that doesn't require Next.js to be installed on the system—only the Node.js runtime is needed.

Image Optimization without Vercel

Vercel automatically optimizes images via its API. When moving to a jamstack vps, you need to ensure the sharp library is installed in your project. Next.js will automatically detect it and use your CPU resources to compress and convert images to WebP/AVIF.

npm install sharp

Keep in mind that this will put a load on the CPU. If you have thousands of heavy images, choose plans with powerful cores. You can read more about how the processor affects the performance of heavy applications in the article on Bare-metal vs VPS for ML, which details computational load issues.

Step-by-Step Netlify Migration Process: SvelteKit and Nuxt.js

Migrating projects on SvelteKit or Nuxt is similar but requires changing the adapter. In the Jamstack ecosystem, these frameworks often use adapter-auto or adapter-netlify. For a VPS, you will need adapter-node.

For SvelteKit:

1. Install the adapter: npm i -D @sveltejs/adapter-node.
2. Modify svelte.config.js:

   import adapter from '@sveltejs/adapter-node';
   export default {
     kit: {
       adapter: adapter()
     }
   };

3. Build the project: npm run build.
4. Start the server: node build/index.js.

For Nuxt.js:

Nuxt works perfectly in a Node.js environment by default. Simply run npm run build and start the result with node .output/server/index.mjs. It is important to correctly pass environment variables like PORT and HOST so the application is accessible from outside the Docker container or via Nginx.

Environment Setup: Docker, PM2, and Nginx

To ensure your jamstack vps runs stably, you shouldn't just run node server.js in the console. You need a process management system and a web server to handle SSL and caching.

Option 1: Using Docker (Recommended)

Docker isolates dependencies and simplifies deployment. Example of a minimal Dockerfile for a Next.js project:

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV production
COPY .next/standalone ./
COPY .next/static ./.next/static
COPY public ./public
EXPOSE 3000
CMD ["node", "server.js"]

Option 2: Using PM2

If you prefer running without containers, use PM2. It will ensure the application automatically restarts on crashes or after a server reboot.

npm install pm2 -g
pm2 start .next/standalone/server.js --name "my-app"
pm2 save
pm2 startup

Configuring Nginx as a Reverse Proxy

Nginx will accept incoming traffic on ports 80/443 and forward it to your Node.js application (port 3000). This is critical for security and performance. When choosing a server, pay attention to the traffic volume; read more about this in Bandwidth VPS: TB/mo vs unmetered.

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

CI/CD Automation: Replacing Vercel Deployments

One of the main reasons people love Vercel is automatic deployment on Git push. When you migrate from Vercel or Netlify to a VPS, this functionality is easily set up via GitHub Actions or GitLab CI.

Example Workflow for GitHub Actions:

1. Build: Build the project and create a Docker image.
2. Push: Push the image to Docker Hub or GitHub Container Registry.
3. Deploy: Connect to the VPS via SSH and run docker compose pull && docker compose up -d.

This takes a bit more time for the initial setup but gives you full control over the process. You can add testing stages, security checks, and Telegram notifications without build minute limits found on free or even paid PaaS tiers.

Performance Optimization: Edge Caching on Your Own VPS

Many fear that with a vercel migration, they will lose the advantage of an Edge network (serving content from the point closest to the user). However, this is easily solved by using Cloudflare in proxy mode.

• Cloudflare CDN: Caches static files (JS, CSS, images) on its Edge nodes for free.
• Nginx Caching: You can set up micro-caching on the server side for dynamic pages, allowing you to handle thousands of requests per second even on a weak VPS.
• Brotli Compression: Enable Brotli compression in Nginx to reduce the size of transferred data more effectively than standard Gzip.

For projects requiring minimal latency and high computational power, such as game servers, infrastructure choice is even more critical. You can learn how to select servers for high loads from the review of the best servers for Minecraft, where CPU and RAM requirements are at their peak.

Security and Monitoring After Migration

By moving from Netlify, you take responsibility for OS security. A minimal checklist:

1. UFW (Firewall): Close all ports except 80, 443, and your custom SSH port.
2. Fail2Ban: Protect the server from brute-force SSH attacks.
3. SSL: Use Certbot to obtain free Let's Encrypt certificates with auto-renewal.
4. Monitoring: Install Uptime Kuma or use simple scripts to check your application's availability.

Unlike closed platforms, here you see the real system load, can analyze Nginx logs in real-time, and respond quickly to abnormal traffic spikes or hacking attempts.

Conclusions

Migrating from Vercel or Netlify to a VPS is a strategically sound move for any project that has outgrown the prototype stage and requires cost optimization. For most Fullstack applications on Next.js or Nuxt, a VPS with 4 GB RAM and a modern NVMe drive is the optimal choice, providing stable operation without overpaying for the "magic" of Edge platforms.