Dora NodaMost platform pricing starts with a floor: Render's Starter web service is $7/month, Railway's minimum is $5, Heroku's cheapest usable dyno tier is $7, and Vercel Pro is $20. You pay that whether your app serves a million requests or zero. But a handful of platforms bill pure usage with no monthly minimum at all — and an August 2026 pricing survey flagged four of them: Fly.io, Cloudflare Workers, Neon, and Northflank.
So I modeled all four against the same reference workload at three utilization levels, with a flat Hetzner Cloud server as the baseline. Here is the full result table first — the rest of this post shows the math, the billing mechanics behind each number, and the exact utilization where the flat box takes the lead.
The short version: the full cost table in 60 seconds
Reference workload: one small API container (1 shared vCPU, 1 GB RAM) plus Postgres (Neon minimum 0.25 CU, 1 GB storage), with traffic scaling alongside running hours. Utilization means fraction of the 730-hour month the stack is running: 10% ≈ 73 hours and ~1M requests, 50% ≈ 365 hours and ~5M requests, 100% = always-on with ~10M requests.
| Monthly cost | 10% (side project) | 50% (business hours) | 100% (always-on) |
|---|---|---|---|
| Fly.io (app container) | $0.72 | $2.85 | $5.70 |
| Cloudflare Workers (requests) | $0.00 | $5.00 | $5.40 |
| Northflank (1 vCPU + 1 GB) | $1.83 | $9.13 | $18.25 |
| Neon (Postgres row) | $2.28 | $10.02 | $19.70 |
| Usage-only full stack (Fly + Neon) | $3.00 | $12.87 | $25.40 |
| Hetzner CX22 (2 vCPU, 4 GB, all-in) | $4.85 | $4.85 | $4.85 |
Read it left to right and the story is simple: at 10% utilization the usage-only stack wins ($3.00 vs $4.85). At 50% the flat box wins by 2.6×. At 100% it wins by more than 5× — and that flat $4.85 also includes 20 TB of transfer and room for several more services. The crossover sits around 17–25% utilization, roughly 4–6 running hours a day. Everything below now earns those numbers.
How each of the four actually bills you
Fly.io: per-second presets with scale-to-zero. Fly Machines bill by the second while in the started state, priced by CPU/RAM preset: a shared-cpu-1x with 256 MB runs about $1.94/month if left on continuously, 512 MB about $3.19, and 1 GB about $5.70. With auto_stop_machines enabled and min_machines_running = 0, an idle app stops and the compute meter drops to zero — but stopped is not free: the machine's root filesystem still bills at $0.15/GB per month, pennies per stopped app. There is no monthly minimum on pay-as-you-go.
Cloudflare Workers: a free tier, then a $5 floor. Workers is the odd one in this list and honesty requires saying so up front. The free tier (100K requests/day) genuinely has no floor — low-traffic workloads cost exactly $0. But once you exceed it, the Paid plan is $5/month including 10M requests and 30M CPU-ms, with overages at $0.30 per additional million requests and $0.02 per additional million CPU-ms. So Workers is "no monthly floor" below ~3M requests a month and "$5 floor" above it. Keep that in mind when the table shows $0.00 at 10% and $5.00 at 50%.
Northflank: per-second vCPU/GB-hour, no minimum. Northflank's pay-as-you-go tier has no monthly minimum and no per-seat fee: $0.01667 per vCPU-hour and $0.00833 per GB-hour, billed per second, plus $0.15/GB-month for SSD volumes and $0.06/GB egress. A 1 vCPU + 1 GB service left running all month costs about $18.25 (730 × $0.01667 + 730 × $0.00833). The smallest plan (0.1 vCPU + 256 MB) runs about $2.70/month always-on. Pricing is tied to the plan size you pick, so you size for peak and pay per second while running.
Neon: serverless Postgres by the CU-hour, no minimum since December 2025. Neon separated compute from storage: Launch-plan compute is $0.106 per CU-hour (1 CU ≈ 1 vCPU + 4 GB RAM, minimum 0.25 CU), storage is $0.35/GB-month, and idle compute suspends to zero after the idle timeout. There has been no monthly minimum since December 2025 — spend $3 and you pay $3. The free tier covers 100 CU-hours a month. Neon is database-only, so treat its row as the database line of the bill, not an app host.
The baseline: Hetzner CX22 at ~$4.85/month. Two shared vCPUs, 4 GB RAM, 40 GB NVMe, 20 TB of included transfer, for €4.49/month (about $4.85 at recent rates, before VAT). The ARM CAX11 with the same RAM is even cheaper at ~€3.79. Northflank's own blog covered Hetzner's 2026 price increases in detail — the flat-box baseline moved a little, but it is still flat: the price does not care whether your app runs 73 hours or 730.
The workload model, stated plainly
A cost model you cannot audit is marketing. Here are the exact assumptions so you can redo the arithmetic:
| Assumption | 10% | 50% | 100% |
|---|---|---|---|
| Running hours/month | 73 | 365 | 730 |
| Requests/month | ~1M | ~5M | ~10M |
| Avg CPU per request (Workers) | 5 ms | 5 ms | 5 ms |
| App container | 1 shared vCPU, 1 GB | same | same |
| Postgres | 0.25 CU, 1 GB stored | same | same |
| Egress | 100 GB | 100 GB | 100 GB |
Three simplifications to note. First, traffic and running hours scale together — a reasonable shape for an auto-stopping service, less so for a batch worker; the "where the model understates the bill" section below covers the gaps. Second, Workers CPU-ms per request is the most workload-dependent input here: 5M/25M/50M CPU-ms across the three levels. Third, egress is held at 100 GB in the base model and then stress-tested separately, because metered bandwidth is where usage bills ambush people.
The numbers: 10%, 50%, 100%
At 10% — the side project — usage-only wins across the board. Fly.io costs 10% of its $5.70 always-on rate ($0.57) plus ~$0.15 of stopped rootfs: $0.72. Workers serve 1M requests inside the free tier's ~3M monthly allowance: $0.00. Northflank costs 10% of $18.25: $1.83. Neon burns 0.25 CU × 73 hours = 18.25 CU-hours × $0.106 = $1.93 plus $0.35 storage: $2.28. Stack Fly + Neon for the full app-plus-database total: $3.00, comfortably under Hetzner's flat $4.85. Every usage platform beats the flat box here. This is the zone usage billing was designed for.
At 50% — business-hours production — the flat box takes the lead. Fly.io: $2.85. Workers cross the free tier, so the $5 plan kicks in (5M requests and 25M CPU-ms both fit inside its included 10M/30M allowances): $5.00 — a touch above Hetzner on its own. Northflank: $9.13. Neon: 0.25 × 365 = 91.25 CU-hours × $0.106 = $9.67 plus storage = $10.02. The stacked usage total is $12.87 vs $4.85 flat — the box wins by 2.6×. Note what happened: Neon, cheap at idle, became the most expensive line on the bill the moment the database stayed warm half the month.
At 100% — always-on — it is not close. Fly.io: $5.70. Workers: $5 base + zero request overage (10M included covers it) + 20M extra CPU-ms × $0.02 = $5.40. Northflank: $18.25. Neon: 182.5 CU-hours × $0.106 + $0.35 = $19.70. Stacked usage total: $25.40 vs $4.85 — more than 5×. An always-on database on per-hour serverless compute is the single most expensive way to run Postgres in this comparison.
The crossover: ~17–25% utilization. Solving the stacked usage cost (hourly share × $25.05 plus ~$0.50 of storage/rootfs floors) against the $4.85 flat line gives ~17% with a Fly app layer, or ~23% with a Workers app layer inside its free tier. In plain terms: if your stack runs more than about 4–6 hours a day on average, the flat box is already cheaper. Sensitivity runs one direction only — a hungrier database (0.5 CU average instead of 0.25) doubles Neon's line and pulls the crossover down near 10%.
Where the model understates the bill: egress, storage, always-on databases
Three meters can flip individual winners even where the base model looks settled.
Egress. The CX22 includes 20 TB of transfer. The metered platforms charge roughly $0.05–0.06/GB past small allowances. At the model's 100 GB, that is ~$5–6 — already larger than Fly's entire 10% compute line, and enough to erase Workers' $0. Push a media-heavy workload to 500 GB and egress alone costs ~$25–30 on metered billing while Hetzner shrugs. If your app serves bytes more than it computes, model egress first and compute second.
Storage floors. "Scales to zero" never means "bills zero": stopped Fly machines keep rootfs charges, Neon storage bills per GB-month regardless of compute state, Northflank volumes bill at $0.15/GB-month. These are pennies-to-dollars per service, but they are the reason a portfolio of ten stopped side projects still generates a bill.
The $5 Workers step. Workers' cost curve is not smooth — it jumps from $0 to $5 the request you exceed the free tier. For workloads hovering near 3M requests a month, that step is the entire decision: just under it, Workers is the cheapest compute in this post; just over it, a flat box running an always-on service is cheaper. Model which side of the step you are on before comparing anything else.
Apples-to-oranges, disclosed
One table invites unfair comparisons, so here are the three disclosures that matter.
First, Workers is not a container. A 128 MB isolate with CPU-time limits cannot run your Postgres, your background worker, or anything stateful — it is the cheapest line in this post precisely because it does the least. Comparing Workers to Fly.io or Northflank is comparing an edge-function surcharge to a full Linux VM.
Second, Neon is the database row, not a hosting alternative. It earns its place in the table because every app needs somewhere to put data, and its pricing shows how usage billing treats the warm-state part of your stack. And to be explicit about our own position: bex does not offer managed databases and has no plans to — this is a comparison point, not a feature claim.
Third, Northflank's premium buys managed UX — build pipelines, preview environments, and a console your whole team can use without SSH. At $18.25/month always-on for 1 vCPU/1 GB it is the priciest app compute here, but the comparison is against a bare Hetzner VM you operate yourself. Whether that delta is worth it depends on who is on call, not on the invoice.
The decision rule
If your workload is spiky or mostly idle — nights-and-weekends side projects, staging environments, per-PR preview stacks — usage-only billing is genuinely cheaper, often by 2–5×, and the four platforms above let you start without committing to any monthly floor (with Workers' $5 step past the free tier as the one asterisk). The moment anything in your stack is always-on — a production API, a database that never suspends, a worker that never drains — a flat ~$5 box wins on price, includes 20 TB of transfer the metered platforms charge per gigabyte for, and runs your next three services for free.
That crossover at roughly a quarter of the month is the number to remember. Below it, rent by the second. Above it, own the box.
Running above the crossover? Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with Render-compatible APIs your agents can drive. Star the repo on GitHub or deploy your first app today.
