Fly.io's $2.02 Machine Isn't Your Bill: The Five Metered Lines That Double It

Fly.io's cheapest Machine costs $2.02 a month. The smallest real app you can run on it costs roughly three times that — and the gap isn't compute.

Fly.io charges $0.00000078 per second for a shared-cpu-1x with 256 MB. Leave it on all month and you owe $2.02. No base plan, no seat fee, no monthly minimum — the pitch that makes every comparison table label Fly.io "pure pay-as-you-go." The number is real, and for a Firecracker microVM that boots in 300 milliseconds, it is genuinely cheap.

The catch is that the cheapest Machine is never the whole invoice. Add the volume its data lives on, the egress its responses consume, and — since January 2026 — the snapshots, egress IPs, and cross-region traffic Fly.io began metering separately, and that $2.02 line becomes a $6 to $11 slice of an $18 to $34 bill. None of the new lines is unreasonable alone; together they decide whether "you only pay for what you use" still reads as cheap, or just as complicated.

Here is the answer before the explanation, for a boringly typical stack — a web service, a background worker, and a Postgres — priced as Fly.io actually invoices it today versus the same workload on a flat-price Hetzner box.

More precisely: of the $18.44 invoice, $11.26 is compute for three Machines, $3.00 is the Postgres volume, $1.20 is egress, and $3.60 is a static egress IP. Compute is 61% of the bill; the primitives the headline doesn't mention supply the other 39%. Push egress to 300 GB or add a second region and that 39% becomes 50% or more. The rest of this post shows where each dollar comes from and why "no base plan fee" is a different promise than "no hidden lines."

How "pure pay-as-you-go" actually works​

Fly Machines are Firecracker microVMs. You declare a CPU/RAM preset, point it at a Docker image, and Fly bills for every second the Machine is in the started state — not per request, per second the VM is running. Stop the Machine and compute billing stops. That is the whole primitive, and it is why the model feels so clean next to a monthly seat or tier.

The preset table makes the arithmetic concrete:

Additional RAM beyond the preset is about $5 per GB per 30 days. A shared-cpu-1x with 2 GB costs $11.11/month always-on, not $2.02 — the preset is the floor and real apps rarely live on it.

Three things keep billing when the Machine is stopped, and this is where "pay only while running" starts leaking:

• Volumes — persistent NVMe disks. $0.15/GB-month, pro-rated hourly, whether the Machine is running or not. Delete the app but forget the volume and you keep paying for the disk.
• Snapshot storage — incremental backups of those volumes (see below). Billed hourly on stored bytes even if the source Machine is stopped.
• IP addresses — any dedicated IPv4 ($2/month) or static egress IPv4 ($3.60/month) you allocated. Allocated means billed.

A 20 GB Postgres volume costs $3.00/month forever. That alone is 150% of a shared-cpu-1x's compute price. Fly's auto_stop_machines can suspend idle Machines on request, but it only saves compute — volumes, snapshots, and egress IPs don't scale to zero with it. For a web service that handles a request every few minutes, "idle" rarely arrives; the clock runs continuously.

The five lines the headline doesn't mention​

Every real Fly invoice has the same shape: a small compute block at the top, then a longer tail of infrastructure primitives a flat-price Hetzner box simply includes.

1. Volumes — $0.15/GB-month, always​

You provision a size (10 GB, 20 GB) and pay for that provisioned size every hour it exists, not used bytes. Two 20 GB volumes for a Postgres primary and replica: $6.00/month before either Machine boots.

Hetzner includes 40 GB (CX22) to 80 GB (CX33/CAX21) of NVMe in the server price. No separate disk line.

2. Egress bandwidth — $0.02/GB (NA/EU), $0.04 (APAC/SA/Oceania), $0.12 (Africa/India)​

Outbound responses to the public internet. Most orgs now use granular billing (auto-enrolled after July 2024): inbound is free, same-region private traffic is free, everything else meters at the regional rate. A modest API shipping 60 GB/month from iad or ams owes $1.20; the same app serving 300 GB of images owes $6.00. Fly's trial includes a one-time free egress allowance, but there is no recurring monthly free tier — every gigabyte after that counts.

Hetzner includes 20 TB of outbound traffic per cloud server — effectively unmetered for anything short of a CDN.

