Dora NodaRailway's rate card is genuinely simple: $20 per vCPU-month, $10 per GB-RAM-month, a $5/month Hobby plan that already covers that usage as credit. Run a real hobby project through it — half a vCPU, half a gig of RAM, a few thousand visitors, a small Postgres instance — and the bill lands at $10-15/month, all in. That number is not marketing. It is cheaper than most solo developers' phone plans.
Here's the part most "just self-host it" posts skip: price your own time at even $25 an hour and budget two hours a month to keep a server patched, and you've already spent $50 — more than the entire Railway bill — before the Hetzner box costs you a cent. The breakeven point between "pay Railway" and "own the machine" isn't a big number reached only at enterprise scale. At realistic ops-time assumptions, it can sit below the usage tier a real hobby project actually runs at. Below is the table that shows exactly where that line falls, and what changes it.
What Railway Actually Charges
Railway bills by the second for whatever a container consumes, on top of a small monthly base:
| Resource | Rate |
|---|---|
| Hobby plan base | $5/month (includes $5 of usage as credit) |
| Pro plan base | $20/month per seat (includes $20 of usage as credit) |
| vCPU | $20/vCPU-month ($0.000463/vCPU-minute) |
| RAM | $10/GB-month ($0.000231/GB-minute) |
| Network egress | $0.05/GB (inbound is free) |
| Volume storage | $0.15/GB-month |
Run a genuinely small hobby app through that card — a single web service on 0.5 vCPU / 0.5 GB RAM, a few thousand visitors a month, a small Postgres instance — and the compute alone works out to roughly $10 (RAM) + $5 (vCPU) before the Hobby plan's included credit and a little Postgres overhead. That's exactly how independent 2026 pricing write-ups land on the widely-quoted $10-15/month all-in figure for a solo hobby project — the number this whole comparison has to survive contact with, not a padded enterprise topology.
It's also, for what it's worth, cheaper than the same topology on Render or Fly.io's comparable tiers, which is why Railway keeps winning "cheapest managed option for a solo developer" comparisons in 2026.
What Owning the Box Actually Costs
A Hetzner CX22 — 2 vCPU, 4 GB RAM, 40 GB NVMe, 20 TB of included traffic — costs €4.35/month (about $4.70) after Hetzner's June 2026 repricing. That's the number every "self-hosting is cheaper" post leads with, and it's accurate as far as it goes: it comfortably fits the same hobby workload Railway charges $10-15/month for, with room to spare.
It's also not the full cost, because someone still has to run that box. Published estimates for what that actually takes vary by an order of magnitude depending on how automated the setup is:
- ~1-2 hours/month once a simple, stable single-app deployment is set up and left alone.
- 10-20 hours/month is the range that shows up most consistently across 2026 self-hosting cost breakdowns for OS updates, TLS certificate renewal, backup verification, monitoring, and the odd incident — covering security patching, deploy scripting, and capacity checks for a real production app, not a toy.
- 15-30 hours/month, trending toward Pragmatic Engineer's often-cited estimate of 312-1,300 developer-hours a year on security patching alone, for more complex, multi-service deployments.
None of those numbers has a single correct answer — it depends entirely on how much of the OS-and-certificate layer is automated versus hand-run. What they have in common is that they're rarely zero, and almost never priced into a "self-hosting only costs €4.35/month" comparison.
To make the comparison honest, this needs a second variable: what an hour of that time is actually worth. A conservative hobbyist opportunity-cost figure is around $25/hour; a professional's blended engineering rate is commonly cited around $75/hour. Both are legitimate — which one applies depends on whether the two hours a month come out of a side-project weekend or a salaried workday.
The Breakeven Table
Put the box cost and the time cost together — self-hosted total = $4.70 + (ops-hours × hourly rate) — and convert that dollar figure into the equivalent Railway usage it would take to cost the same, using the $20/vCPU + $10/GB rate card above. Treat "1 vCPU + 1 GB RAM, sustained for a month" as one combined unit — $30/month on Railway — since vCPU and RAM scale together on most real workloads, whether the extra load comes from more traffic, more services, or a bigger database:
| Ops time/month | @ $25/hour (hobbyist) | @ $75/hour (professional) |
|---|---|---|
| 2 hours | $54.70 total → ~1.8 Railway units | $154.70 total → ~5.2 Railway units |
| 5 hours | $129.70 total → ~4.3 Railway units | $379.70 total → ~12.7 Railway units |
| 10 hours | $254.70 total → ~8.5 Railway units | $754.70 total → ~25.2 Railway units |
| 15 hours | $379.70 total → ~12.7 Railway units | $1,129.70 total → ~37.7 Railway units |
| 20 hours | $504.70 total → ~16.8 Railway units | $1,504.70 total → ~50.2 Railway units |
Read the top-left cell first, because it's the one that actually matters for a solo developer: at just 2 hours a month, valued at a modest $25/hour, the breakeven point is around 1.8 combined vCPU+RAM units — smaller than the real hobby-project usage most solo developers run (Railway's own $10-15/month example uses roughly 0.5 of a unit).
That means the hobby-scale app this whole comparison started with never reaches the breakeven line at all. Priced honestly, Railway's sticker price wins outright at hobby scale the moment any of your own time counts for anything.
The table also shows where that flips. At a professional's $75/hour and a realistic 10-20 hours/month of real production-grade ops work, the breakeven point moves out to roughly 25-50 combined units — a multi-service app serving meaningful traffic with a real database, well past hobby scale.
So the honest answer to "where does the math flip" isn't a single number; it's a function of two things a generic cost comparison can't know for a specific reader: how many hours self-hosting actually costs them, and what their hour is worth. The traffic/service-count/database-size axis the question is usually framed around is really just a proxy for the vCPU+RAM units in the table above — more traffic needs more vCPU to serve it, a bigger database needs more RAM to cache it, more services multiply the same units across containers.
Why a Cluster-API PaaS Changes the Answer
The one lever in that table a solo developer can actually pull is the ops-hours column, and that's the entire pitch behind running a Cluster API-based platform on top of owned hardware instead of hand-rolling a VPS. What a Cluster API layer automates is specifically the part of the 10-20-hour estimate that's infrastructure, not application: node provisioning and health checks, OS-level lifecycle, and the TLS certificate rotation that shows up in every self-hosting time-cost breakdown. A git-push deploy pipeline replaces the deploy-scripting hours in that same estimate.
What it doesn't remove is the honest caveat this whole exercise depends on: a platform like bex — an open-source, Cluster-API-based PaaS that turns a git push into a running HTTPS service on Hetzner-owned machines — deliberately doesn't manage tenant databases. Backup verification and restore-testing for your own Postgres instance stay your job either way, because managed databases are a non-goal, not a missing feature.
So the realistic effect of automating the infrastructure layer isn't collapsing ops-hours to zero — it's moving a solo developer from the 10-20-hour row of the table down toward the 1-2-hour row, which is exactly the "once a simple, stable deployment is set up and left alone" scenario from the research above. At $25/hour and 2 hours a month, that's the top-left cell of the table: a breakeven point around 1.8 combined units, genuinely competitive with Railway's own hobby-tier pricing rather than requiring enterprise-scale traffic to justify owning the box at all.
The Decision Rule
Skip the marketing on both sides and run one calculation: your own hourly rate × your honest estimate of monthly ops hours, plus the box cost, against Railway's bill at your actual usage — not a hypothetical bigger one. If that number comes out below what Railway would charge for the same workload, owning the box wins. If it doesn't, the $10-15/month sticker price was correct all along, and no amount of "but it's only €4.35" changes that until either your traffic grows or your ops-hours shrink.
That second lever — shrinking the ops-hours, not waiting for traffic to grow — is the more useful one for most solo developers to pull, because it's the one variable in the whole table that's actually a product decision rather than a growth projection.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with node lifecycle and TLS handled by Cluster API instead of a personal cron job. Star the repo on GitHub or deploy your first app today.