Serverless vs VPS in 2026: The Real Cost & Performance Comparison

The serverless vs VPS debate, settled with data

The “serverless vs VPS” question is one of the most common architectural decisions developers face in 2026. Serverless platforms like AWS Lambda, Vercel Functions, and Cloudflare Workers promise zero infrastructure management. VPS providers like Hetzner, DigitalOcean, and Vultr offer raw compute at a fixed monthly cost. Both are valid choices, but they serve fundamentally different use cases.

This guide compares them on the metrics that actually matter: real-world cost at different traffic levels, request latency including cold starts, architectural constraints, and total cost of ownership. By the end, you will know exactly which option fits your project.

What is serverless?

Serverless computing runs your code in ephemeral containers managed by a cloud provider. You write a function, deploy it, and the provider handles provisioning, scaling, and OS patches. You are billed per invocation and execution duration rather than a monthly fee for a running server.

Popular serverless platforms include AWS Lambda, Google Cloud Functions, Azure Functions, Vercel Functions, and Cloudflare Workers. Each function typically handles a single HTTP request, runs for a limited duration (usually 10-30 seconds max), and is stateless between invocations.

// A typical serverless function
// Each request spins up a new (or reused) container
export default async function handler(req, res) {
  const { userId } = req.query;

  // Cold start: 200-1500ms if container is not warm
  const user = await db.query("SELECT * FROM users WHERE id = $1", [userId]);

  // Function exits after response — no persistent state
  res.status(200).json({ user });
  // Container may be destroyed after this
}

What is a VPS?

A Virtual Private Server (VPS) is a dedicated virtual machine that runs 24/7 on a physical server. You get allocated CPU cores, RAM, and storage with full root access. Your application process runs continuously, ready to serve requests instantly with no cold starts.

VPS providers include Hetzner (starting at $4.50/mo), DigitalOcean ($6/mo), Vultr ($5/mo), and Linode ($5/mo). You typically get 1-2 vCPUs, 1-2GB RAM, 20-50GB SSD, and 20TB+ monthly bandwidth. That is more than enough to handle hundreds of thousands of requests per month.

// Traditional server — always running, no cold starts
import express from "express";

const app = express();

// Process starts once, stays in memory
app.get("/api/user/:id", async (req, res) => {
  // No cold start — handler executes immediately
  const user = await db.query("SELECT * FROM users WHERE id = $1", [req.params.id]);
  res.json({ user });
});

// Persistent connections work natively
app.ws("/live", (ws) => {
  ws.on("message", (msg) => ws.send(`Echo: ${msg}`));
});

app.listen(3000, () => console.log("Server running on port 3000"));
// Process runs 24/7 — no timeout limits

Cost comparison: serverless vs VPS at scale

This is where the serverless vs VPS debate gets real. Serverless pricing looks cheap at low volumes, but costs grow linearly with traffic. A VPS costs the same whether you serve 1,000 or 1,000,000 requests. Here are real numbers from major providers as of March 2026.

* Vercel Pro plan is $20/mo base — see our Vercel pricing breakdown for details. Lambda pricing assumes 128MB memory, 200ms avg duration. All prices exclude bandwidth egress and database costs. Cloudflare Workers free tier includes 100K req/day.

Performance comparison: cold starts vs always-on

Performance is where VPS hosting has the clearest advantage. A VPS process is always running, so every request hits a warm server. Serverless functions may need to boot up from scratch on each invocation if the container has gone cold.

Cold start latency by runtime

Cold starts vary significantly by language and bundle size. Here are measured cold start times on AWS Lambda with 256MB memory as of early 2026:

When to use serverless

Serverless is not universally bad. It excels in specific scenarios where its strengths align with your requirements. Here is when serverless is the right choice:

When to use a VPS

A VPS is the better choice for the majority of web applications, APIs, and SaaS products. Here is when you should choose a VPS over serverless:

The same Express app: serverless vs VPS deployment

To make the comparison concrete, here is the same Express API deployed two different ways. The application code is nearly identical, but the deployment model and runtime behavior differ significantly.

1Deployed as a Vercel Serverless Function

import express from "express";
import { PrismaClient } from "@prisma/client";

const app = express();
app.use(express.json());

// WARNING: New Prisma client on every cold start
// Each cold start opens a new DB connection pool
const prisma = new PrismaClient();

app.get("/api/posts", async (req, res) => {
  const posts = await prisma.post.findMany({
    take: 20,
    orderBy: { createdAt: "desc" },
  });
  res.json(posts);
});

app.post("/api/posts", async (req, res) => {
  const post = await prisma.post.create({ data: req.body });
  res.status(201).json(post);
});

// Vercel wraps this — each request may cold-start
export default app;

// Limitations:
// - 10s execution limit (Pro: 60s)
// - No WebSocket support
// - No cron jobs or background workers
// - New DB connection pool per cold start
// - Max 250MB function bundle size

2Deployed on a VPS with PM2

import express from "express";
import { PrismaClient } from "@prisma/client";
import { WebSocketServer } from "ws";
import cron from "node-cron";

const app = express();
app.use(express.json());

// Single Prisma client — connection pool stays warm
const prisma = new PrismaClient();

app.get("/api/posts", async (req, res) => {
  const posts = await prisma.post.findMany({
    take: 20,
    orderBy: { createdAt: "desc" },
  });
  res.json(posts);
});

app.post("/api/posts", async (req, res) => {
  const post = await prisma.post.create({ data: req.body });
  // Notify connected WebSocket clients
  wss.clients.forEach((client) => client.send(JSON.stringify(post)));
  res.status(201).json(post);
});

const server = app.listen(3000, () => console.log("Running on port 3000"));

// WebSockets — works natively on VPS
const wss = new WebSocketServer({ server });
wss.on("connection", (ws) => {
  ws.send(JSON.stringify({ type: "connected" }));
});

// Cron jobs — run background tasks on schedule
cron.schedule("0 * * * *", async () => {
  console.log("Hourly cleanup job running...");
  await prisma.session.deleteMany({
    where: { expiresAt: { lt: new Date() } },
  });
});

// No execution time limits
// No cold starts
// Persistent DB connection pool
// Native WebSocket support
// Background jobs with cron

# Install PM2 globally
npm install -g pm2

# Start the app with auto-restart
pm2 start server.js --name my-api

# Enable startup on reboot
pm2 startup && pm2 save

# View logs
pm2 logs my-api

Migration guide: serverless to VPS

Outgrowing serverless is common. Rising costs, cold start frustrations, or the need for WebSockets and background jobs are the typical triggers. Here is how to migrate your serverless application to a VPS step by step.

server {
    listen 80;
    server_name api.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# After running: sudo certbot --nginx -d api.yourdomain.com
# Certbot will auto-add SSL configuration

Architecture comparison at a glance

Here is how a typical SaaS application stack looks when deployed on serverless versus a VPS:

VPS pricing based on Hetzner CX22 ($4.50/mo) or DigitalOcean Basic ($6/mo). Serverless pricing based on moderate usage (500K req/mo). All services on the VPS share a single server.

The verdict: which should you choose?

There is no universal answer, but the data points to a clear pattern. Here is a decision framework based on your specific situation:

For most web applications, APIs, and SaaS products in 2026, a VPS delivers better performance at a fraction of the cost. The main objection to VPS hosting has always been the operational burden of managing servers, deployments, and SSL. Tools like DeployWise eliminate that objection by giving you Vercel-like push-to-deploy on your own VPS, for free.

Frequently asked questions