Dora NodaRun the numbers before you fall in love with the developer experience. A single always-on standard-1 Cloudflare Container — half a vCPU and 4 GiB of memory, the shape of a perfectly ordinary web service — costs roughly $35 to $58 per month on Cloudflare's usage meter. The equivalent always-on VPS from Hetzner, OVH, or Netcup lands in the $7-15 band. That is a 3-8x gap at the small end, and it widens to 5-10x as the instance grows: the 4-vCPU standard-4 works out to $139-192/month metered, against $15-30 for a comparable flat-rate box.
The catch is not hidden fees. Every rate in this post comes straight off Cloudflare's public pricing page, and the math is four lines of multiplication. The catch is structural: Cloudflare Containers are billed like a function but provisioned like a server. The 10ms-increment meter is a brilliant fit for workloads that sleep most of the day — and a quietly expensive one for anything that doesn't. This post does the full recompute, finds the exact duty-cycle crossover where the meter stops being a deal, and explains why the pricing model behaves this way.
How the 10ms Meter Actually Works
Cloudflare Containers (public beta since June 2025) sit on top of the $5/month Workers Paid plan and bill three resources for every 10ms a container is awake:
| Resource | Rate | Included with Workers Paid ($5/mo) |
|---|---|---|
| Memory | $0.0000025 per GiB-second | 25 GiB-hours |
| CPU | $0.000020 per vCPU-second | 375 vCPU-minutes |
| Disk | $0.00000007 per GB-second | 200 GB-hours |
Two details in the fine print drive everything that follows:
- Memory and disk bill on provisioned size, not usage. If your container has 4 GiB attached and it's awake, you pay for 4 GiB — whether the process is serving requests or waiting on a socket.
- Only CPU bills on active usage. An idle-but-awake container accrues little CPU charge, but its memory and disk meters keep running.
Billing starts when a request wakes the container and stops only when it goes to sleep after an inactivity timeout. The instance menu runs from lite (1/16 vCPU, 256 MiB) through basic (1/4 vCPU, 1 GiB) up to standard-4 (4 vCPU, 12 GiB, 20 GB disk). Every container also carries Worker and Durable Object plumbing — requests route through a Worker, and a Durable Object supervises each instance, each with its own (mostly small) line items.
For bursty work — a video transcode, a code sandbox, a cron job, a demo backend that sleeps 23 hours a day — this is close to ideal. Cloudflare's own launch material pitches exactly those use cases. The problem starts when the workload is a service: a web app plus a background worker that must be awake to accept traffic around the clock.
The Worked Recompute: One Always-On Service, Line by Line
Take the most typical thing anyone deploys — a web app with a background worker, sized to a standard-1 container (1/2 vCPU, 4 GiB memory, 8 GB disk), awake 24/7. A 730-hour month is 2,628,000 seconds. Here is the whole bill:
| Line item | Math | Monthly cost |
|---|---|---|
| Workers Paid base | flat | $5.00 |
| Memory | 4 GiB × 2,628,000s = 10.51M GiB-s − 90,000 included, × $0.0000025 | $26.06 |
| Disk | 8 GB × 2,628,000s = 21.02M GB-s − 720,000 included, × $0.00000007 | $1.42 |
| CPU @ 10% avg utilization | 131,400 vCPU-s − 22,500 included, × $0.000020 | $2.18 |
| CPU @ 50% avg utilization | 657,000 vCPU-s − 22,500 included, × $0.000020 | $12.69 |
| CPU @ 100% (pegged half-core) | 1,314,000 vCPU-s − 22,500 included, × $0.000020 | $25.83 |
| Total | base + memory + disk + one CPU row | $34.66 – $58.31 |
Note what dominates: memory. A mostly-idle service at 10% CPU still pays $26/month just for having 4 GiB provisioned while awake — 75% of its total bill. The meter doesn't care that the RAM was holding an idle Rails process.
Scale the same exercise up to standard-4 (4 vCPU, 12 GiB, 20 GB disk) — the shape of a modest production API plus workers:
- Memory: 31.45M billable GiB-s → $78.62
- Disk: 51.84M billable GB-s → $3.63
- CPU at 25-50% average utilization → $52.11 – $104.67
- Plus the $5 base: $139 – $192 per month for one container.
Now the flat-rate column. A 2-3 vCPU / 4 GB shared-vCPU VPS — Hetzner's EU cloud line, OVH, Netcup, and a dozen others — runs $7-15/month with generous or unmetered bandwidth (Hetzner includes 20 TB). A 4-8 vCPU / 16 GB box runs roughly $15-30. The multiples:
| Workload shape | Cloudflare Containers | Always-on VPS | Multiple |
|---|---|---|---|
| Small web+worker (½ vCPU, 4 GiB) | $34.66 – $58.31 | $7 – $15 | ~3-8x |
| Production API (4 vCPU, 12 GiB) | $139 – $192 | $15 – $30 | ~5-10x |
The 5-10x figure circulating in 2026 platform comparisons is not hyperbole — it is what the public rate card produces for any container big enough to run a real service, the moment that service stops sleeping.
The Duty-Cycle Table: Where the Meter Flips Against You
The multiple above is not a constant; it is a function of one variable — how many hours a day the container is awake. Everything else is detail. Here is the same standard-1 service (light CPU) across the duty-cycle range:
| Awake time | Effective duty cycle | Monthly cost | vs. $15 VPS |
|---|---|---|---|
| 1 h/day | 4% | ~$5.90 | Containers win ~2.5x |
| 6 h/day | 25% | ~$11.70 | Containers still cheaper |
| ~9 h/day | 37% | ~$15 | Crossover |
| 12 h/day | 50% | ~$18.60 | VPS wins |
| 24 h/day | 100% | $34.66 – $58.31 | VPS wins 2-8x |
The crossover sits at roughly a 37% duty cycle — about 9 awake-hours a day — against a $15 VPS, and closer to 4.5 hours a day against a $10 one. Below that line, scale-to-zero is genuinely doing what it promises: a demo environment awake one hour a day costs about $6, and no flat-rate box beats that at equivalent convenience. Above the line, every additional awake-hour is pure premium over hardware you could have rented outright.
The trap is that services drift across this line silently. The internal tool becomes load-bearing. The staging app gets a health checker that pings it every four minutes — which, with a five-minute sleep timeout, means it never sleeps again. Nothing alerts you that your workload's shape no longer matches its pricing model; the bill just quietly triples.
Billed Like a Function, Priced Like a Server
Why does the model behave this way? Because serverless economics assume the idle state is free — that's the deal: you pay a premium per active unit in exchange for paying nothing when there's no work. Functions honor that deal, since a function is its active time. Containers break it halfway: a container has server-shaped attributes — provisioned memory, attached disk, a warm process — and Cloudflare bills those attributes whenever the container is awake, at rates set for burst pricing.
Annualize the memory rate and the shape is obvious: $0.0000025/GiB-s is ~$6.57 per GiB-month. Hetzner's cheapest boxes deliver RAM (with CPU and disk attached) at $2-4 per GiB-month, flat. Paying $6.57/GiB is a fine trade for RAM you hold four hours a day. It is a bad trade for RAM you hold every hour of the month — and an always-on service holds it every hour of the month.
Egress tells the same story. Containers include 1 TB to North America and Europe, then $0.025/GB — so a service pushing 3 TB adds $50/month in bandwidth. Hetzner includes 20 TB on a €10-class box; the same 3 TB adds nothing. Even the Durable Object supervising your container participates: one always-on container's DO sits just under the free 400,000 GB-s duration allotment; run two and the overage line appears.
Three honest caveats, so this stays a fair fight:
- Flat-rate providers reprice too. Hetzner raised cloud prices twice in 2026 — a broad hike in April and a second in June that hit some lines far harder, pushing its cheapest US instance past $20. The gap narrows; it does not close, because the structure (flat vs. metered-while-awake) is unchanged.
- A VPS price is not the whole story. You operate the box: patching, TLS, deploys, monitoring. The container premium buys real operational outsourcing — the question is whether it's worth 5-10x of the compute, forever, per service.
- Cloudflare isn't mispricing; it's positioning. The launch material pitches media processing, sandboxing, batch jobs, and on-demand backends — bursty things. The 40-vCPU concurrency cap in beta says the same. Running a 24/7 service on it is using the product against its own grain, which is precisely why the bill looks the way it does.
What to Run Where
The decision rule falls out of the arithmetic:
- Duty cycle under ~35%, spiky, or genuinely scale-to-zero → the meter is your friend. Cloudflare Containers, and per-second-billed platforms like them, are the right buy for sandboxes, previews, transcodes, and cron-shaped work.
- Awake most of the day, every day → you are a server workload, and you want server pricing: a flat number for capacity you own or rent, where the marginal cost of being awake is zero.
The uncomfortable middle — teams running a dozen always-on services on metered platforms because the deploy experience is pleasant — is where the 5-10x multiple compounds into real money: ten small services at the metered rate is $350-580/month for compute that fits comfortably on two $15 boxes with room to spare.
The structural fix is not "go back to hand-managed VPSes"; it's putting the PaaS experience on top of flat-rate capacity. When the platform layer is software you run — not a vendor's meter — git-push deploys, HTTPS, and process supervision cost the same whether your app sleeps or serves traffic all day, and adding the eleventh service to a half-empty box costs exactly nothing.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with no per-10ms meter anywhere in the stack. Star the repo on GitHub or deploy your first app today.
