Fly.io's Two New 2026 Line Items, Priced Line by Line: Snapshots and Cross-Region Traffic vs a Flat Hetzner Fleet

Fly.io spent 2024 and 2025 teaching its users that usage-based billing is a feature: per-second Machines, provisioned volumes, metered egress. Then, in the first two months of 2026, it added two line items to the invoice for things that used to be bundled — volume snapshots in January, inter-region private-network transfer for Managed Postgres in February. Neither charge is large on its own. Together, on the exact multi-region topology Fly.io's own marketing encourages, they turn a roughly $17 app into a roughly $23 app — and into a roughly $45 app if your second region happens to be in Africa or India.

That is the whole story of this post: a worked bill for one typical two-region app, line by line, against the same topology on two flat-rate Hetzner CX22 machines at about $10/month where both of the new meters read zero. The numbers are small enough that nobody migrates over any single line. The point is the shape of the invoice — every new capability arrives as a new meter — versus hardware you already own.

Here is the answer up front, for a typical setup (two shared-cpu-1x 1GB Machines in two regions, two 20GB volumes, daily snapshots on 5-day retention, 200GB public egress, 50GB cross-region replication traffic, North America/Europe rates):

Move the second region to Mumbai or Johannesburg and the Fly.io column becomes ~$45 with no architecture change at all. Keep reading for each line's rate, the sensitivity math, and the honest cases where Fly.io still wins.

What actually changed in January and February 2026​

Two separate announcements, two separate meters, one shared logic: traffic and backups that used to ride along inside the platform price now have their own per-GB rate.

Volume snapshots became billable on January 1, 2026. The rate is $0.08/GB-month with the first 10GB free each month, pro-rated to the hour, with the first charges appearing on the early-February invoice.

Three details matter more than the headline rate. First, automatic daily snapshots with 5-day retention are enabled by default on new volumes, so a team that never opted into backups started accruing snapshot storage silently. Second, billing is on actual data stored, not provisioned volume size — a 20GB volume holding 12GB of data snapshots at roughly 12GB, not 20GB. Third, snapshots are incremental per volume: each snapshot stores only blocks changed since the previous one, so retention length, not volume size, is the variable that moves this line.

Inter-region private-network usage for Managed Postgres (MPG) became billable in February 2026. Traffic between your app Machines and MPG across regions is now charged at the same granular private-transfer rates as ordinary Machine-to-Machine cross-region traffic, shares the same free quota, and stays free within a single region. Organizations created after July 18, 2024 are on granular rates automatically; older orgs either pay the flat public-egress rate for cross-region traffic or can opt into granular pricing one way with no way back.

The granular private-transfer rates, from Fly.io's current pricing page:

Note the asymmetry the table hides: public egress is 3–8x the private rate in every group, but the Africa/India group is 6x North America on egress and 8x on private transfer. Region choice is now a billing decision, not just a latency decision — the sensitivity section below quantifies exactly how much.

Context worth remembering: Fly.io removed its permanent free tier for new organizations in October 2024 (legacy Hobby/Launch/Scale accounts keep up to 3 shared-cpu-1x VMs, 3GB of volumes, and 100GB of transfer), replaced it with a one-time trial of a few machine-hours, and deprecated GPU Machines entirely with availability ending August 2026. Each step is defensible on its own. Each step also moves the same direction: fewer things bundled, more things metered.

The worked math, line by line​

The reference topology is deliberately boring: the smallest multi-region setup a team runs in production without feeling clever. One shared-cpu-1x Machine with 1GB RAM in each of two regions (say, Frankfurt and Chicago), each with a 20GB volume, Postgres replicating across the regions, daily snapshots kept five days, 200GB/month of public egress, 50GB/month of cross-region replication and health-check traffic. North America/Europe rates, granular pricing org.

Compute: $11.40/month. A shared-cpu-1x with 1GB runs about $5.70/month at 24/7 in a base-price region (the pricing matrix ranges from $5.70 to about $7.12 depending on regional markup; additional RAM beyond presets is ~$5/GB per 30 days). Two of them: 2 × $5.70 = $11.40. This line did not change in 2026 — it is the baseline everything new stacks on top of.

