The 5x Spread on an Identical Workload: What Railway, Render, Fly.io, and Vercel Actually Bill

The same three-service app — API, background worker, Postgres, 200 GB egress — costs $18 on one PaaS and north of $90 on another in the same month, running the same code and serving the same traffic.

No typo. No enterprise tier. A June 2026 audit that priced an identical representative workload across Railway, Render, Fly.io, and Vercel landed on a roughly 5x spread between the cheapest and most expensive way to run it — and most of the gap never appeared on any pricing page.

This post puts that audit on one page: the bill, in dollars. Not the headline per-GB rate or the hero price on the marketing site, but the invoice you actually pay when you add the second service, add Postgres, ship egress, and leave the thing on 24/7. Then it shows why the spread hides, how to build an apples-to-apples model before you migrate, and where a flat-rate Hetzner box running a self-hosted PaaS lands on the same chart.

1. The audit at a glance — same workload, four invoices plus Hetzner​

We fixed a workload and priced it everywhere, same specs, same uptime. Every line below is what hits the invoice — base subscription, compute for two always-on services, Postgres, and 200 GB monthly egress. Builds and extra bandwidth overages are separated so you can see the recurring floor, not a one-off spike.

On this representative small-production stack, the recurring floor spans ~$18 (Fly.io) to ~$95 (Vercel with team + Postgres) — a 5x spread for identical compute. The cheapest managed PaaS beats the self-hosted box on paper only until you add the second service, the database, or the next 100 GB of egress. The priciest is not "expensive per unit" so much as expensive in dimensions the headline price never names.

