Vercel vs Docker: The $3,000 Hosting Mistake

You deployed your Next.js app to Vercel. It worked perfectly. The free tier handled development. Pro tier seemed reasonable at $20/month per seat.

Then a spike in traffic hit. Or a build ran too long. Or you accidentally left bandwidth-heavy assets on the wrong plan.

You opened your Vercel dashboard to a $3,000 bill.

This isn't a one-off horror story. It happens regularly. And for startups running lean, a single billing mistake can wipe out a month's runway.

Let's look at the real costs of Vercel, why they add up so fast, and how to deploy the same app on Docker for $7/month.

Vercel Pricing: What You're Actually Paying

Vercel's pricing looks simple. It isn't.

Free tier ($0/month):

• 100GB bandwidth
• Serverless function execution included
• Automatic deployments from Git
• Great for prototypes and personal projects

Pro tier ($20/month per seat):

• 1TB bandwidth
• 1,000GB-hours of serverless function execution
• Custom domains, analytics
• This is where most startups land

Enterprise: Custom pricing. Not relevant for most vibe-coded projects.

The problem isn't the base price. It's the overages.

Vercel charges $0.15 per GB for bandwidth overages. That doesn't sound like much until you do the math:

• A Next.js page with optimized images: ~200KB per visit
• 10,000 page views/day: 2GB/day = 60GB/month
• 100,000 page views/day: 20GB/day = 600GB/month

At 100K daily page views, you're using 600GB/month of bandwidth. The Pro tier includes 1TB, so you're still okay. But add API routes, image optimization, and serverless function invocations, and you hit limits fast.

One Reddit user reported: "$237 in 6 days for moderate traffic." Another shared the ultimate bill shock: "$3,000 bill from a small mistake." These aren't edge cases — they're predictable consequences of Vercel's pricing model applied to real-world usage.

Why Vercel Costs Add Up So Fast

The base tier is the tip of the iceberg. Here's where the hidden costs come in:

Build Minutes

Vercel includes build minutes in your plan, but heavy Next.js applications (especially with large images or complex build steps) can eat through them. Excess build minutes are billed per-minute.

Serverless Function Duration

Every API route, every server-side render, every middleware execution uses function duration. Vercel charges for compute time beyond your plan limits. A slow database query that takes 5 seconds per request? At 100K requests/day, that adds up.

Bandwidth Overages

The killer. Vercel charges $0.15/GB for overages. That's $150/month for every 1TB over your limit. A viral blog post, a product launch, a spike in organic traffic — any of these can push you over.

Image Optimization

Next.js image optimization runs on Vercel's edge network. Each optimization request counts against your bandwidth and compute limits. If you're optimizing hundreds of images per page load, you're paying for it.

Analytics

Vercel Analytics is $20/month for the first 10,000 events. Web Vitals tracking, audience metrics, custom events — all billed separately. Use Google Analytics instead and save the subscription.

The Multiplier Effect

These costs don't just add — they multiply. A traffic spike increases bandwidth, which increases function invocations, which increases build minutes if you're doing ISR (Incremental Static Regeneration). Everything compounds.

The analysis is clear: "Vercel is ~30x more expensive than self-hosted" for the same workload. That's not hyperbole — it's math.

The Alternative: Docker + Hetzner

Here's the move that saves startups $3,000+/year.

Hetzner CX22: $6.50/month

• 2 vCPU, 4GB RAM
• 40GB SSD storage
• Unmetered bandwidth (fair use)

Coolify: Free and open-source

• Docker-based deployment platform
• Manage containers, databases, and networking
• Web UI for deployment management

Together, they replace everything Vercel does at a fraction of the cost.

Real Migration Story

One Reddit user shared their migration: "$300/mo Vercel → $7/mo Hetzner + Coolify." That's a 97% cost reduction. The app performance stayed the same. The user experience didn't change. The only difference was where the bill went.

Step-by-Step: Migrating from Vercel to Docker

Here's how to move your Next.js app from Vercel to a VPS with Docker.

Step 1: Set Up the Server

# SSH into your Hetzner server
ssh root@your-server-ip


curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

Coolify gives you a web interface at https://your-server-ip:8000. Set up your account and you're ready to deploy.

Step 2: Containerize Your App

Create a Dockerfile in your project:

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/static ./.next/static

EXPOSE 3000
ENV PORT=3000
CMD ["node", "server.js"]

Add a next.config.js output setting:

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

Step 3: Deploy via Coolify

Push your code to GitHub

In Coolify, add a new application

Connect your GitHub repo