Volumes: $6.00/month. $0.15/GB-month of provisioned capacity, pro-rated hourly, charged whether attached or not and whether the Machine is stopped or not. 40GB provisioned × $0.15 = $6.00. The "even when detached" clause is the one that bites during migrations: the old region's volume keeps billing until you delete it, not until you stop using it.

Snapshots (new): $1.20/month. Assume each 20GB volume holds ~12GB of real data with moderate churn. Five days of incremental daily snapshots store roughly 12–15GB per volume after deduplication of unchanged blocks — call it ~25GB total stored. Minus the 10GB monthly free allowance: 15GB × $0.08 = $1.20.

A team that disables automatic snapshots pays $0 here and self-insures; a team that extends retention to 30 days for compliance pays roughly six times this (see sensitivity below). The honest range for this line is $0 to ~$8 for this topology, with $1–2 as the default-drift number for teams that never touched the retention setting.

Public egress: $4.00/month. 200GB × $0.02/GB in North America/Europe. This line is not new, but it is the multiplier everything else rides with: the moment your app serves real users, egress dwarfs both new charges combined.

Cross-region private transfer (new for MPG): $0.30/month. 50GB × $0.006/GB on granular rates. On a legacy non-granular org billed at the egress rate, the same 50GB costs 50 × $0.02 = $1.00 — more than triple, for identical packets. Same-region traffic is free either way, which is why the single-region version of this app never sees this line at all.

Total: $22.90/month (granular, NA/EU), before optional extras: a dedicated IPv4 at $2/month per app if you need one, single-hostname certs at $0.10/month beyond the first ten free, extra RAM headroom. Call it $23–25 all-in for the realistic invoice.

Two things to notice. First, the two new 2026 lines sum to $1.50 — about 7% of this bill. Nobody migrates over $1.50.

Second, the bill's variance now lives in the new lines' dimensions: add a region in the wrong group, extend retention for an audit, or grow replication traffic, and the meter moves without any deploy. That variance is the actual product change, and it is what the flat-rate column prices at zero.

Sensitivity: where the same app costs $23,$27, or $45​

A single worked example proves nothing if the conclusion flips on the first changed assumption. So here is the same topology repriced across the three variables that actually move it: region group, snapshot retention, and egress scale.

Region group moves the total most. Holding everything else fixed:

The compute and volume lines barely shift with regional markup (a dollar or two); egress and private transfer do all the damage. A Frankfurt-plus-Mumbai topology — entirely reasonable for latency — costs nearly double the Frankfurt-plus-Chicago one for byte-identical traffic. This is the line item to check before adding a region, not after.

Snapshot retention scales the backup line linearly-ish. At 5GB of daily churn per volume pair, stored snapshot data grows roughly with retention window: 5 days ≈ 25GB stored ($1.20 after the free 10GB), 14 days ≈ 45GB stored ($2.80), 30 days ≈ 80GB stored (~$5.60). Teams with compliance-driven 30- or 90-day retention should model snapshots as a $5–15 line, not a $1 line — still small, but now comparable to a whole Machine.

Egress scale buries both new charges. At 50GB/month egress, the NA/EU bill is ~$19.90 and the new lines are ~8% of it. At 500GB, the bill is ~$28.90 and egress alone ($10) exceeds compute-adjacent lines. At 2TB — a successful consumer app, not an outlier — egress is $40 and the conversation stops being about snapshots entirely. The general rule: under ~100GB/month, argue about snapshots and private transfer; over ~500GB, argue about egress; the region-group multiplier applies to both regimes.

The representative conclusion, not the flattering one: for a small NA/EU multi-region app, the two new 2026 lines add low-single-digit dollars. For the same app with an Africa/India region, long retention, or real traffic, they and their sibling egress meter add tens of dollars — on a base that started at $17.

The flat-rate side: two CX22s and two lines that read zero​

