Dora NodaEveryone comparison-shops PaaS pricing and nobody prices the fourth option. In June 2026, ExpressTech priced the same boring app on Render, Railway, and Fly.io — a small always-on Node service, a small Postgres next to it, 50 to 100 GB of monthly egress — and found a roughly 5x spread between the cheapest and most expensive way to run it. I took their line items and recomputed every one against owned Hetzner hardware.
Here is the verdict first: a single €4/month cloud VM runs their entire test app for about $5 a month all-in, undercutting every hosted configuration on the table — while a €46/month dedicated box loses money on one app but drops below $2 per app once you bin-pack thirty of them onto it. The hosted platforms still win exactly two cases: the lone tiny app that idles most of the month, and the team with zero appetite for operating anything.
| Configuration | Monthly total, same test app |
|---|---|
| Render, Hobby workspace | ~$21–28 |
| Render, Pro workspace | ~$43–50 |
| Railway, metered (~$20 typical) | ~$15–27 |
| Fly.io, DIY Postgres | ~$8–11 |
| Fly.io, Managed Postgres | ~$42–45 |
| Owned Hetzner cloud VM (CX22-class, ~€4) | ~$5 |
| Owned Hetzner AX42 dedicated (€46, one app) | ~$53 |
That last row is the honest one people skip: owning a whole dedicated server for a single 512 MB app is the most expensive option on the table. The owned-hardware story only works through bin-packing, and the rest of this post does that math properly — per-app cost at one, three, ten, and thirty apps, plus the bursty and egress-heavy cases where the answer flips.
What ExpressTech actually priced
Credit where it is due: the ExpressTech teardown is the rare pricing post that prices a concrete thing instead of waving at pricing pages. The spec is deliberately boring — the kind of thing a side project or a small SaaS actually runs:
- One small always-on Node service (512 MB RAM class)
- One small Postgres database beside it
- 50 to 100 GB of outbound transfer a month
Their findings, briefly: Render looks flat until you hit the April 2026 bandwidth cut (included egress dropped from 100 GB to 5 GB on Hobby and 25 GB on Pro, with overage at $0.15/GB), so a solo dev pays roughly $21–28 and a team on the $25 Pro workspace pays roughly $43–50. Railway meters everything per second ($20/vCPU, $10/GB RAM, $0.05/GB egress) with no spending cap, landing around $20 for the test app — fair until a leak or spike meets an uncapped meter. Fly.io is cheapest on raw compute (~$3.32 for the app) but splits in two on the database: about $8–11 if you run your own Postgres, about $42–45 once you pay $38 for Managed Postgres.
The spread from cheapest to priciest is roughly 5x, and ExpressTech's punchline is that none of the three sells a flat, knowable number. That is the exact seam to recompute: what happens to every one of those line items when the machine is yours?
Recomputing it line by line
The recompute uses two owned configurations, both current Hetzner list pricing. Option A is a CX22-class cloud VM — 2 shared vCPUs, 4 GB RAM, 40 GB NVMe, about €4 a month (~$4.50), with 20 TB of included traffic. Option B is an AX42 dedicated server — 8-core Ryzen 7 PRO, 64 GB DDR5, 2x512 GB NVMe, €46 a month plus a €39 one-time setup fee, also with effectively limitless included bandwidth for this workload.
Compute: the meter disappears. The test app needs roughly 0.5 vCPU and 512 MB. On the €4 VM that is an eighth of the box; the metered equivalent (Railway's RAM pricing alone is $5 for that 512 MB) costs more than the entire VM. On the AX42 the app is background noise — under 1% of RAM. Owned compute is a step function, not a meter: you pay for the box, and marginal apps are free until the box fills.
Database: the DIY caveat, priced honestly. Self-hosting Postgres on your own box is operationally identical to Fly.io's cheap number — unmanaged Postgres you back up yourself. So compare like with like: the owned configurations compete with Fly DIY ($8–11), not with the $38 managed plan. If you need a managed database with point-in-time recovery and a support contract, none of the owned numbers below apply to you; buy RDS or stay on a managed plan. This is the single most common cheat in self-hosting math, and I am not doing it here.
Egress: the line item that vanishes. This is where owned hardware beats all three vendors outright, with no asterisks. The test app's 50–100 GB costs $7–14 on Render's $0.15/GB overage, $2.50–5 on Railway's $0.05/GB, and $1–2 on Fly's $0.02/GB (North America/Europe). On either Hetzner box it costs exactly $0 — 100 GB is 0.5% of the 20 TB included allowance.
Egress is also the axis where the vendors' bills scale worst: at 2 TB a month, Render charges ~$300, Railway ~$100, and Fly ~$40, while the owned number stays $0. Any workload that moves real bandwidth — assets, APIs with chunky responses, anything user-facing at scale — should price egress before it prices compute.
The fees that evaporate. Render's $25 Pro workspace fee: gone. Fly's $2 dedicated IPv4: included with the box. Per-service minimums, per-seat anything, overage cliffs at 5 GB: all gone. What replaces them is a €39 setup fee on the dedicated box (about $3.25 a month amortized over a year) and snapshot storage at roughly a cent per GB-month. The owned bill has two lines; the hosted bills have six.
The crossover math
One app on one dedicated server is a waste of a server, so here is the per-app monthly cost as the fleet grows. Mid-estimates, 75 GB egress per app, one Postgres per app except where noted:
| Apps | Render Hobby | Railway | Fly DIY | Fly Managed* | Cloud VM (~$5) | AX42 (~$53) |
|---|---|---|---|---|---|---|
| 1 | ~$25 | ~$20 | ~$9.50 | ~$43 | ~$5 | ~$53 |
| 3 | ~$75 | ~$45 | ~$28 | ~$53 | ~$5 | ~$53 |
| 10 | ~$250 | ~$125 | ~$95 | ~$86 | ~$15 (3 VMs) | ~$53 |
| 30 | ~$750 | ~$375 | ~$285 | ~$200 | n/a | ~$53 |
*Managed Postgres shared across apps: one $38 plan plus per-app compute and egress.
Three crossovers matter. First, the cloud VM beats every hosted configuration from app one — $5 flat against Fly DIY's $9.50 — because a 4 GB box comfortably holds two or three of these stacks with room for the OS. Second, the dedicated box crosses the cheapest hosted option (Fly DIY) at about six apps and then flatlines: at thirty apps it is under $1.80 per app while Fly DIY is still charging $9.50 each. Third, Render's egress overage makes it scale worst: at ten apps the $0.15/GB meter alone (~$112) costs more than twice the entire dedicated server.
Now the two cases where the table flips. The bursty app — staging environments, internal tools, side projects idle 90% of the month — is the owned model's worst case. Fly's per-second billing drops an idle-mostly app to $1–2 a month, while the owned VM still costs its flat $5. If your fleet is mostly idle, the meter is a feature, not a bug.
And the single-app-no-more case is real: if you will only ever run one tiny service and it fits Fly's cheapest machine, $8–11 with zero operations is a better deal than $5 plus your time. The owned story needs either steady utilization or more than one app; with neither, stay hosted.
What the owned number honestly excludes
Self-hosting math that stops at the hardware price is marketing, so here is the rest of the invoice. First and largest: your time. Somebody provisions the box, patches the OS, upgrades Postgres, rotates TLS certs, and gets paged when a disk fills at 3 AM. At any realistic engineering hourly rate, two unplanned hours a month exceeds the entire price gap on a single app. The honest pitch for owned hardware starts at "we already operate boxes" or "we run enough apps that the savings buy the pager duty."
Second: availability. One VM is a single failure domain — no live migration SLA, no multi-AZ failover. The hosted platforms replicate and reschedule behind the scenes; your €4 VM does not. Third: backups. Hetzner snapshots and automated backups exist and are cheap (snapshots at roughly a cent per GB-month, automated backup at 20% of server price on dedicated), but they are a checkbox you must tick and a restore you must test, not a managed guarantee. Fourth: the managed-database gap from the previous section, restated because it bears repeating — the owned Postgres is DIY Postgres, with DIY backups, DIY failover, and DIY upgrades.
None of this is disqualifying; it is the actual price. A team running ten apps on one AX42 at $53 a month total can afford to spend some of the ~$200-a-month savings over Render on backup storage, a second box, and monitoring. A solo dev with one side project cannot amortize any of it, which is why the crossover table has a "stay hosted" region.
Where hosted still wins
Give the vendors their due — each one is the right answer for a specific shape of workload. Fly.io wins the lone tiny app and anything bursty: per-second billing on a shared-cpu machine is the cheapest way to exist on the internet, and its multi-region story (anycast, regional Machines, $0.02/GB egress in NA/EU) is a genuine moat no single Hetzner box can replicate. If your app needs to be close to users on three continents, stop reading pricing tables and use Fly.
Railway wins developer experience for teams that will actually set up spend alerts: the dashboard, templates, and deploy flow are the best of the three, and $20 for a small production app with zero ops is a fair price. It loses on predictability — the uncapped meter is the most common complaint for a reason — but a team that watches usage gets a good platform.
Render wins the team that wants hosting to feel like hosting: flat per-service prices, a real (if sleepy) free tier, and the $25 Pro workspace is cheap compared to two hours of anyone's time. It loses on bandwidth: the 5–25 GB allowances mean any app that serves real traffic should model egress first, because $0.15/GB compounds faster than any other number in this post.
And all three win the zero-ops team outright. If nobody on the team can SSH into a box and fix Postgres at midnight, the managed premium is not a tax — it is the product.
The flat number under the meters
ExpressTech's teardown ends by noting that none of the three platforms sells a knowable number. The recompute adds the missing row: owned hardware sells exactly that, at roughly $5 a month for the first few apps on a cloud VM and roughly $53 flat for up to thirty on a dedicated box. The metered platforms win idle and tiny; the owned box wins steady and many; egress-heavy workloads are not close at any scale.
The deeper pattern is who absorbs variance. On Railway and Fly, your traffic variance becomes invoice variance. On Render, it becomes overage variance past a small allowance. On your own box, variance becomes headroom variance — the bill never moves, and the only question is how full the machine gets. For a fleet of steady production apps, that is the better place for variance to live.
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.
