Your PaaS Bill Lied in June 2026: What Railway, Render, Fly.io and Vercel Actually Cost With Egress, Cold Starts, and the 127x Spread

The same app — one API, one worker, Postgres, 200 GB of egress — costs $14 on one invoice and more than 100x that on another.

That is not a hypothetical. Tural Allahverdiyev's June 2026 audit on Medium, "Your PaaS Bill Lied to You," re-priced an identical workload across Railway, Render, Fly.io, and Vercel with every hidden line counted — per-service multiplication, egress at the region you actually serve, cold-start behavior, and Fly.io's two new 2026 billing lines. Among the four PaaS, the honest monthly floor spanned roughly 5x. Stretch the comparison to the cheapest and most expensive way to move the same gigabyte — Cloudflare R2 at $0 versus Fly.io's Africa/India rate at $0.12 and hyperscaler standard at $0.09 plus every vendored line item — and the same byte spreads 127x.

If you only read the marketing page, none of that is visible. This post puts the audit on one page: the table, the workload it holds constant, where the 127x and the 5x each come from, what cold starts actually cost, and what the same workload looks like on a flat-rate Hetzner box under Cluster API where no vendor can add a line item unilaterally.

1. The bill in one table — same workload, four PaaS plus the extremes that make 127x​

We fix the workload, then price it everywhere with the same assumptions: 730 hours (always-on, no sleep), NA/EU region unless noted, one developer seat, VAT excluded. Pricing from Railway docs ($20/vCPU-mo, $10/GB RAM-mo, $0.05/GB egress), Fly.io docs (shared-cpu-1x ~$3.32/mo at 512 MB, volume $0.15/GB-mo, egress $0.02 NA/EU / $0.12 Africa/India, plus $3.60/mo per app-scoped egress IP since Jan 1 2026), Render docs (Starter $7/mo for 512 MB/0.5 vCPU, Standard $25/mo, workspace Hobby $0 / Pro $25 / Scale $499, bandwidth included then $0.15/GB), Vercel (Pro $20/seat, ~1 TB bandwidth included then $0.15/GB), and Hetzner Cloud (CPX22 ~€7.99/mo flat, 20 TB traffic included per instance in EU/US). Postgres is the cheapest managed or first-party option per platform.

Among the four PaaS, the floor runs ~$18 (Fly.io NA/EU) to ~$90 (Vercel/Render Pro) — the ~5x spread the audit headline reports. Put the same gigabyte on the cheapest and most expensive billing dimensions the audit counted — zero-egress R2 versus $0.12/GB plus snapshots, egress IPs, seats, and per-service fees — and the per-unit cost of moving a byte spans 127x. That is not one hike; it is how many dimensions now get metered for the same byte.

Sensitivity: at 50 GB egress, Vercel's 1 TB included band hides the pain and the ranking tightens. At 1 TB egress, Railway adds $50, Render's overage adds ~$150, Fly.io NA/EU adds $20 while Africa/India adds $120, and Hetzner still adds $0 — the spread widens past 5x. At one service Render Hobby looks cheapest; at three services its per-service multiplication pulls it above Railway.

2. What "identical" means — the workload the audit holds constant​

An audit is only honest if the thing it compares does not move. The June 2026 teardown fixes a boring median-team stack:

• API: 0.5 vCPU / 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, NA/EU unless labeled otherwise
• Builds: ~100 build minutes/month — called out separately
• Uptime: 730 hours/month. No free-tier sleep, no scale-to-zero credit.
• Team: 1 seat for the floor; sensitivity at 5 seats

If your workload is a static Next.js site or a twice-daily cron, your ranking will differ. The point is that a two-service plus database plus real egress stack is the first shape that forces every platform to bill every dimension.

3. Egress — the bill that decides the bill​

At 200 GB, egress is the largest single charge on two of the four platforms and the line with the widest spread in 2026.

