Railway's $5 Hobby Plan Is a $5 Credit, Not a $5 Flat Fee: Where It Beats — and Loses to — a €4 Hetzner Box

Railway charges $5 a month for Hobby and $20 for Pro. A Hetzner CX22 costs €3.79 a month flat and ships with 20TB of traffic. One looks like a subscription. The other is a computer. Only one of them stays the same number when your app grows.

The confusion is intentional — not deceptive, just well-branded. Railway's Hobby $5 is not a fee for a 512MB box. It is $5 of usage credit toward whatever you actually burn at $10/GB RAM/month and $20/vCPU/month, metered by the second. The flat language hides the meter, and the meter is where every real bill is decided.

This post is the teardown the title promises: how each price actually works, what the same three workloads cost line by line on Railway versus a flat Hetzner CX box, and the exact usage level where the meter overtakes the metal.

Why it matters now: Railway's hybrid model — subscription counted as credit plus metered overage — has stayed stable while every adjacent PaaS repriced around it. Vercel repriced four times since 2024, Render cut Hobby egress from 100GB to 5GB effective August 1, 2026, and Fly.io added two new metered lines (volume snapshots in January, inter-region private networking in February 2026). When fixed allowances shrink and new meters appear, a "flat subscription" that is really a meter deserves its own line-by-line audit.

TL;DR: The three-tier teardown in one table​

This is the table you came for. All numbers are monthly, 730 hours. Railway RAM is $10/GB/month and vCPU is $20/vCPU/month; the $5 Hobby or $20 Pro fee is consumed as usage credit, not added on top — overage is billed only after credit is exhausted. Hetzner CX22 is €3.79/month (2 vCPU, 4GB RAM, 40GB SSD, 20TB traffic) at ~$4.10 at EUR/USD 1.08; CX32 is €6.80/month (4 vCPU, 8GB RAM, 80GB SSD, 20TB traffic) at ~$7.35. Railway egress ($0.05/GB) and volume storage ($0.15/GB/month) are excluded below to keep the comparison on the load-bearing meter — compute and RAM — with a sensitivity note after the table.

Bottom line before the detail: Railway is cheaper at truly idle only because the $5 credit almost covers a tiny 0.5GB footprint. At anything that stays awake — 2GB+ — the flat box is already 4–8× cheaper, and every extra gigabyte widens the gap linearly at $10/GB with no ceiling.

How Railway actually bills: a credit, not an allowance​

Railway's pricing page reads like a subscription. Its invoicing behaves like a utility meter with a minimum.

The plan fee is credit:

• Hobby — $5/month includes $5 of usage credit. You are not buying 512MB or 1 vCPU; you are prepaying $5 toward whatever you burn. Burn $4.80 and you paid $5 for $4.80 of usage. Burn $10 and you pay $5 + $5 overage.
• Pro — $20/month per seat includes $20 of usage credit per seat. Same logic at a higher floor. Workspace seats are billed separately but the credit pools against usage. Trial and Free tiers give a one-time $5 credit with tighter caps.
• Overage is per-second: RAM at $10/GB/month ($0.00000386/GB-second), vCPU at $20/vCPU/month ($0.00000772/vCPU-second). A 1GB service left on for 730 hours (one month) costs exactly $10 whether it served one request or one million.

Three other meters you will meet:

• Network egress — $0.05/GB. Private networking between Railway services in the same environment is free, but any byte that leaves Railway — including an app reaching a database over the public URL instead of the private one — counts. A docs note explicitly warns that public-URL database connections are a common source of surprise egress.
• Volume storage — $0.15/GB/month ($0.000021/GB-minute). A 10GB Postgres volume is $1.50/month regardless of how much of it is filled. Railway Metal (the newer host tier) recently cut this from $0.25/GB, but the meter remains.
• The sleeping footnote: Railway Serverless can sleep after ~10 minutes without outbound traffic; wake can 502 the first request if a DB connection or telemetry stream did not keep it alive. "Scale to zero" saves money only if your app actually qualifies to sleep — many production apps with a Postgres connection pool do not.

The rate card looks small until you multiply by always-on hours. That multiplication is the whole story.

How Hetzner CX actually bills: a flat monthly number that includes the bandwidth​

The box that makes every Railway comparison look expensive on paper is not expensive:

