Dora NodaFly.io's pricing page opens at $2.19 a month. The actual invoice for a boring, always-on, single-region app — one web service, one worker, one Postgres, 100 GB of traffic — is $19. That 8.7x gap between the headline and the bill is the subject of this post, along with the harder question it raises: every dollar above a $7 VPS is paying for a global edge platform, so what exactly is a team whose users sit in one timezone getting for it?
Short answer: mostly nothing. The anycast network, the 18-region price list, the per-second global scheduling — none of it does anything for an app pinned to one primary_region that never scales out. This post prices that unconsumed edge line by line, sets it against Render's flat-rate predictability and Railway's metered simplicity for the same stack, recomputes the whole thing on a single-region Hetzner box, and then states the honest carve-out where Fly's edge genuinely earns its keep.
The bill, up front
Same stack on all four platforms, October 2026 list prices, one region, always on, 100 GB egress in North America/Europe. Every column is labeled with its Postgres management level, because that label is doing more work than any other line in the table.
| Fly.io (container PG) | Fly.io (Managed PG) | Render (managed PG) | Railway (container PG) | Hetzner (self-hosted PG) | |
|---|---|---|---|---|---|
| Web (~1 shared vCPU, 1 GB) | $6.69 | $6.69 | $7.00 | $20.00 | included |
| Worker (small) | $2.19 | $2.19 | $7.00 | $10.00 | included |
| Postgres | $8.19 | $39.40 | $6.00 | $21.50 | included |
| Egress, 100 GB | $2.00 | $2.00 | $14.25 | $5.00 | $0.00 |
| Plan fee (net) | $0.00 | $0.00 | $0.00 | $0.00 | — |
| Total | ~$19 | ~$50 | ~$34 | ~$57 | ~$7 |
Two deltas in that table are the whole argument, so let's name them precisely.
The premium, defined. First, the assembly gap: $19 against the $2.19 headline is an 8.7x multiple — the price of one always-on Machine versus the price of an actual stack. Second, the edge-at-zero gap: $19 against the $7 Hetzner box is $12 a month in cash, plus a Dockerfile and a per-second invoice to operate, paid for edge capability this workload consumes at exactly zero. Note what the premium is not: Fly does not cost more dollars than Render or Railway here. It undercuts both — while asking you to run your own database and your own container build to do it.
The managed-for-managed flip. Compare managed Postgres to managed Postgres and the ranking inverts: Fly at ~$50 becomes the most expensive row, against Render's ~$34. Railway has no managed-database tier at all — its Postgres is a container you operate, metered like everything else — which is why its column stays on the container path. Keep both framings in mind; the rest of the post earns them line by line.
The workload under test
The stack above is deliberately unglamorous: a web service with roughly one shared vCPU and 1 GB of RAM, a small background worker, a Postgres database with a few GB of live data, and 100 GB a month of outbound traffic to users in one timezone. Everything runs 24/7 in a single region. No multi-region failover, no scale-to-zero, no GPU, no edge functions.
That shape matches the "Startup" tier in Techsy's July 2026 three-way benchmark of the same trio (1 web + 1 worker + Postgres + Redis at ~500 req/min: Railway ~$25–40, Render ~$50–60, Fly.io ~$20–35) (source), minus the Redis, which would add roughly the same small container on every platform. It also matches the team this post is written for: users in one timezone, deploy target a container that stays up. If that is your app, the numbers below are your numbers; the sensitivity section reruns them at 10 GB and 1 TB of egress so you can check where the ranking breaks.
Fly.io, line by line
Start with compute, repriced October 1, 2026. A shared-cpu-1x with 256 MB now lists at $2.19 a month always-on, and every preset takes extra RAM at $6.00 per GB per month, up from $5 (Fly.io's 2026 pricing update). So the web service — 1 shared vCPU with 1 GB total — is $2.19 plus 768 MB of extra RAM at $4.50, or $6.69.
The worker at the base 256 MB preset is $2.19. Unmanaged Postgres on the same 1 GB shape is $6.69 plus a 10 GB volume at $0.15/GB, or $8.19. Egress in North America and Europe is $0.02/GB, so 100 GB adds $2.00. Total: $19.07.
Three things about that $19 deserve more than a footnote.
Region count is invoice complexity. The pricing page prices compute across 18 regions, and the same preset does not cost the same everywhere: community-compiled price sheets documented a spread from $1.94 in Sydney to $3.14 in Mumbai for the base shared preset before the October update — over 60% between cheapest and priciest (community sheet). Egress is region-banded too: $0.02/GB in NA/EU, $0.04 across Asia Pacific, Oceania, and South America, $0.12 in Africa and India. None of this matters if you pin one region and stay there — but it all sits in the invoice's possibility space, and the day someone adds a second region for "just a read replica," every line reprices.
2026 added lines that used to ride free. Volume snapshot billing ($0.08/GB-month, first 10 GB free) started charging early this year, and app-scoped static egress IPs began billing January 1 at $3.60 a month per IPv4 (announcement) — the two new line items the summer cost teardowns flagged (Medium teardown, September ledger). Our reference stack owes $0 on both (snapshots fit the free 10 GB; no static egress IP needed), which is exactly why they are dangerous: they are $0 until the month they are not, and nothing in the $2.19 headline warns you they exist. Add the October 2024 removal of the permanent free tier for new orgs — new accounts get a one-time $5 trial credit that does not renew (forum confirmation) — and Fly's cheap tier is now cheap only in the way a hardware store is cheap: every component priced separately.
The database is the fork in the road. Run Postgres yourself on a Machine and it is the $8.19 above. Hand it to Fly's Managed Postgres and the Basic plan alone is $38 a month plus $0.28 per GB of storage (Prisma, checked October 2026) — roughly $39.40 for our shape, which single-handedly moves Fly from cheapest to priciest in the managed-for-managed ranking. That $30 spread is the concrete price of "we don't want to operate Postgres," and on Fly it costs more than the entire rest of the stack.
Then there is the entry fee no invoice shows: Docker knowledge. Techsy's comparison is blunt — Fly requires flyctl and, in practice, a Dockerfile you own, against Railway's auto-detecting Railpack and Render's native buildpacks (source). Time to first deploy runs ~5–10 minutes versus ~2 for Railway, and the learning curve is the only one of the three rated medium-high. That is not a complaint; full Docker control is a feature teams graduate into. It is simply a cost, paid in whoever maintains the Dockerfile, that the $2.19 headline never mentions.
Render and Railway on the same stack
Render: flat lines, metered bandwidth. The April 2026 replan kept compute prices untouched — Starter $7 (0.5 CPU/512 MB), Standard $25, Pro $85 — while replacing per-seat workspace fees with a flat Hobby $0 / Pro $25 / Scale $499 lineup (Render pricing). Our stack on a $0 Hobby workspace is $7 + $7 + ~$6 for managed Basic Postgres: $20 of compute that never moves.
The movement is all in bandwidth: 5 GB included, then $0.15/GB (rate card), so 100 GB of egress adds $14.25 and lands the total at ~$34. A Pro workspace would add $25 flat for 25 GB included — ~$56 at this egress — which is why small teams stay on Hobby until they need the collaboration features. Render's promise holds: you always know what next month costs. Its threat is that bandwidth, not compute, is now the line that surprises.
Railway: metered everything, punished by always-on. Railway's 2026 rates are $20 per vCPU-month, $10 per GB of RAM-month, $0.05/GB egress, and $0.15/GB-month of volume, billed per second of actual use (Railway's own pricing explainer). Costed at provisioned-equivalent sizes — web 0.5 vCPU/1 GB ($20), worker 0.25/0.5 GB ($10), Postgres container 0.5/1 GB plus 10 GB volume ($21.50), 100 GB egress ($5) — the meter runs $56.50, and the $5 Hobby fee nets against its $5 included usage for a ~$57 total.
The honest caveat cuts in Railway's favor: it meters actual consumption, so an idle worker and a quiet database land below provisioned-equivalent — treat $57 as a ceiling, not a quote. Even so, the shape of the finding survives: per-second metering rewards spiky workloads and taxes flat ones, and a 24/7 stack is the flattest workload there is. That is the same verdict Techsy reached from the other direction — Railway wins pay-what-you-use simplicity, not the always-on price war.
Sensitivity: move the egress slider
Egress is the variable that drives every ranking change, so here is the table rerun at 10 GB, 100 GB, and 1 TB a month (unmanaged-PG path for Fly; Hobby workspaces; Hetzner EU):
| Egress/mo | Fly.io | Render | Railway | Hetzner |
|---|---|---|---|---|
| 10 GB | ~$17 | ~$21 | ~$52 | ~$7 |
| 100 GB | ~$19 | ~$34 | ~$57 | ~$7 |
| 1 TB | ~$37 | ~$169 | ~$102 | ~$7 |
Two readings. First, Fly's $0.02/GB egress is the flattest metered line in the trio — at 1 TB it adds just $20 while Render's $0.15/GB rate detonates to ~$169 and Railway's $0.05 lands at ~$102. If your app is bandwidth-shaped, Fly's edge network starts looking less like a premium and more like a discount. Second, nothing in the PaaS trio touches the Hetzner row at any egress level inside the EU's 20 TB included allowance — the self-hosted box is flat at ~$7 from 10 GB to 10 TB.
One more sensitivity, in Fly's favor, that the table above cannot show: staging. Fly's autostop means stopped Machines pay only rootfs (~$0.15/GB) and volumes — no CPU or RAM charge while stopped (Prisma comparison) — so an idle staging copy of the stack collapses to a couple of dollars. Render's paid instances bill flat whether traffic arrives or not (only the free tier sleeps), and Railway meters whatever the staging containers actually burn. Autostop is the one metered Fly feature that pays off fully for a single-region team: production stays pinned and always-on, and every non-production environment stops costing real money the moment nobody is clicking it.
The Hetzner recompute
The entire reference stack — web, worker, Postgres, 100 GB of egress — fits on one Hetzner CAX11 (2 Ampere cores, 4 GB) at €5.99 a month, roughly $7, with 20 TB of included EU traffic making the egress line $0 at every volume this post considers. The Intel CX23 at €5.49 is a euro cheaper (today's Hetzner teardown, hetzner.com/cloud).
Two honest qualifications, both from that same teardown. First, 2026 repriced Hetzner twice: the June 15 hike tripled some AMD and dedicated lines (the CCX13 jumped 169% to €42.99), though the small shared and ARM rows this workload needs took only ~30–40%. The $7 figure is current list, not a grandfathered rate — but verify it at provisioning time, because Hetzner's price list now moves twice a year.
Second, the $7 buys a kernel and an IP address, not a platform: no git-push deploys, no managed Postgres, no preview environments, no one to page except you. The PaaS trio's real product was never the vCPU — it is the deploy pipeline and the pager you don't carry. Price the box at $7 plus whoever operates it, and compare that against $19–57 before declaring victory.
Even with ops labor priced in, the structural point stands: a single-region always-on workload is the shape dedicated hardware serves best. The PaaS premium buys elasticity and geography; this workload consumes neither.
Where Fly genuinely earns it
The carve-out, stated plainly — three workloads where Fly's edge stops being a premium and starts being the point:
Multi-region latency. Fly operates its own hardware across dozens of regions behind an anycast network (The New Stack). If your users span continents and your app needs single-digit-millisecond reads near each of them, one fly.toml with a regions array does what would otherwise be a multi-provider project. None of Render, Railway, or a Hetzner box offers that primitive at all.
Burst and scale-to-zero. Per-second billing with autostop is the correct shape for spiky traffic, bursty workers, and preview environments that live for hours. A staging fleet that idles 20 hours a day pays for 4 on Fly and 24 on Render. The meter that taxes always-on production subsidizes everything episodic.
Cheap egress at volume. The sensitivity table is the argument: at 1 TB, Fly's $0.02/GB is a third of Railway's and an eighth of Render's overage. Bandwidth-heavy apps — APIs with fat responses, asset origins, anything streaming — flip the ranking toward Fly as volume grows.
The decision test is one line in your fly.toml: if primary_region has never changed and no second region is on the roadmap, you are paying edge complexity without edge value. Not edge dollars, necessarily — $19 still undercuts the alternatives — but edge complexity: the Dockerfile, the region-banded invoice, the five-line bill for a one-container mental model. That complexity is a fine price for a global platform. It is a strange price for a container that stays up in Frankfurt.
The decision rule
If your app is always-on, single-region, and boring — and most production apps are — the ranking is: Hetzner-class hardware cheapest if you operate it ($7), Fly.io cheapest if you won't until you need managed Postgres ($19, or $50 managed-for-managed), Render the predictable middle ($34, watch the bandwidth line), Railway the simplicity tax on flat workloads (~$57 ceiling). If any of the three carve-outs applies — users on multiple continents, spiky or episodic traffic, egress past a few hundred GB — rerun the sensitivity table before deciding, because each one moves Fly's row for a different reason.
And if the Hetzner row tempts you but the ops burden doesn't, that gap is exactly what a self-hosted PaaS on owned hardware is for: git-push deploys and managed primitives with the $7 unit economics underneath instead of the $57 meter on top.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.
