Fly.io's Managed Postgres Costs $38/Month Before You've Added the App

Fly.io's Managed Postgres (MPG) has a clean headline number: $38/month. What the headline leaves out is that $38 buys only the database — the app that talks to it is a separate line item on Fly Machines, and a real small-team topology (app + database, minimal traffic) lands closer to $41-47/month minimum once both are added up. The same topology fits entirely on a single ~$6/month Hetzner box, database included, with room to spare. Below is the full tier table, the worked total Fly's pricing page never shows in one place, and what happens to the gap once the workload actually grows.

What $38/Month Actually Buys​

MPG replaced Fly's older "run Postgres yourself on a Fly app" pattern with an actually-managed product: automatic HA failover, backups, and connection pooling bundled into every tier, priced by compute size rather than by the hour. Fly's own pricing page lists five tiers:

Storage is separate from all five tiers: $0.28 per provisioned GB for a 30-day month, up to a 1TB-per-cluster ceiling. That storage is replicated across every node in an HA cluster, but — worth crediting Fly for — it's billed once per cluster, not once per replica, so the $0.28/GB rate isn't secretly 2-3x higher than it looks. A 10GB database on the Basic tier adds $2.80/month; a 100GB database adds $28. Multi-region clusters carry one more line item most single-region comparisons miss: Fly started billing inter-region private networking at Machine compute rates in February 2026, so a cross-region replica setup pays for the WireGuard traffic between regions on top of the base tier.

The Line Item Nobody Adds​

MPG bills the database. It does not bill the app. Fly Machines — the compute layer running the actual application — is metered completely separately, by the second: a minimal shared-cpu-1x Machine with 256MB RAM runs $2.02/month if left on continuously, and a Performance-tier 2GB Machine runs $32.19/month. There's no bundle that combines "the app" and "the database that app needs" into one number on Fly's pricing page — a structurally different shape than Railway, which treats Postgres as an ordinary metered project service billed the same way as any other container, no separate managed-database product to add.

That's a meaningfully different pricing shape than the other usage-based PaaS this list keeps benchmarking against. Railway treats Postgres as an ordinary project service — the same per-second vCPU and RAM meter that bills any other container, no separate "managed database" SKU, no $38 floor before a single query runs. Fly's MPG went the opposite direction on purpose: a fixed-tier product with HA and backups baked in, priced like a distinct line of business rather than folded into the general compute meter. Neither shape is wrong, but they're not the same claim, and a team pricing "Postgres on Fly" against "Postgres on Railway" is really pricing two different products, not two numbers on the same rate card.

Put a real hobby topology together on Fly — one small always-on web Machine plus MPG Basic plus a modest amount of storage — and the total looks like this:

That $42.82 is the floor — the smallest possible Machine, on the smallest possible MPG tier, with a database barely bigger than empty. Give the app Machine more than the bare-minimum 256MB (most real apps want at least 512MB-1GB to avoid swapping under load) and the total climbs toward $45-47/month before a single byte of egress or a second environment is counted.

The Same Topology, Owned​

Run the identical shape — one web process, one Postgres instance, modest traffic — on a single Hetzner box instead, and there's no second line item to add because there's no second product. A Hetzner CX23 — 2 vCPU, 4GB RAM, 40GB NVMe, 20TB of included traffic — costs €5.49/month (roughly $6) at Hetzner's current, post-June-15-2026-hike pricing, and both the app and Postgres run on it side by side, with the entire 40GB of NVMe available for whichever of the two needs it most. No $38 floor before the app is even counted; no separate storage product metered at $0.28/GB the moment a database crosses whatever's bundled in.

That last point is worth making concrete: if a workload does outgrow the box's local NVMe, Hetzner's block storage volumes price at roughly €0.057/GB/month (about $0.06) — a little over a fourth of Fly's $0.28/GB MPG storage rate. Storage isn't the biggest line item in either comparison, but it's the cleanest apples-to-apples one, and it isn't close.

Does the Gap Close as the Workload Grows?​

A comparison that only holds at hobby scale isn't a comparison — it's a cherry-picked data point. The honest test is whether the multiple survives moving up the tier ladder, especially now that Hetzner's own 2026 price hikes have made its dedicated-vCPU line meaningfully more expensive than it used to be.

Take MPG's Launch tier — Performance-2x, 8GB RAM, $282/month — and add a realistically sized app Machine and database storage:

The comparable Hetzner box in this weight class is a CCX13 — 2 dedicated vCPU, 8GB RAM, 80GB NVMe — which, even after Hetzner's brutal 113-204% price increase on the CCX/CPX lines this June, still runs €42.99/month (about $47). That's one box, app and database together, both riding on dedicated (not shared) cores — a full step up from the CX23's shared vCPUs.

$328 against $47 is roughly a 7x gap, essentially unchanged from the hobby tier's own ~7x. Hetzner's price hikes moved the absolute numbers on both sides of this comparison, but they didn't touch the ratio, because MPG's own per-tier pricing climbed just as steeply on the way up — Launch to Scale is a 3.4x price jump for a 4x memory jump, Scale to Performance a 2x jump for a 2x memory jump. Both vendors' pricing scales roughly linearly with resources; the multiple between them holds because neither curve bends toward the other.

What $38 Buys That the Box Doesn't Hand You Free​

None of this means the $38 buys nothing. It buys automatic HA failover, backup scheduling, and connection pooling as configured, tested defaults — the same three things a companion piece on this blog already priced out in ops-hours rather than dollars: setting up Patroni or repmgr for failover, writing and verifying a restore process (not just scheduling one — testing that it actually restores), and running PgBouncer yourself all cost real time, and that time has a dollar value even when the box itself is nearly free. None of it is exotic work, but none of it is zero either, and a botched failover script or an untested backup is the kind of failure that only shows up at the worst possible moment. A team that would rather pay $38-282/month than own that setup work isn't making an irrational choice — it's buying back hours it has better uses for, and paying to convert a one-time engineering project into a recurring subscription with someone else on the hook for it.

What the $38 doesn't buy is a discount on the app's own compute, a lower storage rate, or a bundle that makes "app plus database" one line item instead of two. Those are the parts of the bill that don't require any operational tradeoff to remove — they're just the cost of routing a database through a managed product instead of the hardware the app is already running on. The two costs are genuinely separable: a team can self-host Postgres for the dollar savings shown above and still pay for managed backups or a monitoring service to cover the ops-hours gap, rather than treating "rent MPG" and "own everything yourself" as the only two options on the table.

bex, for what it's worth, takes a stance that agrees MPG's HA layer represents real, non-trivial engineering — and deliberately stays out of it anyway: managing tenant databases is a non-goal, not a missing feature, on the theory that a platform's job is the git-push-to-HTTPS path, not reinventing what Patroni and pgBackRest already do well. A tenant running Postgres on a bex-managed Hetzner fleet gets the dollar side of this comparison — no MPG-style tier floor, no $0.28/GB storage product — and keeps the failover, backup-verification, and pooling work as their own, exactly as they would running Postgres directly on any other box they own.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with no separate managed-database line item metered on top of the box you're already paying for. Star the repo on GitHub or deploy your first app today.