Always-On PaaS vs Per-Second Scale-to-Zero: What a 10-Service Stack Actually Costs on Render, Railway, Fly.io, and Scalix

Contents
There are two billing philosophies in app hosting and almost every pricing page is a variation on one of them. The flat-rate school says: reserve a slice of a machine, pay the same every month, and never think about it again. The per-second school says: the meter runs while your code runs, stops when it stops, and idle capacity is not a product. Render is the purest flat-rate platform in the field. Railway, Fly and our own Scalix Run are the per-second school, each with a different answer to what happens at idle. Neither philosophy is wrong. They produce very different bills for the same architecture, and the difference is computable, so we computed it.
The reference stack is ten services, which is what a real product looks like once staging and previews exist: two web APIs at 1 vCPU / 2 GB, always awake; three workers at 0.5 vCPU / 512 MB to 1 GB, two always awake and one busy six hours a day; two cron jobs an hour a day; a staging clone busy eight hours a day; an internal tool busy two hours a day; a small always-on Postgres holding 20 GB; 100 GB of egress; and ten preview environments at half a vCPU, each busy two hours a day. All rates are the vendors’ published numbers checked on 7 November 2026. One of the four platforms is ours, priced with the same arithmetic as the rest.
Render: the flat-rate ladder, priced
Render’s compute menu is the most legible in the industry, which makes it the right place to start. Web services and workers: $7/month for 0.5 CPU and 512 MB, $25 for 1 CPU and 2 GB, $85 for 2 CPU and 4 GB, climbing to $1,500 for 12 CPU and 96 GB. Postgres: $19 for 0.5 CPU and 1 GB, $40 for 1 CPU and 2 GB. Cron jobs bill per minute from $0.00016. Workspace plans: Hobby free with 5 GB of bandwidth, Pro $25 with 25 GB, Scale $499 with a terabyte. Bandwidth past the allowance is $0.15/GB, disks $0.25/GB-month, expandable database storage $0.30/GB. All from render.com/pricing.
The line that decides the philosophy question is on the same page and in their docs: free instance types spin down after fifteen minutes without inbound traffic, and paid types do not spin down at all. A $25 service that answers eleven requests in a month bills $25. The predictability is the product, and it is real: nobody has ever been surprised by a Render invoice that matched the ladder.
| Ten-service stack on Render | |
|---|---|
| 2 web APIs, 1 CPU / 2 GB | $50.00 |
| 3 workers, 0.5 CPU / 512 MB | $21.00 |
| 2 cron jobs, per-minute | $0.58 |
| Staging clone, 1 CPU / 2 GB | $25.00 (runs 8 h/day, bills 24) |
| Internal tool, 0.5 CPU / 512 MB | $7.00 (runs 2 h/day, bills 24) |
| Postgres 1 CPU / 2 GB, 20 GB data (storage beyond the plan’s allowance at $0.30/GB) | $40.00 |
| Egress 100 GB (25 included) | $11.25 |
| Workspace Pro | $25.00 |
| Previews, 10, on free types | $0.00 (spin down) |
| Total | ≈ $180/month |
The two rows with parentheticals are the whole argument: $32 of that bill buys capacity that is awake eight hours and idle sixteen, or two, because the flat ladder has no gear for “mostly off”. Render’s newer Sandboxes product, at $0.12 per active CPU-hour with automatic suspend, is their answer for ephemeral shapes; standard services keep the flat philosophy.
Railway: per-second against plan credits
Railway meters consumption at published rates, $20 per vCPU-month and $10 per GB-month, consumed per minute, drawn against a plan subscription that doubles as usage credit: Hobby $5/month including $5 of usage, Pro $20 including $20. Egress is $0.05/GB, volumes $0.15/GB-month, and the database is a template their docs describe as unmanaged, so the same CPU and RAM rates apply to it and backups are yours to arrange.
| Ten-service stack on Railway Pro | |
|---|---|
| 2 web APIs, 1 vCPU / 2 GB, always on | $80.00 |
| 2 workers always on ($20 each), 1 busy 6 h/day | $44.93 |
| 2 cron jobs, 1 h/day | $1.23 |
| Staging clone, 8 h/day (sleeps when idle) | $13.15 |
| Internal tool, 2 h/day | $1.23 |
| Postgres template 1 vCPU / 2 GB + 20 GB volume | $43.00 |
| Egress 100 GB | $5.00 |
| Previews, 10, 2 h/day each | $12.33 |
| Pro subscription (first $20 of usage included) | $20.00 |
| Total | ≈ $201/month |
The asterisk on Railway is sleep mechanics. Their Serverless feature parks a service after ten minutes without outbound packets, inbound traffic explicitly does not keep it awake, and the docs warn the first request after sleep “may return a 502”. A staging clone with an open connection pool to the database may therefore never sleep at all, which moves its row from $13.15 to $40. Read your own service’s idle behaviour before trusting the parked column.
Fly.io: machines that stop
Fly sells named presets billed per second while a Machine runs, from $2.19/month for a shared-cpu-1x with 256 MB up through performance tiers, with stopped Machines billing only root filesystem storage at $0.15/GB-month. Auto-stop and auto-start are documented features, so the parked state is cheap rather than free, and Managed Postgres is a first-party product from $38/month plus $0.28/GB-month of storage. Egress to the internet is $0.02/GB in North America and Europe, the lowest published per-GB egress rate in this survey.
| Ten-service stack on Fly | |
|---|---|
| 2 web APIs, performance-1x 2 GB, always on | $66.00 |
| 2 workers always on, shared-cpu-1x 512 MB | $7.38 |
| 1 worker 6 h/day, auto-stopped | $1.22 (incl. parked rootfs) |
| 2 cron jobs, 1 h/day | $0.18 |
| Staging clone, shared-cpu-2x 8 h/day | $4.76 |
| Internal tool, shared-cpu-1x 256 MB, 2 h/day | $0.18 |
| Managed Postgres Basic + 20 GB | $43.60 |
| Egress 100 GB | $2.00 |
| Previews, 10, 2 h/day each | $1.83 + parked rootfs |
| Total | ≈ $128/month |
Fly is the cheapest column here, and the honest footnote is that shared-cpu presets are burstable, and a production API on performance presets is where the $66 row comes from. Fly is also the most assembly-shaped platform of the four: the machine lifecycle is an API you drive, which is the control that justifies the model and the work that comes with it.
Scalix Run: per-second with a zero floor
Our rates are one flat pair with no preset ladder: $0.036 per vCPU-hour and $0.004 per GiB-hour, billed per second while a service is awake, with a minimum instance count you can set to zero. Parked services meter nothing; stored data keeps metering at its own rates. The database is Scalix Nova at $0.0954 per CU-hour with compute suspending when idle, storage at $0.315/GB-month, and the full rate card is the published price book the console meters against. Run services have no separate egress line in that manifest.
| Ten-service stack on Scalix | |
|---|---|
| 2 web APIs, 1 vCPU / 2 GB, always on | $64.24 |
| 2 workers always on, 1 busy 6 h/day | $36.08 |
| 2 cron jobs, 1 h/day | $1.20 |
| Staging clone, 1 vCPU / 2 GB, 8 h/day, parks idle | $10.56 |
| Internal tool, 2 h/day, parks idle | $1.20 |
| Nova Postgres, 190 CU-hours + 20 GB | $24.43 |
| Egress 100 GB | $0.00 (no metered Run egress line) |
| Previews, 10, 2 h/day each, parked between | $12.00 |
| Total | ≈ $150/month |
The wake side of parking, because a zero floor is worth nothing if the first request suffers: our production benchmarks put a parked Run service at roughly 200 ms median to serve TCP and about 600 ms through the TLS edge, with a suspended Nova database waking on the first query. The full method and numbers are in what is scale-to-zero, and the counter-case, a real customer bill where an always-on VM ate 84% of the total, is in what an always-on VM actually costs.
The duty-cycle curve, which decides everything
Collapse the four philosophies to one service, 1 vCPU / 2 GB, and vary how awake it needs to be:
| Awake share of the month | Render (flat) | Railway | Fly (perf preset) | Scalix |
|---|---|---|---|---|
| 100% | $25 | $40 | $33 | $32.12 |
| 50% | $25 | $20 | $16.50 + rootfs | $16.06 |
| 25% | $25 | $10 | $8.25 + rootfs | $8.03 |
| 4% (1 h/day) | $25 | $1.64 | $1.38 + rootfs | $1.32 |
| 0% (parked) | $25 | sleeps or $40 | rootfs only | $0 |
Two readings, both true. At full duty the cheapest flat rate beats every per-second meter here, and a team whose services genuinely run hot pays a premium on the meters, which is exactly what Render is selling and why they sell it well. The curves cross between roughly 60% and 80% duty depending on the pairing ($25 flat against $32.12 always-awake crosses at 78%, against Railway’s $40 at 63%), and below that the per-second side widens its lead with every idle hour. Most real stacks, with their staging clones, internal tools, cron corners and preview farms, live well below the crossover. The preview row is the extreme case: ten environments that exist to be looked at occasionally are ten flat-rate instances on one philosophy and twelve dollars a month on the other.
AWS sits outside the table as the always-on reference point: a Fargate task bills from pull to termination with no auto-park, so it behaves like the 100% column plus the network furniture priced in the AWS teardown.
What sleep actually costs you
Scale-to-zero is not free money, and the platforms that pretend otherwise are selling something. The bill moves; the latency budget takes the hit. Railway’s first post-sleep request may 502. Render’s free type takes about a minute to wake, which is why nobody runs production on it. Fly Machines restart the process, so in-memory state is gone by design. Ours wakes in a couple hundred milliseconds at TCP, which is imperceptible for a dashboard and disqualifying for a sub-ten-millisecond p99 path. Persistent connections break under every sleep model, because a socket is a service that never looks idle. So the decision rule we use for our own services: steady 24/7 traffic, held sockets, or a p99 budget that cannot absorb a wake stay always-on and pay the flat column gladly; everything else parks, and the meter follows reality instead of the calendar.
Where each platform is the right answer
Render, if the bill must match the ladder exactly, your services genuinely run hot, and you want the deepest managed data services without assembling anything. The flat rate is a feature at high duty cycles, and their support and compliance surface is published where ours is not.
Railway, if you want per-second pricing with a project graph, a database you fully control, and you have read the sleep rules against your own services’ idle behaviour rather than assuming.
Fly, if you want machine-level control through an API, the cheapest published egress rate in this survey, and first-party Postgres in twelve regions, and you will trade some assembly time for it.
Scalix Run, if your stack looks like the reference stack, mostly-busy services around a small always-on core, and you want the database, storage, auth and inference beside the containers on one key and one ledger in the EU. Not if you need more than one region this quarter, more than 4 vCPU per service, or an SLA on paper; those gaps are real and the other three have answers we do not.
Model your own duty cycle against the curve above; it takes an afternoon and it beats every comparison table including this one. If you want to run the experiment against the zero floor, Scalix Run deploys from a source directory or an image and parks at zero when nothing calls. Tell us what your bill did on Discord.
FAQ
What is the Render pricing breakdown?
Three layers. A workspace plan: Hobby free, Pro $25/month, Scale $499/month. Compute per service: web services and workers from $7/month (0.5 CPU, 512 MB) through $25 (1 CPU, 2 GB) and $85 (2 CPU, 4 GB) upward, billed prorated to the second while the service exists; Postgres from $19/month (0.5 CPU, 1 GB); cron jobs per minute from $0.00016. And metered extras: bandwidth past the included allowance at $0.15/GB, disks at $0.25/GB-month, expandable database storage at $0.30/GB. Checked on render.com/pricing, 7 November 2026.
Does Render scale to zero on paid plans?
Standard paid services do not. Only the free instance type spins down, after 15 minutes without inbound traffic, waking in about a minute; paid web services and workers run continuously and bill their full monthly rate at zero traffic. Render's newer Sandboxes product does suspend and resume automatically at $0.12 per active CPU-hour, so the platform now sells both shapes, as different products.
What does per-second billing mean for container hosting?
The meter runs while the container runs and stops when it stops, at an hourly rate divided to the second. Railway publishes $20/vCPU-month and $10/GB-month consumed per minute; Fly bills named presets per second while a Machine runs and $0.15/GB-month of root filesystem while stopped; Scalix Run bills $0.036/vCPU-hour plus $0.004/GiB-hour with a minimum instance count that can be zero. Render's flat plans are prorated to the second too, but the service itself never stops, so the proration rarely helps.
How much do preview environments cost?
On flat-rate platforms, a preview that uses a paid instance type costs its full monthly rate, so teams either route previews to free types (Render's default, which spin down) or accept N environments times the instance price. On per-second platforms with parking, ten preview environments at half a vCPU busy two hours a day cost about $12/month on Scalix rates and near-zero on Fly's stopped-Machine model. The environment count stops being a budget line and becomes a hygiene question.
When is always-on the right choice anyway?
Three cases: traffic is steady around the clock, so the duty cycle is near 100% and flat rates beat meters; the service holds persistent connections like WebSockets or streaming consumers, which sleeping breaks by definition; or your p99 latency budget cannot absorb a wake, even a 200 ms one. Everything else is a service paying rent on hours nobody is using.