Next.js hosting cost in 2026: Vercel vs Netlify vs Railway vs VPS

By Nayan Kyada · · 7 min read

Part of Next.js Performance

Next.js hosting cost is one of those things that looks simple until your first invoice arrives. This post puts a realistic monthly number on five categories of host for the same mid-traffic site: ~80 k page views/month, ~4 GB egress, ISR on ~200 routes, and next/image serving ~300 k image transforms/month. No free-tier demos — estimates based on published list prices, rechecked in October 2026.

The reference site I'm pricing against

Before comparing, here's what I'm assuming so the numbers are comparable:

  • Next.js 15 App Router, Sanity CMS backend
  • ~80 k page views/month, peak ~500 concurrent
  • ISR with revalidate tags; roughly 50 k revalidation function invocations/month
  • next/image active — ~300 k image optimisation requests/month
  • ~4 GB outbound egress/month
  • One staging environment
  • No video streaming (that's a separate Mux line item)

This is a typical content-marketing or e-commerce landing site for a funded startup or mid-size agency client. Not a hobby project, not a FAANG-scale app.

The pricing table

ProviderPlanBase feeImage optimisationISR / functionsEgressRough monthly total
VercelPro$20/mo incl. 1 seat + $20 usage credit; extra developer seats $20Billed per transformation (~$0.05 per 1k) plus cache reads/writesUsage-based (invocations from ~$0.60/M, plus compute)1 TB Fast Data Transfer included, then from $0.15/GB$20–$60 (more seats and add-ons stack fast)
NetlifyPersonal / Pro (credit-based)$9/mo (Personal) or $20/mo Pro with unlimited membersNetlify Image CDN (used by next/image on Netlify)Draws from your monthly credits20 credits/GB ($0.13/GB at Pro credit-pack rates)$20–$40
RailwayHobby / Pro$5/mo (incl. $5 usage) or $20/mo (incl. $20 usage)None native — you bring your own image CDNBilled as CPU/RAM per container (~$20/vCPU-month, ~$10/GB RAM-month)$0.05/GB$15–$45
RenderHobby or Pro workspace + web service$0 or $25/mo workspace + $7 (0.5 CPU/512 MB) to $25 (1 CPU/2 GB) instanceNone nativeBackground workers billed separately5 GB (Hobby) / 25 GB (Pro) included, then $0.15/GB$10–$55
Fly.ioPay-as-you-go~$4–7 for a shared-cpu-2x machine (512 MB–1 GB)None nativeBilled as Machine time$0.02/GB (North America/Europe)$10–$40
VPS (Hetzner/DO)4 vCPU / 8 GBVaries widely by provider (Hetzner is far cheaper than DO)Self-managed (sharp + nginx cache)N/A — you own the Node processGenerous included traffic on Hetzner$10–$50 + your ops time

Vendor prices above were checked against each vendor's pricing page in October 2026 and change often; the totals are rough estimates for the reference site, so check the vendor's current pricing page before committing.

Vercel: the default, but the meter runs

Vercel is still the fastest path to production for a Next.js app. The Pro plan is $20/month, which includes one seat and a $20 usage credit; each extra developer seat is $20/month, so a two-person team is $40 before usage beyond the credit. That's fine. The problem is what happens next.

Image optimisation is the most common surprise. Vercel bills image transformations (every cache miss or stale), plus cache reads and writes; on-demand rates start around $0.05 per 1,000 transformations at the time of writing. If all 300 k requests were uncached transforms that's roughly $15, plus cache and transfer charges — manageable, but it scales with traffic spikes, cache purges, and every extra width or quality variant. Use minimumCacheTTL in next.config.ts and serve Sanity images via Sanity's own CDN with auto=format to avoid hitting Vercel's transform count unnecessarily.

Function usage on Pro is metered (invocations and compute) and drawn against the included credit first; at 50 k revalidations a month that's a small line item. Fast Data Transfer (1 TB included on Pro) covers 4 GB with massive headroom. The real cost pressure on Vercel is seats and any Edge Config or Analytics add-ons you bolt on later.

Netlify: competitive, but credit-based billing needs watching

Netlify now uses credit-based pricing: Personal is $9/month and Pro is $20/month with unlimited members (3,000 credits), and bandwidth, compute, requests, and deploys all draw down the same credit pool. For our reference site that's workable, but every production deploy and revalidation costs credits, so it pays to batch revalidation calls so one webhook triggers one function that revalidates many tags.

Netlify has its own Image CDN, and next/image on Netlify uses it. For Sanity images I'd still route through Sanity's CDN with ?w=800&auto=format parameters and skip the host's image pipeline entirely. That removes one cost variable and one failure point.

Railway, Render, Fly: bring your own everything

These three are containerised hosts. You deploy a Dockerfile or a Node process — you don't get a managed Next.js runtime. That means:

  • No automatic ISR — you implement on-demand revalidation yourself via revalidatePath/revalidateTag in a route handler, which runs in your own container.
  • No built-in image optimisation — next/image still works, but every transform runs on your CPU. Add an nginx cache in front or route images to Sanity/Cloudinary.
  • Scaling is manual or requires autoscaling config.

The upside: predictable-ish billing. A $25/month Render instance (1 CPU, 2 GB) runs a persistent Node container — no cold starts, no per-invocation billing. Railway charges by CPU/RAM seconds, which is harder to predict but should stay modest at this traffic level if you size the instance correctly.

Fly.io is the most ops-heavy but cheapest at the bottom. A shared-cpu-2x machine with 512 MB–1 GB RAM is roughly $4–7/month running continuously and handles moderate Next.js traffic fine with proper caching headers. Egress is $0.02/GB — essentially free at 4 GB/month.

VPS: cheapest invoice, highest hidden cost

A Hetzner 4 vCPU / 8 GB cloud server (low tens of euros a month or less, depending on region and plan line — check Hetzner's current pricing, which changed in 2026) runs Next.js in standalone mode behind nginx with zero platform overhead. Add Cloudflare's free tier in front for CDN and DDoS protection and hard costs stay low.

The hidden cost is your time. You own TLS cert renewal, Node version upgrades, zero-downtime deploys (PM2 cluster mode or Docker rolling restarts), log management, and alerting. For a solo freelancer running their own site, fine. For a client engagement where your time is billable, that ops overhead is real money. Estimate 2–4 hours/month baseline.

Hidden costs that move every estimate

Image transforms are the single biggest surprise across all managed hosts. Sanity serves images via its own CDN, counted against your Sanity plan's bandwidth quota rather than billed per transform — use that. Set quality: 80, define explicit sizes on every <Image /> and pin minimumCacheTTL to at least 86400 (24 hours) in your Next.js config.

ISR invocation count on Vercel/Netlify depends entirely on how aggressively your webhooks revalidate. A Sanity webhook that fires on every keystroke in draft mode will burn invocations fast. Add a debounce or filter to only revalidate on publish events.

Egress rarely bites at this traffic level, but included allowances vary a lot (1 TB on Vercel Pro versus 5–25 GB on Render), so model egress at scale before you commit.

Staging environments cost roughly the same as production on Vercel/Netlify (another seat or another site). On containerised hosts, staging is just another $5–10 service instance.

What I actually recommend

For a client site with a Sanity backend: start on Vercel Pro. The DX and zero-config ISR support is worth the premium until you're consistently over $200/month, at which point it's worth the migration effort to a containerised host. For internal tools or high-traffic apps where image transforms are low, Render or Railway hit a better cost-to-reliability ratio. A VPS is only the right answer if you have the ops discipline to maintain it — and most client projects don't.