Railway's $5 Hobby vs. a €10 Hetzner Box: What a Solo Dev Actually Pays for an API and a Worker

A solo dev ships a small API and a background worker. On Railway's Hobby plan, that two-service project looks like $5/month. On a Hetzner Cloud box, it looks like €10/month. Both numbers are real. Neither is the bill.

Here is the recomputed answer for the same always-on workload — an HTTP API plus one worker, each needing roughly 0.5 vCPU and 0.75 to 1 GB RAM, with a 10 GB volume and 80 GB of monthly egress — metered the way each platform actually invoices:

A single tiny service can hide inside the Hobby credit. The second service is where the credit runs out and per-minute metering takes over — and where a flat-price box stops looking expensive. The rest of this post shows every line's math, why that second service matters more than the first, and where Railway's meter genuinely wins.

What "$5" and "$20" Actually Buy on Railway​

Railway's 2026 pricing has confused people precisely because it looks simple. It is simple — just not in the "pay $5 and you're done" way.

The model: a flat monthly subscription that converts 1:1 into usage credits, plus metered overage.

• Free ($0): no persistent workloads. You get a trial credit ($5 one-time) but nothing stays running after it expires. This is not a free tier for production.
• Hobby — $5/month: includes $5 in usage credits. You pay $5 no matter what. If your metered usage is $3, you still pay $5. If it is $12, you pay $12 ($5 subscription + $7 overage, or equivalently, the full metered amount when it exceeds the floor).
• Pro — $20/seat/month: includes $20 in usage credits per seat. Same logic, higher floor. Pro also unlocks team seats, higher per-service caps (up to 48 vCPU / 48 GB RAM per service), and priority support.

The meters once credits are exhausted, billed per minute (rounded up from per-second measurement):

• RAM: $10 / GB / month → $0.000231 / GB / minute
• vCPU: $20 / vCPU / month → $0.000463 / vCPU / minute
• Volume storage: $0.15 / GB / month
• Network egress: $0.05 / GB (ingress free)
• Private networking between services: free for data transfer (compute for the services themselves still meters as above)

The critical detail: Hobby's $5 credit pool covers the workspace's total metered usage, not one service. Two services share one $5 credit. That is why every "Railway is $5" screenshot shows a single tiny service and why the bill moves the moment you add the worker every real app needs.

The Workload: One Boring, Representative Solo-Dev Stack​

Comparisons lie when they benchmark a micro VM or an enterprise monster. The fair shape is what a solo dev actually runs in production after the side project gets its first users:

• API: Node.js / Python HTTP service, 0.5 vCPU, 0.75 GB RAM, always on (730 hours/month). Not serverless — it stays warm for auth, webhooks, and low-latency reads.
• Worker: background job runner (queue consumer, cron, image processing, email dispatch), same shape — 0.5 vCPU, 0.75 GB RAM, always on. Most solo stacks need this on day two, not day hundred.
• Combined footprint: 1 vCPU and 1.5 GB RAM continuously allocated across two services, plus headroom for brief CPU bursts at deploy or during a queue drain.
• Volume: 10 GB persistent volume for Postgres / SQLite / object sidecars. Priced separately on Railway, included on Hetzner.
• Egress: 80 GB/month to the internet — API responses, image serving, webhook deliveries. Not viral, not idle; a real side-project with a few thousand active users and a marketing site.
• Region: North America / Europe (so Hetzner's included 20 TB and Railway's flat $0.05/GB both apply without regional surcharges).