3. Egress IPs — $3.60/month per static IPv4 (Fly's NAT gateway equivalent)​

The TODO calls this "NAT gateways" — it needs a translation. Fly doesn't bill an AWS-style NAT Gateway per hour plus per-GB processing fee. Instead, when your Machine needs a stable outbound IP — Stripe webhook allowlists, a partner's IP-restricted API — you allocate a static egress IP. That allocation costs $3.60/month per IPv4 (IPv6 bundled, not separately billed), hourly, as long as it exists. Fly launched app-scoped egress IPs in late 2025 and began billing them January 1, 2026. Need one allowlisted IP for a payment processor and one per region for redundancy? That's $7.20 — more than three shared-cpu-1x Machines.

Hetzner: every cloud server gets a static public IPv4 (roughly €1 add-on since 2024). No per-app egress IP product because the box already has the IP.

4. Volume snapshots — $0.08/GB-month, first 10 GB free (since January 1, 2026)​

Fly takes automatic daily snapshots with 5-day retention by default. Before 2026 this was free; since January 1, 2026 (first charges on February invoices) Fly bills snapshot storage at $0.08/GB-month, first 10 GB free. Snapshots are incremental — only changed blocks since the last snapshot count — so a 10 GB volume with 1 GB of daily churn and 5-day retention stores ~5 GB, inside the free allowance. Cross the allowance and it meters: a 20 GB Postgres volume holding 15 GB of snapshot data owes $(15 - 10) × $0.08 = $0.40; two such volumes, $0.80. Bump retention to 14 days without trimming and that same database can sit on 35 GB of stored snapshots: $2.00 per volume. The knob is retention days times daily churn, not provisioned size.

Hetzner charges for snapshots/backups separately too, but the rate and the retention policy are yours to set, not Fly's 5-day default you have to remember to tune.

5. Inter-region private networking — $0.006/GB (NA/EU), $0.015 (APAC/SA) (since February 2026)​

Machines talking over Fly's 6PN WireGuard mesh — primary to replica, web tier to worker in another region — meter cross-region traffic at the rates above; same-region traffic stays free under granular billing. Fly began billing this for Managed Postgres in February 2026, with general Machines traffic on the same schedule. A 40 GB/month WAL stream between iad and ams costs $0.24; the same stream to sin (Singapore) costs $0.60. A chatty service mesh moving 500 GB/month cross-region hits $3.00 (NA/EU) before any public egress.

Hetzner private networking (vSwitch/cloud networks) inside a project has no per-GB meter; cross-region private traffic rides included bandwidth.

What about "metrics"?​

The TODO names "metrics" as a hidden line. Fly doesn't bill metrics ingestion the way it bills bandwidth. Fly exposes CPU, memory, and request metrics free in the dashboard, and you can ship logs to an external aggregator. The real cost is the external system you need once Fly's built-in retention isn't enough — Grafana Cloud, Datadog, or a self-hosted Loki/Mimir stack. That bill lands on Grafana's invoice, not Fly's, but it's still a production cost of running on Fly. Calling it a Fly charge would be inaccurate; calling it a real cost would be honest.

Worked example: one real app, full invoice​

Pick the stack that ships to Fly most often in 2026: a web service, a background worker, and a Postgres. Single region — no replica, no cross-region networking — to keep the comparison fair to Fly. We'll add the replica as a sensitivity row, not the base case.

Assumptions, chosen to be typical rather than flattering to either side:

• Web: shared-cpu-1x, 512 MB — $3.32/month always-on (256 MB is too tight for a Node/Rails app with real dependencies)
• Worker: shared-cpu-1x, 256 MB — $2.02/month
• Postgres: shared-cpu-1x, 1 GB — $5.92/month (self-managed Postgres on a Fly Machine; Fly's Managed Postgres starts higher)
• Postgres volume: 20 GB × $0.15 = $3.00
• Egress: 60 GB/month from NA/EU at $0.02 = $1.20
• Egress IP: one static egress IPv4 for a payment-provider allowlist — $3.60
• Snapshots: ~8 GB stored under 5-day retention, inside the 10 GB free tier — $0.00 base case

Remove the egress IP — not every app needs an allowlisted IP — and the invoice drops to $14.84, hidden lines still 24%. The headline was never the bill.

How the hidden share moves​

The base case is kind to Fly: single region, modest egress, snapshots inside the free tier. Nudge the knobs a team actually touches over a few months and the composition shifts.

Two patterns:

• Egress dominates. Jumping from 60 GB to 300 GB adds $4.80 — more than two shared-cpu-1x Machines. Fly's $0.02/GB is among the cheapest hosted egress (compare Vercel's $0.15/GB overage), but cheapest per-GB doesn't mean negligible when the app's job is shipping bytes.
• Snapshots and private networking stay small for a single-region app that doesn't hoard retention. They become the story only when you add a replica in a second region or crank retention to two weeks "just to be safe."

The per-second overage that never appears as a row is the clock itself. Three Machines at 24/7 costs $11.26 of compute; autosuspend that sleeps a worker 50% of the time saves ~$1.01 on that worker — real, but less than the volume line you can't suspend. Scale-to-zero is a compute optimization, not a bill-shape optimization.

Same workload on an owned Hetzner box​

Put the same three processes — web, worker, Postgres — on one Hetzner Cloud server. No Machines abstraction, just Docker or systemd on a VM you own. One price, same every month.

Post-June 15, 2026 EU rates (euros ex-VAT, from Hetzner's price-adjustment notice):

* Estimated post-June (+36% on April base). † CAX11 estimated; Hetzner publishes CAX21/CAX31 explicitly.

The smallest box that comfortably runs this stack — a CX22 or CAX11 — costs €6–8/month ($7–8.70) and replaces $11.26 of Fly compute plus $3.00 of Fly volume in one number. It also replaces $1.20–6.00 of Fly egress with 20 TB of included traffic and the $3.60 egress IP with the box's own IPv4. After Hetzner's June 15 hike the dedicated-vCPU CCX/CPX lines did jump 113–175% and are no longer the value pick; the shared Intel CX and ARM CAX lines rose only ~35% and are now the fleet default — a shift covered in our Hetzner second-hike recompute.

What Hetzner's number doesn't include — honestly — is the ops you now own: backups, replication if you want it, Grafana/Loki, OS patching, load balancing. Fly's higher bill bundles the platform: scheduling, volume attachment, private networking, proxying, certs. The comparison isn't "Fly is overpriced" — it's "Fly's value is the platform, not the per-second rate, and the per-second rate alone is not the price."

Why "no base plan fee" and "no hidden lines" are different claims​

"No base plan fee" is about a minimum. Fly genuinely has none: start zero Machines and the invoice is zero (minus any lingering volumes or IPs you forgot to delete — the one asterisk). That is meaningfully different from a platform with a $20 workspace minimum.

"No hidden lines" is about variance. A Hetzner CAX21 costs €13.49 this month, next month, and the month after, whether the app shipped 20 GB or 600 GB. A Fly invoice with the same app can be $14.84 one month and $33.64 the next because egress, retention, and region count moved while compute didn't. The bill's shape follows your workload's shape.

That variance has been growing. Three meters became billable inside six weeks in early 2026:

• Volume snapshots — January 1, 2026 ($0.08/GB, 10 GB free)
• App-scoped egress IPs — January 1, 2026 ($3.60/month per IPv4)
• Inter-region private networking — February 2026 (Managed Postgres, with general traffic on the same window)

Each is individually defensible — Fly's own disclosure notes ~98% of customers see no new charge and 83% of the remaining 2% see less than 10% bump. Each resource costs Fly real money. But the pattern is the one every hosted platform follows as it matures: generous bundling to acquire users, then incremental itemization to match cost. Render's April 2026 egress repricing (100 GB → 5 GB included, then $0.15/GB) and the 2024 removal of Fly's own free Hobby tier are the same motion in different quarters.

A platform that meters more dimensions isn't worse — it's more precise. But precise and predictable are not synonyms. A flat €13.49/month box is predictable because it meters nothing. A $14.84–33.64 metered bill is precise because it meters everything. Which you want depends on whether you budget by forecasting usage or by knowing the number.

When Fly still wins, and when a fleet wins​

Fly is excellent at what it was built for: globally distributed microVMs, fast cold starts, anycast routing, and a fly launch that turns a Dockerfile into a running HTTPS service without thinking about a server.

Fly never hid these lines. They're documented, priced, and disclosed months before they became billable, with a free allowance where one made sense. The gap between "no base plan fee" and "no hidden lines" isn't deception — it's budgeting reality: a bill assembled from five to seven metered dimensions, however fairly priced per dimension, is harder to forecast than one flat number that never changes shape. If you want that flat number on hardware you own, with a Render-compatible git push and a control plane an AI agent can call as an API, that's the bet Bex.co is built around — push a repo, get a running HTTPS service on machines you drew the boundary of.

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.