• Fly.io: $0.02/GB NA/EU, $0.04/GB Asia-Pacific/South America, $0.12/GB Africa/India — same byte, 6x price by region.
• Railway: $0.05/GB (current docs; vintage plans $0.10/GB) — metered per KB.
• Render: $0.15/GB beyond included bandwidth — 100 GB Hobby, 1 TB Pro. Below the line $0; above it the steepest rate in the table.
• Vercel: 1 TB included on Pro, then $0.15/GB. At 200 GB the audit shows $0 overage — which is why a small-egress comparison flatters Vercel for API-heavy workloads.
• Cloudflare R2 / Backblaze B2 Overdrive: $0/GB egress to any destination — the cheap anchor of the 127x.
• AWS/GCP/Azure standard: ~$0.09/GB in 2026 — sticker unchanged, but applied to 3–7x more bytes than a 2020 app pushed.
• Hetzner: 20 TB included per instance in EU/US (1–2 TB on the smallest CX). 200 GB is ~1% of the allowance. No regional surcharge.

At 200 GB: Fly.io NA/EU $4, Railway $10, Render $0–$15, Vercel $0, Hetzner $0, AWS-baseline $18, Fly.io Africa/India $24. At 1 TB: Fly.io NA/EU $20, Railway $50, Render ~$135 beyond 1 TB Pro included, Fly.io Africa/India $120. The spread between $0 on R2 and $120 on Fly.io Africa/India or ~$90 on hyperscaler standard — plus snapshots, IPs, and seats — is the core of the 127x. Region is a pricing decision, not just a latency decision.

4. Cold starts: who pays the tax​

The second hidden line is whether the platform can bill zero when idle — and what you pay in latency when it does.

Scale-to-zero trades a compute bill for a latency tail and often a second bill. Vercel's functions save GB-hours but add p95 latency unless you pay for provisioned concurrency. Render's free tier saves $7 but adds a multi-second spin-up that is invisible in dev and unmissable in prod — which is why most teams promote to Starter. Fly.io and Railway avoid cold starts for the priced workload, but the per-second meter never stops while started. A benchmark that prices one request favors scale-to-zero; a benchmark that prices always-on production flips the ranking.

Vercel's fourth repricing since 2024 shortened the distance between included and metered. Its 2024 infra repricing split bandwidth+functions into granular per-GB, per-GB-hour, and per-build-minute meters, and each subsequent revision narrowed included usage — the same ratchet Fly.io expresses as new billing lines rather than sticker hikes. Either way the bill can move when your traffic does not.

Price cold starts as a cost, not a feature: add the tier or concurrency fee that eliminates them, or budget the p95 they add.

5. The hidden lines that make 127x​

The headline per-GB rate is true and incomplete. Four things the pricing page de-emphasizes stack into both the 5x and the 127x.

Per-service multiplication. Render Starter at $7 looks cheapest per service. With two web services it is $14 before Postgres; with three it is $21–$40 before any workspace fee. On Standard (2 GB/1 vCPU) two services are $50 before anything else — which is why Render's ranking jumps between cheapest and most expensive depending on service count. Railway and Fly.io meter resources consumed across services, so the second service adds marginal CPU/RAM seconds, not a whole new sticker. Vercel is in the middle: one Pro seat covers web plus functions, but each GB-hour is additive.

Fly.io's two new meters in 2026. Fly.io deleted Hobby/Launch/Scale for new orgs on Oct 7 2024 and moved to pure pay-as-you-go. Through 2026 it added dimensions without a plan revision: volume snapshots billed since Jan 1 2026, app-scoped egress IPs at $3.60/mo per IPv4 since Jan 1 2026, and Managed Postgres inter-region private networking at Machine rates since Feb 2026. Each is $3–10 alone; together they are the model — where a plan once capped what got metered, now more things get metered. A flat Hetzner box cannot add a meter — it can raise the box price (and did twice in 2026: 30–35% in April, then up to 2.7x on CCX/CPX dedicated-vCPU lines June 15 on DRAM costs), but not invent a new dimension.

Workspace and per-seat math. Render's Apr 23 2026 overhaul replaced per-seat with flat workspace tiers (Hobby $0 / Pro $25 / Scale $499) on top of per-service compute. Railway Pro is a $20/mo usage minimum with unlimited seats. Vercel Pro is $20/seat — at one developer the floor is $20; at five it is $100 before any compute, which single-handedly explains why Vercel tops the 5x for teams.