Sensitivity: at 50 GB egress the ranking tightens (Vercel's 1 TB included allowance hides the pain); at 500 GB egress the gap widens to ~7x because Vercel/Railway egress and Render overage compound. At one service instead of two, Render Hobby looks cheapest; at three services, Render's per-service multiplication pulls it above Railway.

2. What "identical" means — the workload we actually priced​

An audit is only as honest as the thing it holds constant. Ours is deliberately boring — the median small-team production stack, not a benchmark hero case:

• API: Node or Python web service, 0.5 vCPU / 512 MB–1 GB RAM, always-on, ~200k requests/day
• Worker: background job runner, same size, always listening (no scale-to-zero)
• Postgres: 1 GB RAM, 10 GB SSD, nightly backups
• Egress: 200 GB/month outbound (API responses + images/static), NA/EU region
• Builds: ~100 build minutes/month, excluded from the recurring total and called out separately
• Uptime: 730 hours/month (always-on). No free-tier sleep, no scale-to-zero credit

Why this shape? It is the first workload that forces every platform to bill every dimension: two runtimes (so per-service pricing matters), a stateful database (so you see who bundles it and who externalizes it), and enough egress to surface the line item that decides the bill more than CPU does. A single hobby project or a static Next.js site would hide all three gaps — and that hiddenness is the point.

Normalized assumptions​

If your workload is static-frontend-only, scale-to-zero, or sub-10 GB egress, your ranking will look different. The model in Section 4 lets you re-run it with your numbers.

3. Why most of the gap never appears on the pricing page​

The headline price on every PaaS site is true and incomplete. The 5x spread comes from four things the pricing page de-emphasizes.

Per-service multiplication​

Render's Starter at $7 looks cheapest in isolation — until you count services. Two web services are $14, plus Postgres is a third service at $7–$20, plus Redis or a cron worker is a fourth. A three-service stack on Starter is $21 before bandwidth; the same shape on Standard (2 GB, 1 CPU) is $75 before any workspace fee. Railway and Fly.io meter by resource consumed across all services, so the second service adds marginal CPU/RAM, not a whole new sticker price. Vercel sits in the middle: one Pro seat covers web + functions, but each function invocation and GB-hour is additive.

Rule of thumb: count services before you compare sticker prices. A platform that looks $5 cheaper per service is $15 more expensive at three services.

Egress — the bill that decides the bill​

At 200 GB/mo, egress is the largest single line on two of the four platforms:

• Railway: $0.05/GB (docs) to $0.10/GB depending on plan vintage — 200 GB is $10–$20, often more than compute for a small API.
• Fly.io: $0.02/GB NA/EU — 200 GB is $4. Region matters 6x: the same traffic billed at the Africa/India rate would be $24.
• Render: 100 GB included on free, 1 TB on Pro, then $0.15/GB overage — 200 GB is free on a Pro workspace, but 1.2 TB is $30.
• Vercel: 1 TB included on Pro, then $0.15/GB — 200 GB is included, but add image optimization, ISR, and edge requests and the overage that actually triggers is rarely labeled "bandwidth."

The pricing page shows compute. The invoice is often decided by bytes leaving the edge.

Idle-time and sleep policies​

The same workload's cost flips if you let it sleep:

• Render free / Starter: spins down after ~15 minutes idle, 30–60s cold start to wake. Great for demos, not for an always-on worker that must not sleep.
• Railway free/trial: $5 credit then metered; no sleep, but the free tier does not support persistent workloads — Hobby at $5 is the real always-on floor.
• Fly.io: no free persistent tier without a card; the cheapest always-on machine is ~$2–3/mo, but scale-to-zero can cut a 9-to-5 workload by ~2/3 if your traffic actually stops at night.
• Vercel: Hobby sleeps between invocations on Fluid compute; Pro keeps functions warm — and bills Active CPU only while doing work, which helps spiky but not steady-state workloads.

If your worker sleeps, quote the sleeping bill. If it must stay warm, quote the warm bill. Mixing the two is how audits produce whichever ranking the author wanted.

The line items that aren't on the page you compared​

Every platform bills at least one thing you did not price-shop:

• Build minutes, image pulls, and registry egress — Vercel and Railway meter builds; Docker Hub pulled 80% price hikes on its Pro tier in early 2026, which feeds directly into any Docker-based deploy pipeline.
• Volumes and disks — Fly Volumes at ~$0.15/GB, Render disks at $0.25/GB, Railway at $0.25/GB-month — Postgres storage is not "free because compute includes it."
• Seats and workspace fees — Vercel Pro is $20/seat/month, Railway Pro is $20/seat/month, Render workspace is flat $0/$25/$499 (April 2026 overhaul killed per-seat on Render). A five-person team adds $100 on Vercel/Railway and $25 on Render before any compute.
• Managed Postgres — Render, Railway, and Fly bundle or partner it; Vercel externalizes it entirely. Comparing "platform price" without the database is comparing one platform's complete stack against another's compute-only half.

Hetzner's 2026 repricing is the counter-example worth naming honestly: April 1 lifted most plans 30–37% (CPX22 to ~€8–9), and June 15 lifted CCX/CPX dedicated lines 113–176% on new orders and rescales, driven by DRAM/SSD supply pressure. Existing instances are grandfathered until a rescale, but new capacity is not. "Own the hardware, fixed price" is still a real hedge against per-seat and per-GB creep — but the hardware itself repriced twice in one year, and a self-hosting argument that uses pre-hike numbers is auditing with last year's invoice.

4. How to build an apples-to-apples bill model (and not fool yourself)​

Copy this checklist for your stack before you migrate. It takes 20 minutes and prevents the two errors that create most of the 5x fog: counting one platform's free tier against another's always-on price, and pricing compute without egress.

Step 1 — Fix the workload. Write down services × size × hours. Example: 2 × (0.5 vCPU, 1 GB) × 730h + 1 × Postgres (1 GB, 10 GB SSD, 730h).

Step 2 — Price each bill dimension separately.

monthly = workspace_or_seats
        + sum(compute per service)
        + postgres_and_storage
        + egress_GB × egress_rate_by_region
        + builds_and_registry

Step 3 — Pull the real rates, not the hero price.

• Railway: Hobby $5 incl. $5 usage, then $10/GB RAM/mo + $20/vCPU/mo ($0.000231/GB-min Hobby, $0.000463/vCPU-min), egress $0.05–0.10/GB.
• Render: Starter $7 (512 MB/0.5 CPU) per service, Standard $25 (2 GB/1 CPU) per service, workspace flat, bandwidth overage $0.15/GB past included (5–1,000 GB by tier), disks $0.25/GB.
• Fly.io: per-second, shared-cpu-1x/256 MB ~$2.02/mo, 512 MB ~$3.32/mo, 1 GB ~$5.92/mo; egress $0.02 NA/EU, $0.12 Africa/India; volumes ~$0.15/GB.
• Vercel: Pro $20/seat ($20 usage credit) + 1 TB bandwidth included then $0.15/GB + Active CPU ~$0.128/vCPU-hour (Fluid) + invocations $0.60/million + memory ~$0.012/GB-hour. Hobby is free for personal only.

Step 4 — Run sensitivity, not a point estimate. Recalculate at 0.5x and 2x your expected egress, and at team sizes 1 and 5. If ordering changes across that band — and it almost always does — the "cheapest platform" answer depends on traffic and team, not compute.

Step 5 — Separate always-on from scale-to-zero. If your workload can sleep, price the sleeping bill and name the cold-start cost. If it cannot, do not let a scale-to-zero price anchor the comparison.

Step 6 — Add Postgres honestly. Either include the managed Postgres tier you will actually provision on each platform, or exclude it everywhere and label the comparison "compute only."

A one-row spreadsheet with those seven lines beats any pricing page for migration decisions. If you skip the egress and seat rows, you have not compared platforms — you have compared the subset each platform chose to advertise.

5. Where a flat-rate Hetzner box lands on the same chart​

The self-hosted counterpoint is not "Hetzner is always cheaper." It is "Hetzner is fixed, and fixed is a different kind of cheap."

Flat-rate economics win on three specific bills the metered PaaS cannot cap: per-service multiplication (run three services on one box — no new line item), egress (20 TB included transfer, not $0.05–0.15 per GB), and seats (no per-seat workspace fee when the team grows from 2 to 10).

Flat-rate economics lose on three things the PaaS includes and the box does not:

• Operations — you own patching, Postgres backups, TLS, and incident response.
• Elasticity — a build burst queues on your node pool; a metered builder absorbs it per-second. Provision for peak and you pay idle capacity all night; provision for average and you wait in line at 10 a.m.
• Hardware repricing itself — April and June 2026 proved the substrate reprices too, and a rescale can reprice a grandfathered box.

For the representative workload in Section 1, a single CPX22 at ~$9 plus a volume at ~$5 is the lowest recurring number on the chart — if you already operate the fleet or consolidate multiple workloads to amortize that box. If you price the box for one workload plus the engineering time to operate it, Railway Hobby or Fly.io shared can be cheaper in the first months. The self-hosting advantage compounds with density, not in isolation.

6. What to pick — and what the 5x gap actually signals​

No platform is mispricing. Each is pricing for the buyer it wants:

• Fly.io is cheapest for a small always-on API with modest egress where you control region and you do not need per-seat collaboration at scale.
• Railway is cheapest for variable, bursty workloads where per-second metering and bundled Postgres offset the egress rate — especially before you add seats.
• Render is most predictable for a small fixed number of services on a tiny team where "the invoice is $7 times N plus at most $25 workspace" is worth more than optimizing per-GB.
• Vercel is the right answer for a Next.js frontend fleet where the framework integration offsets the multi-dimensional compute bill — and the wrong answer when you price it as a general container PaaS, where bandwidth, seats, and invocations compound.
• Owned Hetzner + bex is the right answer when you already run multiple workloads, egress is material, team size grows, or bill predictability month-to-month is the actual requirement — not the lowest single-service demo price.

The 5x spread is not a curiosity. It is the cost-of-ownership shape of the current PaaS market after a year in which Render, Vercel, Netlify, Fly.io, Docker Hub, Hetzner, and OVH all moved prices inside six months — not in one direction, but across every layer of the stack. The only line item that reprices on your schedule instead of a vendor's is the one you own outright.

A practical filter before you commit: quote your workload at 50, 200, and 500 GB egress and at team sizes 1 and 5, on every shortlisted platform, with Postgres included. If the ranking survives that band, it is real. If it collapses — and in most audits it collapses — the cheapest platform on the marketing page is not the cheapest platform on your invoice.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. The platform is Cluster-API-native, Render-API-compatible, and priced by the hardware you choose, not by seats or per-GB creep. Star the repo on GitHub or run your first workload on a Hetzner box you control.