• CX22 — €3.79/month (or ~€4.35 in some April 2026 catalog snapshots after the repricing wave; the underlying price is hourly ~€0.006/hour, capped monthly). 2 shared vCPU, 4GB RAM, 40GB NVMe, 20TB monthly traffic, 1 IPv4.
• CX32 — €6.80/month. 4 shared vCPU, 8GB RAM, 80GB SSD, 20TB monthly traffic.
• Bandwidth is not a meter at these sizes. Hetzner's EU regions include 20TB per server (US regions 1TB). Overage is €1/TB — essentially a rounding error. At Railway's $0.05/GB, 20TB would be $1,000. At Vercel's $0.15/GB overage, it would be $3,000. On a CX22 it is zero.

The tradeoff is not hidden: you own the machine. OS patches, Docker daemon health, disk-full pages, and backup snapshots are yours. The flat number stays flat exactly because nothing is metering you per gigabyte or per second — including no one else to page when the disk fills at 2 a.m.

The three tiers, worked line by line​

Assumptions for all tiers: 730 hours/month, no egress or volume storage counted yet (sensitivity added below), EUR/USD 1.08, Hetzner EU region. Railway usage = RAM × $10 + vCPU × $20, then minus credit.

Tier 1: Idle side project — the one place Railway almost wins​

A hobby Next.js app, a 1GB Postgres, a cron that wakes it twice a day. Real average footprint if you set conservative limits: ~0.5GB RAM, ~0.25 vCPU (Railway lets you cap RAM per service; CPU is burstable but billed on actual use).

• Railway raw: 0.5 × $10 = $5.00 RAM + 0.25 × $20 = $5.00 vCPU → $10.00
• Railway Hobby bill: $10.00 − $5.00 credit = $5.00 (plus pennies of egress if you push images)
• Railway Pro bill: $10.00 sits inside the $20 credit → $20.00 flat (you overpaid — Pro is the wrong tier for idle)
• Hetzner CX22: $4.10 flat, 3.5GB of RAM still empty doing nothing, 20TB of traffic still there

Verdict: Hobby costs about $0.90 more than the raw box — essentially a tie, and the narrowest win Railway will ever have. You are paying $0.90 for git-push deploys, automatic TLS, and not patching Ubuntu. Many teams correctly decide that is worth it at idle.

Add a 5GB Postgres volume ($0.75) and 20GB of egress ($1.00): Hobby becomes ~$6.75 vs CX22 at $4.10 + ~$0.75 for a Hetzner volume snapshot. Gap widens to ~$1.90 — still a judgment call, not a blowout.

Tier 2: Steady small production — where the meter pulls ahead and stays there​

An API service (1GB), a background worker (0.5GB), and Postgres (0.5GB). Always on. Real average: ~2GB RAM, ~1 vCPU.

• Railway raw: 2 × $10 = $20 + 1 × $20 = $20 → $40.00
• Railway Hobby: $35.00 ($40 − $5)
• Railway Pro: $20.00 ($40 − $20)
• Hetzner: CX22 $4.10 (2 vCPU / 4GB covers it with headroom) or CX32 $7.35 if you want breathing room

Verdict: The flat box is 4.9× cheaper than Pro, 8.5× cheaper than Hobby. The $5 or $20 credit is now noise — 12% and 50% of raw usage respectively, and shrinking every month traffic grows. Add 10GB of volume ($1.50) and 100GB egress ($5.00): Railway grows to $41.50 (Pro) vs Hetzner at ~$5.60 with volume. The egress line hurts Railway 50× more per GB than Hetzner ($0.05/GB vs effectively $0.00005/GB on the 20TB allowance).

This is the tier most "my Railway bill doubled" posts are actually in: not huge, just always on. Always-on is expensive on a per-second meter by definition.

Tier 3: Bursty growth — three services, a staging env, real data​

Add a second API replica for deploys, a Redis cache, a staging environment that mirrors prod for preview branches. Footprint: ~6GB RAM, ~2 vCPU across 5–6 services, bursty CPU but RAM is allocated the whole time.

• Railway raw: 6 × $10 = $60 + 2 × $20 = $40 → $100.00
• Railway Hobby: $95.00 · Pro: $80.00
• Hetzner: two CX22s ($8.20) or one CX32 + one CX22 ($11.45) or even a single CX32 if you bin-pack tightly — all under $14.70 with full headroom

Verdict: 6–11× gap. At this size you are no longer comparing a subscription to a server — you are comparing a linear per-GB meter with no ceiling to a flat box where the next gigabyte up to 4GB or 8GB costs $0. The staging environment alone is the tell: on Railway it doubles the meter; on Hetzner it is another container on a box you already paid for.

Sensitivity check — what the two excluded lines actually add:

