Dora NodaIn February 2026, a developer opened a Vercel bill for $46,485 — for what was essentially a static site that blew up. The math was all there on the pricing page: 1 TB of bandwidth included on Pro, then $0.15 per gigabyte after that. Nothing was mis-billed. And nothing on the plan-comparison table had suggested the number could ever get that big. A year earlier, the same story played out on Hacker News when Netlify sent a $104,000 bill for a simple static site (negotiated down to $5,000 after the thread blew up), and again in July 2026 when a team moved twenty client-side requests server-side and watched its Vercel bill jump from $300 to $3,550 in a month — 99 percent of it "serverless function duration."
None of these were pricing errors. They were pricing pages doing exactly what pricing pages do: advertising the plan while the meter runs somewhere else. So let's do the exercise the pages won't do for you. Take one typical app, price it from the real 2026 rate cards — compute meters, egress tariffs, build minutes, the database — on Railway, Render, Fly.io, and Vercel, then substitute a flat-rate Hetzner box and see where the spread collapses and where it doesn't.
The table, first: one app, five bills
The reference app, stated up front so you can argue with it: an always-on API on 1 vCPU / 2 GB RAM running 24/7, the smallest production-ish managed Postgres, 500 GB/month of outbound egress, and roughly 500 CI build minutes a month. One developer, so per-seat fees count once. Rates are the published 2026 numbers, and every total below is labeled approximate — regional tariffs differ, and vendors move rates a few times a year.
| Line item (USD/mo, approx) | Railway | Render | Fly.io | Vercel | Hetzner CCX33 |
|---|---|---|---|---|---|
| Plan / base fee | $5 Hobby (incl. $5 usage credit) | $0 (pay per service) | $0 (pay per Machine) | $20 Pro × 1 seat | $0 (flat server) |
| Compute, 1 vCPU / 2 GB × 24/7 | ~$40 metered usage | $25 Standard instance | ~$10 shared-cpu VM | ~$35 Fluid active-CPU + invocations | included |
| Managed Postgres | ~$8 metered usage | $7 Starter | ~$6 self-managed VM | ~$20 external (Neon-class) | $0 marginal on spare capacity |
| Egress, 500 GB | ~$25 at $0.05/GB | ~$60 over included allowance at $0.15/GB | ~$10 at $0.02/GB | $0 (inside 1 TB Pro allowance) | $0 (inside 20 TB included traffic) |
| Builds, ~500 min | ~$3 as metered compute | ~$0 inside allowance | ~$1 as builder VM seconds | ~$0 inside allowance | $0 on-box |
| Total | ~$76 | ~$92 | ~$27 | ~$75 | ~$68 |
The box in the last column is a Hetzner CCX33 — 8 dedicated vCPUs, 32 GB RAM, about €62.49/month plus €0.50 for the IPv4 address, roughly $68, with 20 TB of outbound traffic included. Note what it is: four times the reference app's compute, because flat-rate hardware doesn't come in 1-vCPU slices. You buy the whole machine whether you fill it or not.
At this tier the spread from cheapest to most expensive is ~3.4x ($27 to $92) — noticeable, not scandalous. The scandal needs more traffic. Hold that thought; it gets its own section below.
Where the spread actually comes from
Four line items explain nearly all of it, and none of them is the headline plan price.
1. Egress tariffs span 7.5x before you deploy anything. This is the single biggest hidden variable in PaaS pricing. Fly.io charges roughly $0.02/GB in North America and Europe (more in APAC and South America). Railway prices egress around $0.05/GB — already found in the fine print rather than the plan table, with some plans and regions metering closer to $0.10. Render and Vercel both charge $0.15/GB past their allowances. Same gigabyte, 7.5x price range, and it is the line item most likely to 10x while your app's actual compute stays flat. Every viral bill in the introduction was an egress or duration story, never a plan-price story.
2. The compute billing model matters more than the compute price. Railway meters vCPU-seconds ($0.000463/vCPU/min) and GB-seconds ($0.000231/GB/min), so our 1×2 box accrues ~$40 before the plan credit — honest, but it means an idle-but-running service bills like a busy one. Render sells instance tiers per second while running: a fixed $25 for Standard whether traffic is spiky or flat, which is cheaper than usage metering at sustained load and dearer for bursty side projects. Vercel's 2025–2026 move to Fluid Compute (active CPU plus provisioned memory plus invocations, replacing the old GB-hours model) is the hardest to forecast of the four: a small API idles near free and a slow-AI-call API detonates, as the $300-to-$3,550 team learned. Fly.io's per-second Machines are the closest to "a VPS with an API": ~$5.70/month for a 1-vCPU/1-GB shared box, scaling linearly and predictably.
3. Build minutes are a second meter wearing a trench coat. Vercel's overage is $0.004/minute past quota — trivial until a monorepo team running Turbo machines across twenty daily PRs discovers build costs alone can clear $300/month. Railway and Fly.io fold builds into ordinary compute metering, which is fairer but invisible: your CI habit shows up as a fatter compute line, never labeled. Render includes a build allowance on paid plans and sells a Performance pipeline on top. Nobody's pricing page leads with this number; everybody's invoice eventually does.
4. Postgres is four different products. Railway's database is metered usage like everything else (~$5–10 for small). Render's managed Postgres starts at $7/month for Starter with PITR, replicas, and connection pooling as you climb. Fly.io gives you VMs and a Postgres image — roughly $6 in machine cost, with you as the DBA. Vercel exited the database business for practical purposes, so the honest Vercel column carries a ~$20 external Postgres. Comparing "the database row" across vendors is really comparing managed-ness, which is exactly why the cheapest column (Fly.io) also contains the most pager duty.
Sensitivity: the spread is a function, not a number
Re-run the same table at 2 TB/month of egress — a media-serving app, an image-heavy marketing site, an agent scaffold that streams large artifacts — and everything rearranges:
| Total at 2 TB egress (USD/mo, approx) | Railway | Render | Fly.io | Vercel | Hetzner CCX33 |
|---|---|---|---|---|---|
| Total | ~$151 | ~$317 | ~$57 | ~$225 | ~$68 |
Now the spread is ~5.6x, and the composition tells the story the title promised. Render's $0.15/GB tariff turns 1.9 TB of overage into ~$285 — triple the compute line. Vercel's 1 TB Pro allowance absorbs the first terabyte and then adds $150 for the second. Railway roughly doubles. Fly.io adds $30. The Hetzner box adds nothing: 2 TB is a tenth of its 20 TB included traffic, so its number doesn't move. This is where owning the hardware collapses the spread entirely — egress-heavy workloads convert every metered platform's cheapest line into its most expensive one, while the flat bill stays flat.
But intellectual honesty cuts both ways, because the curve has a left side too. Shrink the app to a quiet hobby project — 50 GB of egress, bursty traffic — and Fly.io or Railway bill under $15 while the Hetzner box still costs $68. At that tier the flat-rate server isn't the spread-collapser; it's just the most expensive column, a fifth point on the same curve sitting above the metered options. Usage-based pricing is genuinely cheaper when usage is genuinely small — Railway's April 2026 free-plan addition and per-second billing exist for exactly this customer.
Two more honest footnotes before anyone screenshots the table. First, flat bills rise too, just on a different schedule: Hetzner's June 15, 2026 price adjustment pushed a CCX33 in the EU from ~€48 to ~€62.49/month, with US and Singapore regions priced higher still — a step change announced in docs, not a spike on your invoice, but not "fixed forever" either. Second, regions break every PaaS column: Fly.io's $0.02 is a North-America-and-Europe number, and inter-region traffic between your app and your database is a separate meter on several vendors. If your users are in APAC, re-run the arithmetic with the APAC tariff before believing any table, including this one.
What the $68 box doesn't give you
The Hetzner column wins the heavy tier by deleting line items, and every deleted line item is somebody's job. Managed Postgres with point-in-time recovery and read replicas (Render's strongest card in every 2026 roundup) becomes a cron job and a restore drill you own. Scale-to-zero becomes a server idling at 3 a.m. Global edge becomes "Nuremberg plus latency." The control plane — provisioning, health checks, deploys, rollbacks, TLS, the 2 a.m. disk-full page — is unpriced in the table because it bills in hours, not dollars, and for a solo developer those hours are the most expensive line of all.
The right reading of the table is therefore not "dedicated hardware always wins." It's that the metered platforms and the flat box have opposite cost curves: metered starts near zero and grows with traffic, flat starts at $68 and stays there. They cross somewhere around a few hundred gigabytes of egress for a small app. Below the crossing, the PaaS meter is a bargain — you rent exactly what a side project uses. Above it, you're paying a 3–5x markup for the privilege of not thinking about servers, and you should at least be making that trade consciously. The teams holding $46,485 invoices weren't overcharged. They were above the crossing without knowing the crossing existed.
The takeaway for your next deploy
Price the app you'll have in eighteen months, not the one you have today: take your expected egress, multiply by the overage rate (not the plan price), add the database you'll actually need, and find your crossing point before traffic finds it for you. The pricing page tells you what the plan costs. The meter tells you what the app costs. They are different numbers, and now you know by how much.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with the meter replaced by hardware you already pay for. Star the repo on GitHub or deploy your first app today.
