Railway Won the Default for Small Projects in 2026 — Here Are the Edge Cases That Push Growing Teams Off It

If you ask 2026's PaaS commentary where a side project should live, the answer comes back fast: Railway. Fastest time from git push to running URL, a one-time $5 trial credit instead of a demo-day sales call, and metered pricing — about $20 per vCPU-month and $10 per GB-RAM-month — that keeps a real hobby stack in the $10–15/month range. Render is the quiet flat-rate alternative, Fly.io is the metered-everything edge play, and since Heroku's early-2026 retreat into sustaining engineering, all three have been absorbing migrating teams. Railway absorbed the small ones first.

That default is deserved. It is also bounded. Talk to teams six months past their first deploy and the same five edge cases come up every time — each with a concrete trigger, each with a dollar figure attached. This post is that inventory, plus the bill-size threshold where the same workloads on a fixed box stop being a hobby and start being the cheaper, more predictable platform.

None of these is a reason to avoid Railway on day one. Every one of them is a reason to know exactly where the exit ramp is before you need it.

1–2. The meter never sleeps, and previews multiply it​

Railway's rate card is genuinely simple: $0.00000772 per vCPU-second and $0.00000386 per GB-RAM-second, which works out to roughly $20/vCPU/month and $10/GB/month for anything running continuously. Volumes add $0.15/GB/month and public egress $0.05/GB. The Hobby plan costs $5/month and includes $5 of usage; Pro costs $20 per seat and includes $20 of usage. So far, so legible.

The surprise is not the rates. It is the duty cycle. Railway does not offer scale-to-zero: on a paid plan your services stay warm — and billing — even when nobody is using them.

Fly.io will park an idle Machine and wake it in 300ms–2s; Render's free tier at least sleeps (with a painful 30–60 second cold start as the price). Railway bills the midnight-to-6am shift at the same rate as peak hour. A staging environment, an internal tool, a Postgres instance serving a low-traffic app: all full rate, all month.

Preview environments multiply the effect. Railway auto-creates an environment per pull request and deletes it on merge, which is excellent DX — and each open PR is a set of live services drawing from the same usage pool. Three open PRs with a database each means six extra services billing simultaneously.

Teams running branch previews typically budget $15–30/month above their production cost, a line item that does not exist on platforms where previews are bundled or free. Render's previews are full infrastructure copies too, but they sit behind previewPlan and expireAfterDays controls on a $25/month flat workspace. Fly.io makes you wire previews yourself through GitHub Actions, which is worse DX but means you never pay for a preview you did not explicitly build.

This is the bill-unpredictability complaint in its concrete form: not that the rates are high, but that the bill moves with developer behavior — open PRs, forgotten staging services, a worker nobody remembered to stop — rather than with traffic. A flat-rate Render service costs $7 or $25 whether your team opened two PRs or twenty.

3. The filesystem is amnesiac​

Every Railway deployment gets ephemeral disk: 1 GB on the trial, 100 GB on a paid plan. Exceed the cap and the deployment can be force-stopped and redeployed. Anything written to local disk — uploads, SQLite files, caches, build artifacts — vanishes on the next deploy or restart unless it lives on an attached volume.

For twelve-factor apps this is a non-issue. For everything else it is a redesign tax. The app that stores user uploads on disk, the SQLite-backed prototype that was supposed to graduate to Postgres "later," the worker that stages large files locally: each needs volumes (billed at $0.15/GB/month, capped around 5 GB on Hobby) or a migration to object storage before Railway is a safe home. Teams discover this the first time a deploy wipes state they assumed was durable, and the fix is architectural, not configurational.

Note the asymmetry with the alternatives: Fly.io volumes are a first-class primitive the platform is built around, and Render at least pairs its ephemeral services with genuinely managed datastores. Railway's storage story is "stateless by default, volumes if you insist" — fine once you know, expensive the first time you learn it in production.

4. Postgres is a container, not a managed service​

On Railway, Postgres is not a separate SKU. It is an ordinary service — a containerized database drawing CPU, RAM, and volume usage from the same pool as your app. That keeps the mental model simple and the small-project bill low. It also means there is no managed Postgres in the Render sense: no point-in-time recovery, no read replicas, no automated failover. Railway shipped an experimental high-availability Postgres add-on in March 2026, but "experimental" is doing load-bearing work in that sentence.