• Every extra 1GB of RAM that stays allocated is +$10/month on Railway, $0 on a Hetzner box with headroom and at most a one-time bump to the next CX size ($3.25 from CX22→CX32).
• Every 100GB of egress is +$5 on Railway, $0 on Hetzner until you somehow exceed 20TB — at which point it is €1/TB, or 50× cheaper per GB.
• Every 10GB of volume is +$1.50 on Railway, ~$1.19 on Hetzner snapshots — the one line that is close to parity.

The crossover formula — the exact point where renting costs more than owning​

Because Railway's tiers are just credit thresholds on the same per-unit rates, the crossover is a one-line inequality:

Railway total = max(planFee, RAM × $10 + vCPU × $20 + egress × $0.05 + volume × $0.15) Hetzner total = flat box price (CX22 ~$4.10 or CX32 ~$7.35) Crossover when RAM × 10 + vCPU × 20 > Hetzner flat — and because the plan fee is credit, the "max" stops mattering once you pass ~0.5GB.

In practice, tying vCPU to RAM at a common 1 vCPU per 2GB (a typical Node/Rails packing ratio) gives a clean rule of thumb:

Read that again: at the packing ratio most small apps actually run, 0.20GB of sustained RAM already costs more on Railway's meter than an entire CX22. The $5 or $20 credit delays the invoice by that many dollars — it does not change the slope. Every real production app that stays resident overnight is past the crossover before it serves its first request.

The honest counterpoint is that many hobby apps do not stay resident. If Railway Serverless actually sleeps your service and your traffic fits in ~100 hours/month of wake time, that 2GB footprint costs ~$5.50 instead of $40 (2 × $10 × 100/730 + 1 × $20 × 100/730). That is the one shape where the per-second meter wins — spiky, mostly idle. As soon as always-on is required — a Postgres, a queue worker, a WebSocket server — the flat box reclaims the advantage by definition.

Why "flat subscription" language is expensive — even when the per-unit price looks cheap​

$10/GB and $20/vCPU sound cheap in isolation. They are not cheap when the unit is time, not events.

A $5-per-month subscription suggests a budget. A per-second meter with a $5 minimum is a budget only for the first ~0.25GB — after that, it is an unbounded function of how long your containers stay up. Two consequences follow that no pricing page warns you about:

1. Your bill is a function of uptime, not traffic. Doubling requests from 100k to 200k barely moves the Railway invoice if RAM/vCPU stayed flat. Leaving a 1GB staging environment running overnight for a week moves it $2.50 (1 × $10 × 168/730). The flat box charges zero for the same week.

2. The number you see is not the number you budget. At $35 or $41 with a few GB and normal egress, a "Hobby $5" app's bill already reads like a Pro tier in disguise. The language — Hobby, Pro, credit — anchors expectations at $5 and $20. The meter bills at $100 for a 6GB fleet long before any dashboard warns that "Hobby" no longer describes the workload.

This pattern is not unique to Railway. Every PaaS that added meters in 2026 — Fly.io's inter-region traffic and snapshots, Render's metered egress cut, Cloudflare Workers' metered Durable Objects storage since January 2026 — sharpened the same lesson: the base fee is the smallest line on the invoice that matters, and the line that scales with residency is the one that ultimately decides whether self-hosting wins.

What this means if you own the metal​

None of this is an argument that Railway is overpriced. For a side project that sleeps, for a prototype that ships in an afternoon, for a team that values zero ops over zero meters, $5 to not think about servers is a good trade. Railway's per-second billing is genuinely cheaper than Vercel's per-invocation Active CPU ($0.128/hour) or Fly.io's per-VM-second model for spiky workloads that can sleep.

It is an argument that a model that charges for residency cannot be compared to a model that does not on the basis of its minimum. The Hetzner number is the same every month because nothing is metering. The Railway number is a function of GB × hours × $10 and vCPU × hours × $20 with a $5 or $20 floor. They are not two prices for the same thing any more than a taxi meter and a monthly bus pass are.

If you are already past the crossover — 2GB+, always on, a staging env you leave running — the self-hosted math is not close, and the platform question becomes: can you get Railway's UX without Railway's meter?

That is the seam a Cluster-API-managed fleet is built to close. A Render-compatible API on machines you own — a CX22 or CX32 you already pay for whether it is idle or saturated, with 20TB of traffic that does not meter — gives you the git-push, preview-deploy, managed-service surface without renting the underlying residency by the GB-hour. The hardware bill is the only bill.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. No per-GB RAM meter, no per-second vCPU line — just the flat Hetzner box underneath. Star the repo on GitHub or deploy your first app today.