Dora NodaInstall Coolify on a fresh box and do nothing else — no apps, no databases, no deploys — and it will still burn roughly 6% CPU and reserve 500-700MB of RAM, permanently, just to exist. Install Dokploy on an identical box and the same idle baseline is closer to 0.8% CPU and 350MB of RAM. That gap looks like a rounding error on a single VPS. It isn't one once you're running a fleet: on a 26-box fleet, Coolify's idle tax alone already costs more per month than standing up a full three-node Cluster API control plane that could be steering all 26 boxes — and every box past that.
Where the Tax Comes From
The gap isn't random — it's architecture. Coolify is a Laravel application: a PHP web app, a PostgreSQL database, a Redis instance for queues and caching, a Soketi websocket server for real-time UI updates, and Laravel Horizon running background queue workers, all as separate containers that stay resident whether or not you've deployed a single app. That's five processes with their own scheduling, polling, and housekeeping — and it shows up in the numbers. Coolify's own GitHub issue tracker has multiple open reports of horizon:work and the scheduled artisan schedule:run command spiking CPU by 40%+ on a recurring, once-a-minute cadence, and separate benchmarking has clocked Coolify's built-in metrics collector pushing idle CPU as high as 25% while it's sampling — on a 4-core VPS, that's half a core doing nothing a tenant app asked for.
Dokploy took a different architectural bet. It's a TypeScript/Next.js control plane that installs Docker, Docker Swarm, and Traefik, then runs itself as a single Swarm service rather than a five-container application stack. Fewer resident processes, no PHP queue worker polling every minute, no separate websocket server — and the idle-resource numbers track that directly. Both tools do genuinely comparable jobs: a web dashboard, a Git-push deploy pipeline, reverse-proxy and TLS management, database provisioning. The 7.5x CPU gap and roughly 2x RAM gap between them is the cost of how each one is built, not what it does.
Turning Percent Into Dollars
Here's the arithmetic, made concrete against a real box: a Hetzner CPX22 (2 vCPU / 4GB RAM), priced at roughly $23/month at the post-June-2026 rate. Treat the daemon's overhead as two separate taxes on that box's capacity — a CPU-capacity tax and a RAM-capacity tax — and average the two into one blended "overhead rate" per box, then price that rate against the box's monthly cost:
| CPU tax (of 2 vCPU) | RAM tax (of 4GB) | Blended overhead | $/box/month | |
|---|---|---|---|---|
| Coolify | 6% | 700MB → 17.1% | 11.6% | ~$2.67 |
| Dokploy | 0.8% | 350MB → 8.5% | 4.7% | ~$1.07 |
That RAM share is the part that actually bites: 700MB reserved on a 4GB box isn't an abstract percentage, it's roughly two or three fewer small tenant containers that box can carry before you have to buy another one. Dokploy's 350MB reservation costs you about half that capacity.
Multiply the per-box tax by fleet size and the abstraction becomes a real invoice line:
| Fleet size | Coolify tax/month | Dokploy tax/month |
|---|---|---|
| 5 boxes | ~$13 | ~$5 |
| 20 boxes | ~$53 | ~$21 |
| 50 boxes | ~$134 | ~$54 |
| 100 boxes | ~$267 | ~$107 |
| 200 boxes | ~$534 | ~$214 |
Put a face on that table: a dev agency running one Coolify instance per client site, at 40 clients, is paying roughly $107/month in pure idle daemon tax before a single client's app has served a request — money that buys zero extra capacity, zero extra reliability, nothing but the dashboard existing on each box. The same 40-box fleet on Dokploy pays about $43/month for the identical non-feature. Neither number sounds dramatic in isolation; both are real, recurring line items an agency is currently paying without a line item to point at, because it's smeared across 40 separate hosting invoices instead of arriving as one bill.
Worth flagging the sensitivity here rather than hiding behind one convenient number: a separate benchmark, measured a few hours after install rather than immediately, put Coolify's idle RAM closer to 1.2GB and Dokploy's closer to 0.8GB — a 30% and 20% RAM-capacity tax respectively. Recomputed on that basis, Coolify's blended rate rises to about 18% ($4.14/box/month) and Dokploy's to about 10.4% ($2.39/box/month). The two measurement windows bracket a real range, not a single point — but Coolify sits meaningfully above Dokploy under either one. And both numbers shrink fast on bigger boxes: the same few hundred megabytes of resident RAM is a much smaller slice of an 8-core/16GB machine, so this tax matters most in the small-VPS regime both tools are actually designed for — which is also where most fleets running one instance per box live.
What Cluster API Charges Instead
A Cluster API-managed fleet pays overhead too, but it doesn't scale the same way. A minimally-HA control plane needs three nodes for etcd quorum — that's a fixed floor set by consensus math, not by fleet size. Matched to the same CPX22 spec used above for an apples-to-apples comparison, three control-plane boxes run about $69/month, total, whether that control plane is steering 10 worker machines or 150 of them. (Production deployments typically spec control-plane nodes larger than a 2 vCPU/4GB box — Kubernetes' own kubeadm guidance recommends up to 4 vCPU/16GB per node when etcd is stacked on the same machines — which would raise this fixed cost. It would still be fixed, though: tripling the control-plane spec doesn't touch the linear per-box tax on the other side of this comparison, it just moves the crossover point further out.)
That's the actual difference "amortized" is pointing at: the per-box PaaS daemon tax scales with the number of machines; the Cluster API control-plane tax scales with the number of clusters, which for a single fleet is usually one. Set the fixed $69/month control-plane cost against the linear per-box tax from the table above, and solve for where the lines cross:
- Coolify crossover: roughly 17-26 boxes, depending on which idle-RAM measurement you use (the immediate-install ~$2.67/box rate or the after-a-few-hours ~$4.14/box rate).
- Dokploy crossover: roughly 29-65 boxes, same two measurement windows applied to Dokploy's lower overhead.
Below those thresholds, running independent single-box installs is cheaper in raw overhead than standing up a dedicated control plane — there's no fleet-wide reconciliation to amortize yet. Above them, you're paying more in cumulative per-box daemon tax than a Cluster API control plane would cost to run the whole fleet, and that gap only widens as boxes get added, because one side of the equation is flat and the other isn't. One caveat on the flat side: stacked-etcd, three-node control planes are the standard recommendation only up to roughly 200 worker nodes — past that, the control plane itself needs to grow, so "fixed" holds within a wide but not infinite range.
The Deployment Pattern This Math Assumes
This entire comparison assumes a specific, common pattern: independent, single-box installs — an agency running one Coolify or Dokploy instance per client VPS, or a small team spinning up one instance per project, each fully paying its own daemon tax. That's a real and widespread way both tools get used.
It is not the only way. Coolify also supports a multi-server mode, where one central instance manages many remote workers over SSH; in that topology, the Laravel/Redis/Horizon stack runs once, on the control box, and the worker machines run nothing but Docker and an SSH server — no daemon tax repeated per box at all. Dokploy's Swarm-native design supports a comparable multi-node pattern. Run either tool that way, and the linear-per-box math above simply doesn't apply — you've effectively built your own lightweight, non-Kubernetes control plane, and the comparison that matters shifts to "how does this hand-rolled control plane's reliability and feature set compare to Cluster API's," not "how much CPU does the daemon idle at."
That's exactly the two-step question the original framing here points at, and it's worth keeping the two steps in the right order. First: if you're running one instance per box, which tool is leaner — and the answer is Dokploy, by a wide and now-dollarized margin. Second, and separately: does the fleet even belong on a per-box daemon at all, once it's crossed the 17-to-65-box range where a shared control plane's fixed cost stops being the more expensive option. Those are different questions, and a team that only ever asks the first one can spend years optimizing which single-box tool to install without ever noticing it's paying a linearly-scaling tax that a fixed-cost control plane would have capped a long time ago.
Bex.co is the open-source, AI-native Render alternative built on Cluster API from the start — a git-push deploy workflow backed by the same declarative, fixed-overhead control plane this math argues for, running on machines you own instead of a rented dashboard. Star the repo on GitHub or deploy your first app today.
