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.
Related: how to deploy your SaaS boilerplate and self-hosting with Coolify. Browse deployment-related boilerplates on StarterPick.