The honest comparison is Render, whose managed Postgres includes PITR and replicas on its flexible plans (compute from about $6/month on Basic, storage at $0.30/GB/month), or the increasingly common split topology: Railway for compute with the database on Neon or Supabase. Either way, the edge case has a trigger you can name in advance — the day you need a restore point, a replica, or a failover story — and past that day the database line item either moves off Railway or becomes ops work you own. Budget for one of the two before the incident, not during it.

5. Teams pay per seat​

Solo developers on Hobby never see this edge. The second teammate does. Team roles and RBAC require Pro at $20 per seat per month, audit logs and SSO sit at Enterprise, and every seat adds its $20 base whether or not that teammate deploys anything.

Render restructured the other way in April 2026: a flat $25/month Pro workspace with unlimited seats, replacing the old $19-per-member plan. For a five-person team that is the difference between $25 and $100 a month for the same dashboard access — before either platform meters a single vCPU-second. Fly.io sidesteps seats with organizations, at the cost of making you build previews and workflows yourself.

This is the team-workflow gap in its concrete form: not that Railway lacks collaboration features, but that its collaboration pricing scales per human while its compute pricing scales per usage, so a growing team gets squeezed from both directions at once. The bill that was $12 for one developer becomes $12 of usage plus $60 of seats for four — and the seats are the part that never goes down when traffic does.

The threshold: when the fixed box wins​

Here is the growth stack that triggers the conversation — two web services, a worker, Postgres, Redis, and branch previews — priced at Railway's published rates:

That lands squarely in the $80–120/month "growth" band that independent 2026 comparisons put Railway in for this shape of stack — and it is all usage, so it grows with every service, preview, and seat you add. The same containers fit comfortably on a 4 vCPU / 8 GB cloud box at roughly €18–21/month post-2026-repricing, with 20 TB of included transfer making the egress line item disappear.

The honest version of this math prices the ops time, because the box does not patch itself:

Two things fall out of that table. First, the exit threshold is not a single number — it is a function of what your time costs, which is why solo developers on nights-and-weekends time leave at $30 while funded teams stay past $200. Second, the threshold moves with egress: push 500 GB/month of media or API responses and Railway's $0.05/GB adds $25 while the fixed box absorbs it into included transfer, pulling every row's breakeven down.

And the when-not-to-leave cases deserve equal weight. Stay on Railway if the bill is under ~$50 and flat, if the workload is spiky enough that 24/7 box rental wastes more than usage billing saves, if the team has no one who wants pager duty for a database, or if preview environments are load-bearing to how the team ships. Independent commentary converges near $150/month total spend as the point where a self-hosted PaaS on a dedicated box starts winning for teams that can operate it — treat that as the center of the range, not a law.

Graduating without going full DIY​

Leaving Railway does not have to mean hand-rolling systemd units. The middle path that 2026's ecosystem actually supports is a self-hosted PaaS — Coolify, Dokku, or a Cluster-API-managed fleet — on hardware with a flat monthly price: git-push deploys and preview environments like the platform you left, with the meter replaced by a box you own. The edge cases above become a migration checklist: size volumes for the stateful parts, pick the managed-database story before the first restore, and keep one preview environment per PR because they are free when the hardware is fixed.

Full line-by-line ledgers for the same workloads on Render, Fly.io, and Hetzner already live on this blog — the September pricing census and the shake-up ledger price every line item this post summarizes. Use them to check my arithmetic against your own stack.

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.

Sources​

• Railway vs Render vs Fly.io: Benchmarks & Pricing (2026) — per-second rates, plan prices, region counts, scale-to-zero behavior, team pricing, and the $80–120 growth-band estimate (re-checked July 19, 2026)
• Railway Pricing 2026: Free Tier Limits, Usage Costs & When to Upgrade — Hobby/Pro mechanics, the $5 one-time trial, preview-environment budgeting, and the ~$150/month self-host threshold
• Railway services docs — ephemeral storage caps (1 GB trial, 100 GB paid) and force-stop on exceed
• Railway's usage-based vs fixed pricing analysis — $0.05/GB egress and worked cross-platform totals
• Render vs Railway vs Fly.io: Pricing Compared (2026) — Fly.io per-machine rates and regional egress tiers
• Hetzner price adjustment notice — 2026 repricing context for the fixed-box side of the threshold