Set environment variables (same ones you had in Vercel)

Coolify builds and deploys automatically

Step 4: Set Up SSL and Domain

Coolify integrates with Let's Encrypt for free SSL certificates. Add your domain in the Coolify dashboard and it handles the rest.

Step 5: Set Up a Database

If your app uses a database, add it as a separate Docker container in Coolify. Postgres, MySQL, MongoDB — all available as one-click additions.

Step 6: Configure Backups

Set up automated backups with a cron job:

# Backup Postgres daily
0 2   * docker exec postgres-container pg_dump -U user dbname | gzip > /backups/db-$(date +%Y%m%d).sql.gz

Or use Coolify's built-in backup features if you're on a paid plan.

Cost Comparison: Vercel vs Docker

The Vercel number depends on traffic and overages. The Hetzner number is fixed. For a startup watching every dollar, that predictability matters.

When Vercel Actually Makes Sense

Vercel isn't bad. It's just expensive for what you get. There are legitimate reasons to stay on Vercel:

You're a solo dev who values time over money. If deploying to Vercel saves you 5 hours/month and your time is worth $100/hour, that's $500 of value. Vercel costs $20/month. The math works. You need edge functions and global CDN. Vercel's edge network is genuinely fast. If your app serves users worldwide and latency matters, Vercel's infrastructure is hard to replicate on a single VPS. You're on the free tier. If you're pre-revenue and traffic is low, the free tier is fine. Upgrade when you hit limits, not before. Your team can't manage infrastructure. If your team is three non-technical co-founders, Vercel's managed platform removes a distraction.

But if you're watching costs, have basic Linux skills, and your app doesn't need edge functions — Docker on a VPS is the move.

Beyond Vercel: Other Self-Hosted Options

Vercel isn't the only expensive option. Here are other alternatives:

Netlify → Docker

Netlify's pricing model is similar to Vercel. Bandwidth overages, function invocations, build minutes — all billed separately. Same Docker migration works.

AWS Amplify → Docker + ECS

AWS Amplify simplifies deployment but charges per build minute and per GB served. For simple apps, it's more expensive than running ECS directly.

Firebase → Postgres on VPS

Firebase's pricing tiers are confusing and expensive at scale. If your app uses Firestore or Realtime Database, consider migrating to Postgres on a VPS.

The Hidden Cost of Vendor Lock-In

Every managed service creates lock-in. Vercel is no exception.

If you're using Vercel's edge functions, middleware, image optimization, and analytics, migrating away becomes harder over time. The code you wrote works on Vercel but doesn't work on a VPS.

The smart approach: write your app to be platform-agnostic. Use standard Node.js server patterns. Avoid Vercel-specific APIs where possible. That way, you can deploy to Vercel now and migrate to Docker later without rewriting code.

Performance: Does Self-Hosted Actually Work?

The biggest objection to self-hosting is performance. "Vercel is fast because of their CDN and edge network."

Reality: for most apps, the performance difference is negligible.

A Next.js app running on a single Hetzner server with nginx as a reverse proxy serves pages in under 200ms for users in the same region. Add Cloudflare as a CDN (free tier) and you get global edge caching without paying Vercel prices.

The apps that benefit from Vercel's edge network are:

• Global SaaS products serving users in 50+ countries
• Real-time collaborative tools needing sub-50ms latency
• E-commerce sites where milliseconds affect conversion

If your app serves users primarily in one region, a VPS is fine. If you need global edge performance, use Cloudflare Workers instead of Vercel's proprietary edge functions.

FAQ

How long does it take to migrate from Vercel to Docker?

For a standard Next.js app: 2-4 hours. The actual migration is straightforward — containerize the app, set up Coolify, deploy. The time goes into testing and making sure everything works the same way.

Will I lose performance switching from Vercel?

For most apps, no. You'll lose Vercel's global CDN and edge network. If your users are in one region, the difference is negligible. If you need global edge caching, add Cloudflare in front of your VPS.

What about database hosting on VPS?

You can run Postgres, MySQL, or MongoDB in Docker containers alongside your app. Coolify makes this easy — just add a database service in the dashboard. Back up with automated cron jobs.

Is Docker hard to learn?

If you've never used Docker, expect a learning curve of 1-2 days. The basics — building images, running containers, managing networks — are straightforward. Coolify abstracts most of the complexity.

Can I still use GitHub deployments?

Yes. Coolify connects to your GitHub repository and deploys automatically on push. It's the same workflow as Vercel — push code, get a deployment. You just control the infrastructure.