Why this shape is representative: it is the smallest stack that is still two services (the pattern Railway's docs and templates push), it fits comfortably on a €10 Hetzner box without overprovisioning, and it surfaces the exact moment the Hobby credit runs out. Sensitivity — where the answer flips — is covered after the tables.

Line by Line: The Same Stack on Railway​

Every number below uses Railway's published 2026 Hobby/Pro rates and per-minute metering. Assume 730 hours (43,800 minutes) in the billing month.

One service in isolation (why "$5" feels true)​

¹ Railway charges the higher of subscription or metered usage. With one service the meter is $23, so you pay $23 (not $5 + $23). The "$5" headline only describes the subscription floor, not the overage.

Already, one mid-sized service blows past the Hobby credit by $18. A truly tiny service (256 MB / 0.25 vCPU) can stay under $5 — that is the screenshot that fuels the "$5" perception — but the solo-dev stack defined above is not that service. Drop the API to 512 MB / 0.25 vCPU and the single-service number is still roughly $11–14 before credits.

Two services (the real bill)​

With two always-on services, Hobby and Pro converge to the same payable number — the meter dominates and the subscription is just a credit toward it. The overage framing helps explain it: on Hobby you pay $5 + $35.50 overage; on Pro you pay $20 + $20.50 overage; both sum to $40.50 in real money leaving your card.

Scale the egress to 200 GB (a modest launch spike or heavier image hosting) and add $6.00 (120 GB × $0.05) to both Railway columns. The Hetzner column does not move.

Where the per-service multiplication hides​

Railway's headline per-GB and per-vCPU rates look cheap in isolation — $10/GB and $20/vCPU are roughly half what some managed Postgres add-ons charge. The multiplication is per service, not per workspace. Every queue worker, every preview environment, every cron sidecar adds another 0.5–1 GB and 0.5 vCPU slice at full meter. The credit pool does not multiply with services. That is the line that decides whether a solo-dev workspace costs $15 or $45.

The Same Stack on a €10 Hetzner Box​

Hetzner's Cloud price that anchors honest comparisons in mid-2026 is not the stale €3.79 CX22 blog posts still quote. After two 2026 adjustments — April 1 (cloud +30–37% in Germany/Finland, up to 38% in US/Singapore, hitting existing customers) and June 15 (standardized -1/-2/-3 SKUs, 113–175% on CCX/CPX dedicated and AMD-shared lines, new orders and rescales only) — the current shelf for a solo-dev-sized box is:

Sources: Hetzner price-adjustment notice (docs.hetzner.com, effective June 15, 2026), post-hike audits via costgoat.com / byteiota.com, vpsmaxxing comparison updated June 15, 2026. Euro-to-dollar at ~1.08.

For the workload above, the CPX21-class / CX32 at roughly €9–11/month is the fair "€10 box." What that buys that Railway meters separately:

• Compute: 2–4 shared vCPU and 4–8 GB RAM — enough to run the API, the worker, Postgres, and Redis on one machine under Docker/K3s without per-service metering.
• Storage: 40–80 GB NVMe included. The 10 GB volume that costs $1.50 on Railway is inside the box price.
• Bandwidth: 20 TB/month included per server, flat. The 80 GB egress that costs $4.00 on Railway is 0.4% of the allowance. Overage beyond 20 TB is €1.00/TB, not a per-GB meter that moves every month.
• No per-service tax: the third, fourth, and fifth container do not each add another $10/GB slice. They share the box until the box is full, then you scale the box — not the invoice line by line.
• What it does not include: you operate the box. OS patches, Postgres backups, and TLS rotation are yours (or your platform's), not the provider's. That is real cost, just not a metered line item.

Payable total on Hetzner for the two-service workload: €9–11/month (~$10–12) flat. Whether egress is 80 GB or 500 GB, whether the worker ran 730 hours or 200 hours, the invoice is the same number. At 80 GB the gap to Railway is roughly 3.4–4×; at 200 GB it is 4–5×.

Sensitivity: Where the Answer Narrows, and Where It Flips​

A single point comparison flatters whichever side picked the point. The honest question is where the flat box wins more, and where per-minute metering wins back.

¹ At 15% average utilization — a spiky API that sleeps between deploys and a worker that idles between queue bursts, with scale-to-zero or aggressive sleep — Railway's per-minute metering for 1.5 GB / 1 vCPU drops from $35/month continuous to roughly $5–7 for compute, plus volume and egress. Add the subscription floor and the practical payable lands around $12–15. Hetzner's box still charges for idle hours. The gap shrinks from 4× to near parity.

That last row is not a footnote. It is the whole reason metered billing exists.

Where Railway's Meter Genuinely Wins: Bursty, Low-Average-Load Workloads​

Hetzner wins every always-on comparison above because a flat box is priced for 100% utilization whether you use it or not. Railway wins the workloads where you do not need 100% utilization.

The bursty case. A side-project API that handles a few requests an hour, a webhook receiver that fires in bursts around deploys, an image-resize worker that runs for 90 seconds after an upload then sleeps for 40 minutes — these spend most of their allocated time idle. On a flat box, idle is still billed at the box rate. On Railway, idle RAM and vCPU still meter (there is no true scale-to-zero for a "sleeping" service that holds RAM), but a workload that can suspend between jobs, prune its replica count, or right-size to 256 MB between bursts burns meaningfully fewer GB-minutes than one pinned at 1.5 GB for 730 hours. The 15% row above — $12–15 vs. €9–11 — is that workload. Drop to 5% average with aggressive sleep and Railway can undercut the flat box outright.

The variable-traffic case. A project that does 20 GB egress in month one, 300 GB in month two (a Product Hunt spike), and 40 GB in month three pays that variance on Railway at $0.05/GB with no reprovisioning. On Hetzner the cost does not vary either — 0.1% to 1.5% of a 20 TB allowance — but the capacity headroom does: a spike that needs 4× RAM for 20 minutes still needs a box large enough to hold it, or an autoscaler and a second box. Railway absorbs that spike within the same per-minute meter without pre-provisioning.

The honest framing. If your two services are always on at the allocation above, the flat box is cheaper by a wide margin and gets cheaper still with every extra service. If your services are bursty, low-average, and can tolerate cold starts or brief scale delays, per-minute metering trades a higher per-unit rate for a lower average unit count — and can win. The break-even sits roughly where average utilization drops below 25–30% for the compute slice. Above that, own the box. Below that, rent the meter.

Choosing Without Lying to Yourself​

Three questions decide the pick faster than any feature matrix:

1. How many always-on services will you run six months from now? One tiny service can live inside the Hobby credit. Two always-on services already cost 3–4× a €10 box. Five services push the gap toward 8×, because per-service meters stack while a box shares. Count the worker and the preview environment, not just the API.

2. What is your real average utilization? If the answer is "my API is warm all day and my worker polls constantly," you are an always-on workload — price for 730 hours, not burst math. If the answer is "my app sleeps most of the hour and spikes at deploy," metered billing's lower average wins are real — measure the idle fraction before choosing.

3. Who operates the box? Railway's per-GB price bundles the operator: deploys from git, managed builds, automatic TLS, Postgres add-ons at a click. Hetzner's €10 buys hardware and bandwidth; you (or your platform) bring the PaaS layer. For a solo dev, that gap is either weekend yak-shaving or a platform like Bex.co that puts the PaaS on the box — push a repo, get a running HTTPS service on machines you own, with the box bill still the only bill. Price the operator honestly in both directions: Railway's meter is the operator's price, Hetzner's flat rate assumes you have one.

There is no moral to "self-hosting always wins." Sometimes renting the meter wins — specifically, when you need less hardware most of the time than you need at peak. For the common solo-dev pattern this post priced — a real API plus the worker it inevitably grows — the math points the other way, and it points there by a margin large enough that choosing the meter means choosing to pay for the operator, not for cheaper hardware.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. If the line-by-line above pushed you toward owning the box, the box can come with the PaaS attached. Star the repo on GitHub or deploy your first app today.