--- title: "Vercel vs Railway vs Render: SaaS Deploy Costs 2026" description: "Vercel vs Railway vs Render for SaaS 2026: costs at $1K, $10K, and $100K MRR. Pricing models, cold starts, and which platform scales cheaper for Next.js." date: "2026-03-16" tier: 1 authors: ["team"] tags: ["vercel", "railway", "render", "deployment", "saas", "hosting", "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: 1. Railway's compute pricing at scale vs Vercel's per-seat + bandwidth 2. Built-in PostgreSQL and Redis eliminate external service costs 3. 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](/guides/how-to-deploy-saas-boilerplate-production-2026).* *See how deployment connects to observability in our [SaaS observability guide](/guides/saas-observability-stack-2026).* *Browse [full-stack TypeScript boilerplates](/guides/best-fullstack-typescript-boilerplates-2026) to choose the right stack before choosing deployment.*