Dora NodaZeabur's free tier does what every free tier with a sleep timer does: your service goes idle, the container stops, and the next visitor eats a cold start while it wakes back up. It's the same trade Render's free web services and Railway's trial plans make — free compute in exchange for accepting that idle means offline. Zeabur's fix is its $5/month Dev plan, marketed in 2026 as a "Top Pick — Simple Deploy" specifically because it removes the auto-sleep. Pay $5, your app stays warm.
That framing makes it sound like a flat fee buys you out of the sleep problem entirely. It doesn't. The $5 isn't a sleep-avoidance toggle — it's a credit against metered compute, and once you actually price out what "staying warm" costs by the gigabyte-minute, the math stops looking like a flat fee and starts looking like a bill that scales with how much memory you keep reserved. Here's exactly what that $5 buys, and what it costs once your app needs more than a sliver of RAM.
What the $5 credit actually buys
Zeabur's Dev plan works like this: you pay $5/month for the seat, and that same $5 arrives back as usage credit — so as long as your metered compute stays under $5 for the month, the plan fee is the bill. Go over, and the overage gets added on top of the $5 you already paid; there's no double charge, but there's no ceiling either.
The metered rates that matter:
- CPU: $0/vCPU-minute. Zeabur cut this to zero — CPU usage doesn't factor into the bill at all.
- Memory: $0.00025/GB-minute. This is the rate that actually drives the bill, since "no sleep" specifically means your container's memory stays reserved continuously instead of getting freed when idle.
Run that rate out to a full month (730 hours × 60 minutes): $0.00025 × 60 × 730 = $10.95 per GB of RAM, held continuously, per month.
Divide the $5 credit by that rate and you get the actual answer to "what does $5 buy": $5 ÷ $10.95/GB ≈ 0.457 GB. Round down for safety margin against bandwidth and storage charges, and the honest number is about 400–450MB of always-on memory before you're paying anything beyond the $5 seat fee. That's the entire "no sleep" allowance — a service holding less RAM than a typical node:20-alpine container's idle footprint.
The bill past 450MB: a workload-size table
A single data point undersells how fast this scales, so here's the same math run across the range a real service actually occupies — from a bare Express health-check to a service scoped to the same 4GB a Hetzner CX22 ships with. Bandwidth ($0.10/GB) and storage ($0.20/GB) are held at a light 5GB/month each to isolate what memory alone does to the bill:
| Continuous RAM | Memory cost/mo | + light usage | Zeabur total bill | Hetzner CX22 (flat) |
|---|---|---|---|---|
| 256 MB | $2.74 | $4.24 | $5.00 (under credit) | €4.35 (~$4.70) |
| 512 MB | $5.47 | $6.97 | $6.97 | €4.35 (~$4.70) |
| 1 GB | $10.95 | $12.45 | $12.45 | €4.35 (~$4.70) |
| 2 GB | $21.90 | $23.40 | $23.40 | €4.35 (~$4.70) |
| 4 GB | $43.80 | $45.30 | $45.30 | €4.35 (~$4.70) |
The CX22 column doesn't move because it isn't metered — €4.35/month (roughly $4.70) buys 2 shared vCPUs, 4GB RAM, 40GB NVMe, and 20TB of traffic as a flat-rate box, whether it sits idle or pegs every core. At the 4GB row — the exact RAM Hetzner includes in that same €4.35 — Zeabur's metered bill lands at roughly 9.6x the price of owning the entire machine outright.
A concrete example rather than a synthetic one: a small side-project API running 512MB continuously, serving 5GB of egress and holding 5GB of persistent storage a month — a genuinely typical footprint, not a stress case — nets $5.47 (memory) + $0.50 (bandwidth) + $1.00 (storage) = $6.97 in usage, all but $1.97 of it absorbed by the $5 credit, for a total bill of $6.97/month. That's already $2.27 above the Hetzner box, and the Hetzner box has 8x the RAM headroom left over for a second service.
The RAM figures aren't arbitrary either — they map onto real app shapes. A static-file server or a lean Go/Rust binary idles well under 256MB, which is why the low end of the table stays inside the $5 credit. A Node or Python API with a framework and a connection pool routinely sits at 512MB–1GB resident even before traffic shows up. Add a single Postgres or Redis instance kept warm alongside the app — the common shape of "a small SaaS," not an edge case — and you're well into the 1–2GB rows, where the metered bill has already pulled ahead of the flat box by 3–5x.
Why "no sleep" was never a separate fee to begin with
The $5 plan doesn't buy a feature called "no sleep." It buys a metering exemption: normal PaaS-with-a-free-tier economics have to bill idle containers as zero-cost (or kill them) because letting every free-tier service sit resident in RAM forever doesn't scale for the vendor. "No sleep" on a paid tier just means Zeabur will hold your container's memory reserved without freeing it — and reserved memory, on a rented server, is exactly the resource metered billing is built to charge for. The Dev plan isn't selling you an escape from a sleep tax; it's the tax, itemized by the gigabyte-minute instead of bundled into a flat number.
A self-hosted box never had this problem because it was never metering memory as a rental in the first place. The €4.35 you pay for a CX22 buys 4GB of RAM as a physical allocation on hardware you're already paying for regardless of whether a container inside it is idle at 3am or serving traffic at peak. There's no sleep timer to configure and no "no sleep" upgrade to buy, because "always on" was the default state of a machine you own, not a billing tier layered on top of one you're renting by the minute.
That difference compounds the moment you're running more than one service. On Zeabur, each additional always-on service adds its own GB-minute meter — five 512MB services stack to $27.35/month in memory alone, each one separately eating into (or blowing past) the shared $5 credit. On a Cluster API-managed Hetzner fleet running something like Bex.co, those same five 512MB services fit inside a single 4GB CX22 with room left over, and the box's price doesn't move whether it's hosting one service or five — because the meter that would charge extra for the fourth and fifth service was never installed.
Where Zeabur genuinely wins
None of this makes Zeabur a bad product — it makes it a different trade than the sticker price implies, and it's worth being honest about which developer that trade is actually built for.
If you don't want to run a server — full stop, not "don't want to run a server yet" — Zeabur's git-push deploy, managed automated backups, domain purchase flow, and built-in AI agent quotas on the Dev plan are real value that a €4.35 Hetzner box doesn't hand you for free. Owning a CX22 buys cheap, flat-rate RAM; it does not buy managed TLS renewal, managed backups, or a dashboard that keeps you from ever touching systemd. For a solo developer shipping a low-traffic side project who has decided, correctly, that their time is worth more than the spread between $6.97 and $4.70, Zeabur's zero-config simplicity is the better $2.27.
The trade only turns bad once a workload's memory footprint grows past a few hundred megabytes and stays there — the exact point where "no sleep" stops being a $5 convenience and starts being a metered line item that compounds with every service you add.
The actual decision rule
Skip the vendor-loyalty framing and use the number: if a service's continuous memory footprint stays under roughly 450MB and you'd rather not touch infrastructure at all, Zeabur's Dev plan is priced correctly for what it does. Past that — multiple services, a database sitting warm, anything that wants a real chunk of RAM around the clock — the bill stops being $5-and-done and starts scaling linearly with memory held, while a fixed box's price doesn't move no matter how many small services you pack onto it.
A quick way to tell which side of that line you're on before you commit to either platform:
- Under 450MB, one service, zero interest in server maintenance → Zeabur's Dev plan is correctly priced; the $5 credit covers you and the managed extras are pure upside.
- 512MB–2GB, or more than one always-on service → you're already paying more than a flat box costs, and the gap widens with every service you add.
- A database, a cache, and an API all warm at once → you're firmly in owned-hardware territory; the metered bill has no ceiling and the flat box does.
The number that matters isn't "Zeabur" or "Hetzner" as a brand — it's whether your memory footprint sits above or below the point where a per-minute meter starts costing more than the machine it's metering.
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-GB-minute memory meter running underneath it. Star the repo on GitHub or deploy your first app today.