The comparison fleet is two Hetzner CX22 cloud servers — 2 shared vCPU, 4GB RAM, 40GB NVMe each, 20TB of included traffic per machine — at roughly €4.59/month each after the June 2026 repricing (older accounts may still show €3.79; budget €4–5 per node, ~$10/month for the pair). That price includes what Fly.io meters separately:

• Cross-node traffic: $0. Private networking between Hetzner machines in the same project rides the included-traffic pool; there is no per-GB private-transfer meter to consult, granular or otherwise. Two regions become two Hetzner locations (Falkenstein plus Ashburn, say) with the same zero marginal rate.
• Snapshot storage: $0 at this scale. Crash-consistent multi-volume snapshots (Kubernetes Volume Group Snapshots, GA since v1.36) or Hetzner-side snapshots land on disk and object storage you already pay for. The honest extra is automated backups at +20% per node (~€0.90) or a self-managed restic/off-site copy to Hetzner Object Storage at ~€0.005/GB — call the pair $10–12/month all-in with real backups, still flat.
• Egress headroom: 40TB combined included, ~€1/TB overage. The reference app's 200GB is 0.5% of the allowance. The 2TB "successful app" scenario that adds $40 on Fly.io adds $0 here.

The delta summary: ~$23 vs ~$11 at the reference point (roughly 2x), ~$45 vs ~$11 with an Africa/India region (roughly 4x), ~$59 vs ~$11 at 2TB egress (roughly 5x). The flat side does not win because any single line is cheaper — it wins because its marginal rate on the appellant's growth dimensions is zero until 40TB.

Self-hosting honesty requires the other column of the ledger: you now own Machine health checks, kubelet upgrades, volume-group snapshot schedules, and Postgres failover that Fly.io's control plane handled. A Cluster API-managed fleet (CAP Hetzner for provisioning, CloudNativePG for Postgres, Velero or native snapshots for backup) automates most of it, but "automated" is not "absent" — budget the setup weekend and the upgrade afternoon per Kubernetes minor. Teams that cannot staff that should keep paying the meter; the next section says exactly when.

When Fly.io still wins, and the migration checklist​

Three shapes of workload should stay on Fly.io without guilt. Single-region apps with spiky traffic never touch the inter-region line (same-region private traffic is free) and benefit most from per-second billing — a staging app that runs eight hours a day costs a quarter of its 24/7 sticker. Bursty preview and edge workloads that need Anycast, fast cold starts near users, and scale-to-zero are buying Fly.io's global edge fabric, not compute; no two-box Hetzner fleet replicates that. Small Postgres-backed prototypes where MPG's managed backups and point-in-time restore replace a weekend of CloudNativePG setup are correctly trading dollars for days.

Migrate when two conditions hold together: the topology is multi-region and stateful (so both new meters fire every month), and traffic is steady rather than bursty (so per-second billing saves nothing and flat hardware utilization stays high). That is the steady SaaS with a primary plus a replica, the API plus worker plus Postgres trio, the team whose invoice grows between deploys with no code change.

The checklist, in order: inventory every volume and its snapshot retention (disable or shorten what compliance does not require before migrating a backup bill you never chose); confirm your org's pricing mode (granular vs legacy — it changes the cross-region math 3x); measure actual cross-region bytes for a week rather than estimating (replication plus health checks surprise everyone); price the destination as two nodes plus backup, not one (HA is the point); and rehearse Postgres cutover with a real pg_dump/pg_restore round trip before cutting DNS. None of these steps is hard. Skipping the first two is how teams migrate the meter along with the app.

Fly.io's two new line items are individually reasonable — incremental snapshots at eight cents a gigabyte and cross-region traffic at six-tenths of a cent are close to underlying costs. What changed is not any single rate but the invoice's direction of travel: every platform capability converging on its own meter, each priced per gigabyte, each multiplied by region group. For steady multi-region apps, the alternative is hardware with a flat number on it: two machines, 40TB of included traffic, backups you schedule yourself, and a bill that reads the same in February as it did in January.

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.