Vercel is genuinely good at what it was built for: push a Next.js repo, get a globally distributed deployment with preview URLs in under a minute. People do not leave because it stopped working. They leave for three reasons: the Hobby tier is restricted to personal, non-commercial use; Pro starts at $20 per user per month plus uncapped usage pricing (Fluid compute CPU at $0.128/hour, image transformations at $0.05 per 1K, ISR reads at $0.40 per 1M - each its own meter); and the backend simply is not there. The moment your app needs a real database, a queue, or a background worker, you are assembling a second stack of SaaS bills on top of Vercel.
So this comparison judges each alternative by the three things that actually change when you migrate: what happens to your Next.js app, what happens to your backend, and what happens to your bill. Disclosure: Miget is our product and we list it first - the numbers for every platform come from their own pricing pages (as of July 2026; check current pages before deciding).
Quick Comparison
| Platform | Next.js SSR | Backend (DB, workers, queues) | Pricing model | Free tier |
|---|---|---|---|---|
| Miget | Yes (Node process, no serverless caps) | PostgreSQL, MySQL, Valkey, RabbitMQ, Kafka included ($0) | Fixed monthly plan, unlimited apps | Yes (256 MiB) |
| Netlify | Yes (via adapter/functions) | External SaaS only | Credit-based: $9-$20/mo + usage credits | Yes (300 credits) |
| Cloudflare Workers | Yes (OpenNext adapter) | D1, KV, Durable Objects, Queues | $5/mo + generous metered usage | Yes (100K req/day) |
| Render | Yes (Node service) | Managed Postgres ($6+), Redis ($10+) | Per-service from $7/mo | Yes (sleeps after 15 min) |
| Railway | Yes (Node service) | Usage-based databases | Per vCPU/GB-second | One-time $5 credit |
| Coolify | Yes (Docker on your server) | Anything Docker runs | Free self-hosted; Cloud $5/mo + your VPS | Self-hosted is free |
| GitHub Pages | Static export only | None | Free | Yes |
1. Miget - the backend stops being a second bill
What replaces what: serverless functions become a plain Node process (next start, no execution-time caps); the Neon + Upstash + cron-service constellation becomes managed databases included in your plan; per-seat pricing becomes one fixed compute plan your whole team shares.
The structural difference is that Miget prices compute, not people or requests. You buy a plan (from $5/month for 512 MiB / 1 vCPU) and run unlimited apps inside it: your Next.js frontend, your API, your workers, and your databases - PostgreSQL, MySQL, Valkey (Redis-compatible), RabbitMQ, and Kafka ship included at $0. Deploys come from a Git push with zero-config builds (Migetpacks detect Next.js automatically), a Dockerfile, or a docker-compose file, and preview environments are included without limit. Every workload runs in its own MicroVM rather than a shared container.
Being a regular Node process cuts both ways. Long-running SSR, WebSockets, ISR with a persistent cache, and 10-minute background jobs all just work - there is no 120-second function ceiling. But your app serves from the region you deploy in (EU or US), not from an edge network in 100 cities. For most dashboards, SaaS apps, and APIs that difference is invisible; for a content site where every millisecond of global TTFB matters, put a CDN in front or pick a static host.
- Strengths: flat predictable bill, no per-seat pricing, databases and queues included, no serverless limits, preview environments included, free tier exists
- Weaknesses: no global edge network (single region per app today), no marketplace of one-click integrations
- Best for: full-stack Next.js apps whose Vercel bill is really a Vercel + Neon + Upstash + seats bill
Full teardown with costed scenarios: Miget vs Vercel.
2. Netlify - the closest workflow match
What replaces what: Vercel's Git-native deploys and previews map almost one-to-one; functions run on Netlify's own runtime with framework adapters for Next.js.
Netlify recently moved to credit-based pricing: the free tier includes 300 credits, the $9/month Personal plan 1,000, and the $20/month Pro plan 3,000 - with usage drawing them down (a production deploy costs 15 credits, bandwidth 20 credits per GB, compute 10 credits per GB-hour). The workflow is excellent and the free tier is real, but the meter logic is the same as Vercel's: success means a growing bill, and your database still lives somewhere else.
- Strengths: most familiar DX for Vercel refugees, real free tier, strong forms/identity/edge primitives
- Weaknesses: same usage-meter economics, no backend services of its own
- Best for: marketing sites and Jamstack apps that want Vercel's workflow without Vercel's Next.js lock-in perception
3. Cloudflare Workers - the cheapest serious serverless
What replaces what: functions move to V8 isolates via the OpenNext adapter; your backend can move into Cloudflare's own primitives (D1 for SQL, KV, Durable Objects, Queues, R2 for storage).
The paid plan is $5/month with 10 million requests and 30 million CPU-milliseconds included, no bandwidth charges at all, and a free tier of 100,000 requests per day that is genuinely usable in production. That is the best raw price on this list by a wide margin. The cost is architectural: D1 and Durable Objects are not Postgres, the isolate runtime is not Node (native modules and long-lived connections need care), and running standard Next.js requires the OpenNext adapter with its documented compatibility gaps.
- Strengths: unbeatable price, true global edge, no egress fees, backend primitives exist
- Weaknesses: not-quite-Node runtime, adapter friction for Next.js, backend means rewriting for Cloudflare's primitives rather than bringing your Postgres
- Best for: teams willing to build Cloudflare-native for the economics and the edge
4. Render - per-service simplicity
What replaces what: your Next.js app becomes a Node web service ($7/month Starter, 512 MB); your backend becomes Render's managed Postgres ($6+/month) and Redis ($10+/month); previews and Git deploys are built in.
Render is what Heroku used to feel like, and for a Next.js app that outgrew serverless it is a comfortable landing: no function limits, real processes, per-service pricing you can predict. The bill grows a line item at a time - web service, worker, Postgres, Redis each priced separately - and the free tier spins down after 15 minutes of inactivity, so it demos rather than hosts.
- Strengths: predictable per-service pricing, managed Postgres/Redis in-house, familiar workflow
- Weaknesses: line items compound as the stack grows, free tier sleeps
- Best for: small full-stack apps that want managed databases without usage meters
We compared it in depth in Best Render Alternatives.
5. Railway - usage-based, but for containers
What replaces what: functions become containers billed per vCPU and GB-second; databases are one-click templates billed the same way; the dashboard is the best-looking in the category.
Railway's model is Vercel's meter applied to containers: you pay for what runs, which is great for spiky side projects and painful for always-on production (an SSR app that must stay warm is the worst case for per-second billing). There is no ongoing free tier - a one-time $5 credit - and cost forecasting requires understanding your app's resource curve, not just its traffic.
- Strengths: excellent DX, deploy anything containerized, huge template catalogue
- Weaknesses: usage-based pricing means variable bills, no standing free tier
- Best for: prototypes and teams comfortable modeling usage costs
6. Coolify - own the whole stack
What replaces what: Vercel becomes a dashboard you host yourself; deploys, previews, and databases all run as Docker containers on your own VPS.
Coolify is open source and free self-hosted; Coolify Cloud manages the control plane for $5/month (plus $3 per additional server) while your apps still run on servers you bring - a $6 Hetzner box gives you a complete Next.js + Postgres stack for under $12/month all-in. The trade is that you are now the platform team: OS updates, backups, monitoring, and the 3 a.m. disk-full page are yours.
- Strengths: cheapest possible production stack, no vendor limits, full data ownership
- Weaknesses: you own uptime, security patching, and backups
- Best for: technical teams that want PaaS ergonomics at VPS prices and accept the ops load
7. GitHub Pages - if your site is actually static
What replaces what: nothing runs at request time. next export static output, docs, and landing pages get free hosting with a custom domain and SSL.
This is the honest bottom rung: if your "app" is actually a static site that never needed SSR, a large share of Vercel's value (and bill) disappears. No functions, no ISR, no previews beyond branch workflows you assemble yourself - but also no invoice, ever.
- Strengths: free, boring, reliable
- Weaknesses: static only; the moment you need SSR or an API you are back to shopping
- Best for: docs, blogs, and landing pages mistakenly living on a Pro plan
How to choose
Three questions settle it:
- Is your site actually static? GitHub Pages or Netlify's free tier - stop paying for SSR you do not use.
- Is your app full-stack with a real database? The meter platforms make you assemble Vercel + Neon + Upstash + a queue. Miget includes that stack in one fixed plan; Render sells it as line items; Coolify gives it to you at VPS prices if you bring the ops.
- Do you need global edge above all? Cloudflare Workers is the only alternative here that matches Vercel's network - if you can build for its runtime.
If the reason you are reading this is a Vercel invoice that doubled without traffic doubling, start with the Miget vs Vercel teardown - it walks through the same app costed on both platforms, seat by seat and meter by meter.