Take the same gigabyte through the full stack — cheapest: R2 $0 plus bundled compute; most expensive: that byte at $0.12 with a snapshot behind it, an egress-IP fee in front of it, and seats plus per-service fees around it — and the per-unit cost spans 127x. The 5x among Railway, Render, Fly.io, and Vercel on the actual workload in Section 1 is the slice you can act on without changing providers.

6. The Hetzner recompute — where flat collapses the spread​

Price the same workload on one Hetzner instance managed by Cluster API and the spread's dimensions stop being billable.

CPX22 (2 vCPU AMD, 4 GB RAM, 40 GB NVMe) at ~€7.99/mo (~$8.60) after the June 15 2026 repricing — existing contracts grandfathered, new orders at the new price. Add a 10–20 GB volume for Postgres at ~$0.15/GB-mo and the whole stack is ~$14/mo flat:

• Compute: $8.60 flat runs both services plus headroom — bin-packed by Kubernetes, not per-service or per-second.
• Postgres: $0 marginal as a workload on the same node (plus volume GB-months).
• Egress: $0 marginal — 200 GB is ~1% of the 20 TB included per instance in EU/US. No regional multiplier, no $0.15 cliff.
• Snapshots / IPs / private networking: no per-unit meter. Snapshots cost disk, the node's public IP is the egress IP, east-west pod traffic is not billed.
• Team size: no workspace or per-seat fee.

The structural win is not that Hetzner is cheap — after two 2026 hikes it is less cheap than folklore still cited on HN — but that the vendor cannot add a dimension. Hetzner can raise the box price; a usage-based PaaS can add a new meter without touching any sticker. Flat turns repricing risk into one forecastable number rather than a growing list of rates that move on independent schedules.

Where flat does not win is bursty, low-average-load work: a nightly cron that runs 10 minutes a day costs ~$0.10/mo per-second on Fly.io or Railway and a full $8.60/mo of flat capacity. The honest answer is hybrid — flat fleet for steady-state tenant traffic where every second is billed, metered runners (GitHub Actions, Depot) for bursts — not pretending either model wins everywhere.

Provisioning through Cluster API Provider Hetzner (CAPH) is what makes that flat number behave like a PaaS. Machines are declarative Machine/MachineDeployment objects — the same kubectl surface manages workloads and the nodes they run on. That is the seam a single-Docker-host tool (Coolify v4 stable Apr 2026, Dokku, CapRover) hits at machine two: no fleet-wide node lifecycle. CAPH pays that cost once at cluster creation and then scales like the PaaS it replaces, except every new byte costs nothing at the margin.

7. How to price your own migration​

The audit's best contribution is the worksheet. Re-run it with your numbers before you switch on vibes.

1. Fix the workload. Services, vCPU/RAM per service, Postgres size, monthly egress (measured from logs), seats, regions. Without egress and region fixed, any comparison is fiction.
2. Add every service. Multiply per-service prices by your actual service count; do not compare Starter $7 to a RAM/CPU meter.
3. Add the 2026 lines. Fly.io egress IPs ($3.60 each) and snapshots; Render workspace tier; Vercel Pro × seats; Railway egress at $0.05/GB (or $0.10 vintage).
4. Price cold starts both ways. Subtract the always-on tier if you can tolerate them, then add p95 cost; otherwise add the tier that eliminates them.
5. Run sensitivity at 50 GB, 200 GB, and 1 TB egress. If the ranking flips — and in the audit it does — your egress trajectory decides the home.
6. Recompute on Hetzner last. One or two CPX22 nodes at current post-hike rates, plus volumes, divided by tenants you will bin-pack — ~$14 flat for one stack above. If that baseline plus your own on-call is cheaper than the metered forecast at your actual egress and service count, it is the predictable number to bet on.

Tural's teardown matters because he published the worksheet, not because he named a winner. Any comparison that hides egress by region, omits Postgres, or prices one service will crown a different winner — and every pricing page is happy to let it.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Flat-rate Hetzner (or any CAPH-compatible) fleet, Cluster API under the hood, no per-seat, per-service, or per-GB surprise. Star the repo on GitHub or deploy your first app today.