The Bandwidth Row Is the Bill: Railway's $50/TB Egress vs Hetzner's €1

Here is the entire post in one sentence: at roughly 200 GB of monthly egress, Railway's bandwidth charge alone costs more than running your whole app — compute, database, storage, and all — on a flat-rate Hetzner box. Everything below is the receipt.

Teams benchmark platforms on container prices. They compare vCPU and RAM, nod at the database row, and skip the transfer line because bandwidth sounds like a rounding error. On Railway in 2026, it is not a rounding error. It is a $50-per-terabyte meter running against a €1-per-terabyte alternative, and for any app that serves images, files, downloads, or a chatty API, that one row quietly becomes the bill.

The two rates, derived — not vibes​

No amortized hand-waving. Both numbers come straight from published unit prices:

• Railway: $0.05 per GB of network egress, billed per second against plan credit (Railway's own 2026 pricing breakdown). Multiply by 1,000 and one terabyte costs $50.
• Hetzner: €1 per TB of traffic overage on Cloud servers in EU regions, roughly $1.12 at GetDeploying's conversion (Hetzner vs Railway, 2026). Inside the included 20 TB monthly allowance, the marginal terabyte costs €0.

The gap: ($50 − $1.12) / $50 = 97.8%, which GetDeploying rounds to 98% cheaper on Hetzner. For calibration, their 34-provider egress survey (updated September 2026) puts the median paid egress price at $41.09/TB — Railway's $50 sits above the industry median, while Hetzner's $1.12 is the cheapest paid rate listed.

Now watch what that meter does at real traffic levels. Egress cost only, both sides:

At 20 TB, Railway egress alone is a thousand dollars. On the Hetzner side it is still zero — and even past the allowance, the next terabyte is €1, not $50.

The rest of the table, in 60 seconds​

Egress is the outlier, but it helps to see what surrounds it. GetDeploying's closest-configuration comparison prices the same shapes on both platforms:

Two things worth noting. First, the compute gap is already enormous — but compute is the row everyone already argues about. Second, Hetzner has no managed-Postgres row at all: on the owned side you run Postgres yourself on the same box, which costs $0 extra and some of your ops time.

That asymmetry matters, and we will come back to it. But the headline stands: storage rows differ by half to two-thirds, compute by up to 94%, and egress by 98% — off a base rate fifty times higher per unit.

A worked bill for a bandwidth-heavy app​

Comparisons of unit prices are abstract. Here is a concrete, typical shape: a small SaaS with a 2 vCPU / 4 GB app, a 2 vCPU / 4 GB / 50 GB Postgres, and a few GB of volume storage — then we vary only the traffic.

Railway (metered, 100% utilization for the compute rows):

• App: 2 × $20/vCPU + 4 × $10/GB RAM = $80
• Postgres: $40 + $40 + 50 × $0.15 volume = $87.50
• Compute + storage subtotal: ~$168 (the $5 Hobby or $20 Pro fee is absorbed — Railway charges fee or usage, whichever is higher, and usage wins here)
• Egress at 100 GB / 1 TB / 5 TB: $5 / $50 / $250

Railway totals: ~$173 → ~$218 → ~$418/mo as traffic grows.

Hetzner (everything consolidated on one box):

• One CX33 (4 vCPU / 8 GB, local NVMe): $10.06/mo — app and self-managed Postgres share the box
• Optional LB11 load balancer: $8.39/mo (many single-box setups skip it; included below as the honest upper bound)
• Egress at 100 GB / 1 TB / 5 TB: $0 / $0 / $0 (all inside the 20 TB EU allowance)

Hetzner totals: ~$10–18/mo at every traffic level.

The delta at 1 TB of transfer is roughly $200/mo — $2,400 a year — for an app most developers would call small. At 5 TB it passes $400/mo. And notice the shape of the two curves: the Hetzner line is flat while the Railway line climbs $50 per terabyte, because only one side meters the thing a bandwidth-heavy app consumes most.

One fairness adjustment strengthens rather than weakens this point. Railway bills actual CPU/RAM consumption per second, so a bursty app averaging 30% utilization pays roughly $50 for compute instead of $168. But egress has no utilization discount — bytes are bytes.

At 1 TB, the $50 bandwidth row then roughly equals the entire compute bill. The less your app computes relative to what it serves, the more the bandwidth row dominates. Media hosting, file downloads, software distribution, image-heavy storefronts, and polling APIs live exactly in that corner.

The threshold, exactly​

Three crossover numbers pin the decision down:

1. ~200 GB/mo — Railway egress ($10.05) passes the price of the entire Hetzner CX33 box ($10.06). Past this point, bandwidth alone costs more than somebody else's whole server.
2. ~3.3 TB/mo — Railway egress ($167.50) passes the entire Railway compute bill ($168) for this stack. Past this point, you pay more to move the bytes than to produce them.
3. The next terabyte — $50 on Railway versus €0 inside Hetzner's allowance, €1 past it. Every additional terabyte of growth costs fifty times more on the metered side.

Sensitivity check: these thresholds assume the CX33-class box. Drop to the smaller CX23 ($6.71) and crossover #1 falls to ~134 GB/mo. Add the load balancer ($18.45 all-in) and it rises to ~369 GB/mo. The conclusion survives the whole range — somewhere between one and four hundred gigabytes a month, the bandwidth row buys a server.

What the $50 buys, and what the €1 doesn't​

A one-sided teardown would be dishonest, so here is the other ledger.

Railway's $50/TB comes with: per-second billing that genuinely saves money on spiky workloads, app sleeping for idle projects, zero server ops, managed Postgres with backups, preview environments per pull request, and regions across the US, EU, and Asia on hardware Railway itself owns. For a side project doing 10 GB of egress, the bandwidth row is fifty cents and none of this post matters — stay, ship, sleep well.

Hetzner's €1 comes with caveats. The 20 TB allowance is an EU-region figure: US locations include far less (around 1 TB on small instances) and Singapore includes just 0.5 TB with a steep €7.40/TB overage (regional allowance breakdown) — so an Asia-serving app must redo this math. There is no managed database, no sleeping, no per-PR environments; backups, patching, Postgres tuning, and the 3 AM page are yours. And a single box in Nuremberg is not a global footprint — latency to distant users is physics, not pricing.

The fair summary: Railway sells freedom from operations with bandwidth as the margin; Hetzner sells raw capacity with operations as the cost. The question is never "which is cheaper" in the abstract — it is whether your traffic has crossed the point where the ops you avoid costs less than the bandwidth you burn.

Three ways to cut the bandwidth row​

If the thresholds above made you wince, you have options in increasing order of commitment:

1. Stop serving bytes from app servers. Push downloads, images, and assets to object storage fronted by a CDN or a zero-egress-fee store — Cloudflare R2 charges no egress at all, and Hetzner's own object storage meters egress at €1/TB. For asset-heavy apps this alone can remove most of the metered transfer without moving a single container.
2. Shrink what you must serve. Compression, aggressive cache headers, responsive image sizing, and replacing polling with webhooks or server-sent events all reduce the meter directly. This is also just good engineering.
3. Move to flat-rate hardware. When monthly egress alone exceeds the price of the box that could serve it — that ~200 GB line for a CX33-class workload — the migration pays for itself in weeks, not years. Consolidate app and database on one server, keep the CDN in front, and the bandwidth row drops out of your budget vocabulary.

The deeper lesson is about how teams shop for platforms. Container prices are the showroom sticker; bandwidth is the financing. Railway's $20/vCPU and $10/GB RAM look reasonable next to a hyperscaler — and they are — but nobody's bill ever blew up on vCPU.

It blows up at $0.05/GB, one thousandth of a terabyte at a time, until the transfer line is the biggest number on the invoice. Price the bandwidth row first. Everything else is commentary.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. If your bandwidth row is doing the spending above, Star the repo on GitHub or deploy your first app on hardware with a flat-rate transfer allowance today.