How to migrate from Vercel/Netlify to a VPS

To successfully migrate from Vercel or Netlify to a VPS, it is sufficient to rent a virtual server with 2-4 GB of RAM and a CPU with 2 or more cores, set up Docker containerization for your application (Next.js, Nuxt, or SvelteKit), and deploy a reverse proxy like Nginx or Caddy. This allows you to reduce hosting costs by 5–10 times and completely eliminate limits on bandwidth and function execution time.

Why migrating from vercel netlify becomes a necessity for growing projects?

The main reason developers initiate a migrate from vercel netlify is unpredictable pricing when scaling. PaaS (Platform as a Service) platforms are great at the start, providing a Hobby/Free tier, but as soon as a project exceeds the limits, the cost of infrastructure ownership grows exponentially.

Economics of scaling and hidden fees

On Vercel and Netlify, you pay for "Seats" (team members), for bandwidth exceeding the limit, and for Serverless function execution time. For example, exceeding traffic by 100 GB can cost $40, while on a VPS, you get terabytes of traffic included in the price. If your project is actively growing, hosting for an MVP startup in 2026 based on a VPS becomes a much more logical choice in terms of unit economics.

Technical limitations of Serverless architecture

Using Edge functions and Serverless processing imposes strict limitations:

• Execution time limit (usually 10 to 30 seconds on Free/Pro plans).
• The "Cold Start" problem, where the first request after idle time is processed with a delay of several seconds.
• Limited RAM for function execution (usually 128 MB – 1024 MB).
• Difficulty connecting to traditional databases due to connection pool exhaustion.

Feature Comparison: Jamstack VPS vs PaaS Platforms

When moving to a jamstack vps, you trade "one-button" convenience for full control over system resources. Below is a table that clearly shows the difference in resources and cost between a typical PaaS Pro plan and an average VPS from Valebyte.

It is important to consider the type of traffic when choosing a server. You can read more about this in the article Bandwidth VPS: TB/mo vs unmetered — which to choose.

Vercel migration: specifics of moving Next.js applications

The vercel migration process for Next.js is the most in-demand, as Vercel is the "native" home for this framework. However, Next.js works perfectly on any Linux server thanks to standalone mode.

Setting up standalone mode in Next.js

To make a Next.js application run efficiently on a VPS, you need to modify the next.config.js file. This allows the framework to build only the necessary files, minimizing the size of the Docker image or project folder.

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

After running the npm run build command, Next.js will create a .next/standalone folder that can be launched via node server.js. This eliminates the need to install all node_modules on the production server, saving disk space and speeding up deployment.

Replacing Vercel Image Optimization

On Vercel, image optimization works "out of the box" via their proprietary API. When moving to a VPS, you need to ensure the sharp library is installed in the system. Next.js will automatically start using it to resize and convert images to WebP/AVIF on the fly.

npm install sharp

Netlify migration: moving SvelteKit and Nuxt

When performing a netlify migration, developers often find they were using specific Netlify plugins (Forms, Identity, Functions). On a VPS, these features will need to be replaced with Open Source alternatives or custom microservices.

Adapters for SvelteKit and Nuxt

In the Jamstack ecosystem, frameworks use adapters for deployment. To move from Netlify to a VPS, you need to change the adapter:

1. In SvelteKit: replace @sveltejs/adapter-auto or @sveltejs/adapter-netlify with @sveltejs/adapter-node.
2. In Nuxt: ensure the build is set to the node-server preset in nuxt.config.ts.

// nuxt.config.ts
export default defineNuxtConfig({
  nitro: {
    preset: 'node-server'
  }
})

If you previously used Heroku for your Jamstack application's backend, you will find our guide how to migrate from Heroku to VPS in 2026 useful, as the principles of managing Node.js processes are similar there.

Infrastructure Setup on VPS: Docker and Nginx

To create a complete jamstack vps environment, it is recommended to use Docker. This ensures that your application will run identically on your local machine and on the Valebyte server.

Dockerfile Example for a Modern JS Framework

Below is a universal Dockerfile optimized for Next.js or Nuxt:

FROM node:20-alpine AS base

FROM base AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci

FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM base AS runner
WORKDIR /app
ENV NODE_ENV production
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static

EXPOSE 3000
CMD ["node", "server.js"]

Nginx Configuration as a Reverse Proxy

Nginx will accept incoming traffic on ports 80/443 and forward it to the Docker container. This also allows for easy SSL setup via Let's Encrypt.

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;
    }
}

For projects requiring high computing power, such as data processing or ML inference, it is worth considering Bare-metal vs VPS for ML inference on CPU to get the most out of the hardware.

CI/CD Automation: Replacing "Push to Deploy"

One of the main advantages of Vercel is automatic deployment upon pushing to GitHub. On a VPS, this is implemented via GitHub Actions or GitLab CI. The process looks like this:

1. You push code to the repository.
2. GitHub Action builds the Docker image.
3. The image is pushed to a Docker Registry (e.g., GitHub Packages).
4. The Action connects to your VPS via SSH and runs docker-compose pull && docker-compose up -d.

This takes 1-2 minutes longer than on Vercel but gives you full control over the build and testing process. You are no longer dependent on the PaaS provider's build queues, which can be overloaded during peak hours.

Performance: Edge vs Centralized VPS

It is often said that Vercel's Edge functions are faster due to proximity to the user. However, in practice, this is only true for static content. If your application actively works with a database located in one region (e.g., Germany or the USA), an Edge function from Singapore will still make a request to that database, creating significant latency (TTFB).

Hosting an application on a powerful VPS in the same data center as your database often yields better results for dynamic applications. You eliminate network latency between "function" and "data". If you are migrating from cloud solutions like AWS, we recommend reading how to migrate from AWS Lightsail to VPS in 2026.

Security and Monitoring After Migration

By moving to a VPS, you take responsibility for OS security. Minimum set of actions:

• Disable SSH password login (keys only).
• Configure a firewall (UFW or iptables), opening only ports 22, 80, and 443.
• Install Fail2Ban to protect against brute-force attacks.
• Regularly update packages (apt update && apt upgrade).

For monitoring, you can use simple solutions like Uptime Kuma (a self-hosted alternative to UptimeRobot) or a Prometheus + Grafana stack to track CPU and RAM load in real-time.

Conclusions

Migration from Vercel or Netlify to a VPS is justified for any project with traffic exceeding 500 GB per month or when specific system software is required. The optimal choice for such a move is a VPS with 4 GB of RAM and an NVMe drive, which will ensure stable operation of Next.js/Nuxt applications without the limitations of Serverless architecture.