Vercel vs Railway vs Render: SaaS Deploy Costs 2026
Vercel vs Railway vs Render: Where to Deploy Your SaaS in 2026 (Costs Compared)
Platform comparison articles list features. This one leads with money — specifically, what Vercel, Railway, and Render actually cost at each stage of a SaaS business, and where the pricing model breaks.
At pre-revenue: all three are effectively free. At $10K MRR, the differences matter. At $100K MRR, the platform choice is a significant line item. Here's the exact math.
TL;DR
Vercel is the default for Next.js SaaS — zero-config deployment, the best edge network, and free until you scale. Railway is the best value when your app needs always-running processes (workers, cron jobs, WebSockets, Docker) that don't fit Vercel's serverless model. Render splits the difference — managed Postgres, background workers, and a free tier (with sleep) for evaluation. At $10K MRR, Railway is typically 30–50% cheaper than Vercel for full-stack apps; at $100K MRR, custom infrastructure (Coolify on Hetzner) often wins.
Key Takeaways
- Vercel Free: 100 GB bandwidth, 100 deploys/day, serverless functions (unlimited executions, 10s timeout)
- Vercel Pro: $20/user/month, 1 TB bandwidth, 300s function timeout, preview deployments
- Railway: $5/month Starter (5 USD included), $20/month Pro (20 USD included), pay-for-what-you-use beyond
- Render: free tier (apps sleep after 15min inactivity), $7/month Starter per service, managed Postgres $7–97/month
- Cold starts: Vercel serverless ~200ms; Railway (always-on) 0ms; Render free tier 30–60s (sleeping)
- Postgres included: Vercel (no, use Neon); Railway (yes, native); Render (yes, managed)
Pricing Models: The Key Structural Difference
Understanding how each platform bills prevents surprises:
Vercel: Per-seat ($20/user/month) plus consumption (bandwidth, function executions, edge requests). The seat-based model is cheap for solo founders ($20/month) but expensive for teams (5 developers = $100/month just for the platform).
Railway: Per-resource consumption. You pay for vCPU-seconds, RAM-GB-seconds, and networking. No per-seat fees. More predictable for compute-heavy workloads, potentially expensive for high-memory apps.
Render: Hybrid — per-service flat rate for web services plus consumption for bandwidth. Postgres is flat-rate per tier. More predictable billing, less granular control.
Cost at Pre-Revenue (0 MRR)
Vercel Free Tier
$0/month includes:
- Serverless functions: unlimited invocations
- Bandwidth: 100 GB/month
- Builds: 6,000 minutes/month
- Deployments: unlimited (100/day limit)
- Edge functions: 500K requests/month
- Preview deployments: ✓ (per branch)
- Custom domain: ✓
- SSL: ✓
- Team members: 1 (need Pro for multiple)
For a Next.js SaaS in early development, Vercel's free tier is genuinely sufficient. The 100 deploy/day limit is the only meaningful constraint — automated CI/CD hitting this limit requires Pro.
Railway Starter ($5/month)
$5/month (which includes $5 in resource credits) covers:
- Web service: ~$2-4/month (0.5 vCPU, 512MB RAM)
- PostgreSQL: ~$1-2/month (512MB RAM, 1 GB disk)
- Total typical usage: $3-6/month
= $0 out-of-pocket with included credits
Railway's Starter plan provides $5 in credits monthly — covering a basic web service + database with nothing leftover.
Render Free Tier
$0/month includes:
- Web service: 1 (sleeps after 15 min inactivity)
- PostgreSQL: 90-day expiry on free tier
- Build minutes: 400/month
Critical limitation: Render's free web services sleep after 15 minutes of inactivity and take 30–60 seconds to wake. For a SaaS product, this is unacceptable — your first user every day hits a 30-second load time. Render free is useful for side projects only.
Recommendation at pre-revenue: Vercel Free for Next.js SaaS. Add Neon for Postgres ($0). Total: $0/month.
Cost at $1,000 MRR
At $1K MRR, you have 30–100 active users and need:
- Always-available application (no sleeping)
- Reliable Postgres
- At least one background worker (email queue, webhook processing)
Vercel Pro + Neon
Vercel Pro: $20/month (1 developer)
Neon Launch: $19/month
Better Auth: $0
Resend: $20/month (50K emails)
Total: $59/month
% of MRR: 5.9%
Background workers are the problem: Vercel doesn't run persistent processes. You'd need Trigger.dev ($25/month Starter) or Inngest ($0–12/month) for background jobs.
Vercel Pro: $20
Neon Launch: $19
Trigger.dev Starter: $25
Resend: $20
Total: $84/month
% of $1K MRR: 8.4%
Railway Pro
Railway Pro: $20/month base
Web service (1 vCPU, 1GB RAM): ~$15/month
PostgreSQL (shared): ~$5/month
Background worker: ~$8/month (0.5 vCPU, 256MB)
Redis (for queues): ~$3/month
Resend: $20/month
Total: ~$71/month
% of $1K MRR: 7.1%
Railway's all-in-one model is cheaper when you include background workers + Redis. You deploy your own queue (BullMQ on Redis) instead of paying for Trigger.dev.
Render Starter
Web service (Starter): $7/month
PostgreSQL (Starter): $7/month
Background worker (Starter): $7/month
Redis (Starter): $10/month
Resend: $20/month
Total: $51/month
% of $1K MRR: 5.1%
Render is cheapest at this tier — flat-rate per service means predictable billing and decent value at $1K MRR.
Winner at $1K MRR: Render at $51/month. Caveat: less ecosystem support for Next.js than Vercel; more manual configuration than Railway.
Cost at $10,000 MRR
At $10K MRR, you have 300–1,000 active users and significantly higher traffic and compute requirements.
Vercel Pro (2 developers + higher usage)
Vercel Pro: $40/month (2 developers)
Additional bandwidth: $40/month (estimated 300 GB)
Neon Scale: $69/month
Trigger.dev Pro: $100/month
Resend: $90/month (500K emails)
Total: $339/month
% of $10K MRR: 3.4%
Vercel's serverless model scales well — you don't pay for idle compute. But the seat pricing, bandwidth overages, and third-party services add up.
Railway Pro (2 developers)
Railway Pro: $40/month (2 developers)
Web services (2x 2 vCPU, 2GB): ~$80/month
PostgreSQL (2GB RAM, 20GB): ~$30/month
Background workers (2x): ~$20/month
Redis: ~$8/month
Resend: $90/month
Total: ~$268/month
% of $10K MRR: 2.7%
Railway runs 22% cheaper at $10K MRR. The gap comes from:
- Railway's compute pricing at scale vs Vercel's per-seat + bandwidth
- Built-in PostgreSQL and Redis eliminate external service costs
- Always-on processes avoid cold start costs of repeated function invocations
Render Scale Tier
Web services (2x Pro): $85/month
PostgreSQL (Standard): $97/month
Workers (2x): $85/month
Redis: $35/month
Resend: $90/month
Total: $392/month
% of $10K MRR: 3.9%
Render's flat-rate pricing becomes expensive at this tier — you're paying for compute you may not fully use. Render Standard's fixed resources mean paying for peak capacity even during off-peak hours.
Winner at $10K MRR: Railway at $268/month. Vercel's edge network advantage doesn't justify the ~$71/month premium for most SaaS apps at this scale.
Cost at $100,000 MRR
At $100K MRR, infrastructure spending deserves serious optimization.
Vercel Enterprise (estimated)
Vercel Enterprise: $400–1,000/month (custom pricing)
Advanced features: SSO, SLA, dedicated support
Neon Business: $700/month
Background jobs: $250/month (Trigger.dev Enterprise)
Email: $400/month (Resend or Postmark)
Total: ~$1,750–2,350/month
% of $100K MRR: 1.75–2.35%
Railway Scale
Railway Pro: variable (high compute at this scale)
Compute (5 web services, workers): ~$300/month
PostgreSQL (large): ~$100/month
Redis: ~$25/month
Email: ~$400/month
Total: ~$825/month
% of $100K MRR: 0.83%
Self-Hosted on Hetzner (Coolify)
Hetzner CPX51 (16 vCPU, 32GB RAM): €79/month
Hetzner volumes (500 GB): €25/month
Cloudflare (Pro): $20/month
Email: $400/month
Ops time (5h/month at $100/hour): $500/month
Total: ~$1,024/month (including ops time)
% of $100K MRR: 1.02%
Self-hosted is slightly more expensive than Railway once ops time is included — but you have full control, no vendor lock-in, and the ability to optimize specific workloads.
Winner at $100K MRR: Railway on pure cost. Self-hosted wins if you value operational control or have infrastructure expertise in-house.
Technical Feature Comparison
| Feature | Vercel | Railway | Render |
|---|---|---|---|
| Zero-config Next.js | ✓ (best) | ✓ | ✓ |
| Serverless functions | ✓ | Via Docker | Limited |
| Always-on processes | ✗ (serverless only) | ✓ | ✓ |
| Built-in Postgres | ✗ (use Neon) | ✓ | ✓ |
| Built-in Redis | ✗ | ✓ | ✓ |
| Docker support | ✗ | ✓ | ✓ |
| Preview deployments | ✓ | ✓ | ✓ |
| Edge network | ✓ (best — 100+ PoPs) | Limited | Limited |
| Cold starts | ~200ms | 0ms (always-on) | 0ms (paid) / 30–60s (free) |
| GitHub integration | ✓ | ✓ | ✓ |
| Monorepo support | ✓ | ✓ | Partial |
| Custom domains | ✓ | ✓ | ✓ |
| SSL | ✓ | ✓ | ✓ |
| WebSockets | ✗ (serverless limit) | ✓ | ✓ |
| Cron jobs | ✓ (Vercel Cron) | ✓ | ✓ |
| SLA | 99.99% (Enterprise) | 99.9% | 99.95% |
The Vercel Trap
Vercel is excellent for Next.js apps with standard request/response patterns. It struggles with:
WebSockets: Vercel's serverless model doesn't support long-lived connections. If your SaaS needs real-time features (chat, live collaboration, presence indicators), you need Railway, Render, or a separate WebSocket service (Ably, Pusher, PartyKit).
Background workers: Serverless functions time out after 300s (Pro). Long-running background jobs need an external service (Trigger.dev, Inngest) — an extra $25–100/month that Railway/Render include for free.
Database: Vercel doesn't provide Postgres. You need Neon, Supabase, or another external provider. Railway and Render include managed Postgres.
Per-seat pricing: At 5+ developers, Vercel Pro costs $100/month just for the platform. Railway's compute-based pricing is developer-count-agnostic.
Decision Guide
Choose Vercel if:
- Purely serverless Next.js app (no persistent processes, no WebSockets)
- Edge performance is a product differentiator (landing pages, global API latency)
- You're on the free tier and not yet hitting limits
- Preview deployments per branch are critical to your workflow
- You want the best Next.js deployment experience with zero configuration
Choose Railway if:
- Full-stack app with workers, queues, and real-time features
- You want to minimize third-party service count (built-in Postgres + Redis)
- Team has 2+ developers (Railway's compute-based pricing is cheaper than Vercel's per-seat)
- Docker-based deployment or non-Node.js services in your stack
- $10K+ MRR where cost optimization starts to matter
Choose Render if:
- Simpler pricing model matters more than optimization
- You want managed Postgres included without Railway's variable billing
- Free tier evaluation (accepting the sleep limitation)
- You don't need Vercel's edge network or Railway's real-time capabilities
Brief Mention: Fly.io and Cloudflare Workers
Two platforms that don't fit neatly in the three-way comparison but deserve mention:
Fly.io: Closest to Railway in positioning — Docker-based, global edge locations, $5/month minimum. Better global distribution than Railway (35+ cities vs Railway's limited edge); similar compute pricing. Choose Fly.io over Railway if you have specific latency requirements for international users or want to run multiple small services across regions cheaply.
Cloudflare Workers: The edge-native option for apps that genuinely need sub-50ms global response times. No traditional server model — everything runs at the edge. Works with Turso, Cloudflare D1, and KV storage. Not a general-purpose deployment platform but a compelling choice for API-heavy apps with global users.
Neither displaces Vercel, Railway, or Render for standard SaaS — but both are worth evaluating as your architecture evolves. The deployment platform decision is meaningful but revisable: migrating a Next.js app from Vercel to Railway takes a day, not a week. Optimize for developer experience and cost at your current scale, and revisit when the platform constraints become concrete rather than hypothetical.
See our production deployment checklist in how to deploy your SaaS boilerplate.
See how deployment connects to observability in our SaaS observability guide.
Browse full-stack TypeScript boilerplates to choose the right stack before choosing deployment.