Coolify vs Dokploy on a $5 Hetzner Box: 7-Day Benchmark Numbers — and What Breaks When You Outgrow the Box

Four hundred megabytes. That is the entire idle-RAM gap between Coolify v4.0 and Dokploy after seven days running identical apps on a $5 Hetzner VPS — 1.2 GB against 0.8 GB — and on an 8 GB box it is the difference between fitting one more small service and upgrading to the $10 tier.

The head-to-head that produced these numbers, run by The Nguyen at nextgrowth.ai and updated in August 2026, is the most concrete Coolify-vs-Dokploy comparison published since Coolify v4.0's May 2026 launch changed the decision. We have covered the two projects' growth curves and Coolify's MCP server before; this post is about the numbers on one cheap box, and about the question those numbers cannot answer — what happens when your workload outgrows the box either panel sits on.

The 30-second verdict​

Here are the numbers up front; the rest of the post earns them.

Build times are within the margin of error, so this is not a performance contest — it is a footprint-against-features trade. The decision rule the data supports: 1–3 apps → Dokploy, whose lower footprint and simpler mental model ship you faster; 4+ apps, an MCP-aware AI workflow, or local-LLM ambitions → Coolify, whose 280+ service library and v4.0 tooling pay back the extra 400 MB.

The test, and what the numbers mean on an 8 GB box​

The testbed is the important part, because it is also the limitation: a single Hetzner CCX13 ($5 class, 2 vCPU, 8 GB RAM, 80 GB NVMe) running identical apps on each panel for seven days. Both panels installed in under five minutes with a one-line installer. Nothing about this setup resembles a fleet — one box, one Docker daemon each, no remote servers, no Swarm — which is exactly why the results answer "which panel for my first server" and nothing else.

The RAM arithmetic is where the 400 MB delta turns into a planning input. On an 8 GB box running a Postgres instance (~250 MB), a small API service (~180 MB), and an Ollama 7B-parameter model (~4 GB at inference), Coolify's own 1.2 GB footprint leaves roughly 2.4 GB of headroom; Dokploy's 0.8 GB leaves roughly 2.8 GB. That extra 400 MB is not an abstraction — it is one more small service you can fit before the box is full.

If your whole deployment is two apps and a database with no LLM in sight, Dokploy's footprint advantage is the most actionable number in the table. If Ollama is on the roadmap, both panels leave you tight on 8 GB, and the panel choice matters less than planning the memory budget before you deploy the model.

One honest scoping note about the "7 days" in the headline. The published numbers are point-in-time measurements — idle snapshots, install minutes, build seconds — the kind of figures a careful afternoon of testing produces. What the seven-day soak actually proves is stability rather than trends: both panels held their idle footprint steady for a week with no reported restarts or incidents. No day-1-versus-day-7 drift curves were published, so treat idle RAM as a snapshot, not a trend line. Memory creep over months, disk growth from build caches and logs, behavior under sustained load — none of that is in this dataset, and anyone extrapolating a year of production behavior from it is reading past what it says.

What Coolify v4.0 changed​

Before May 18, 2026, this comparison was simpler: Dokploy was the lighter, simpler panel and Coolify was the heavier, broader one, and the argument rarely moved. Coolify v4.0 moved it in three ways that all land in the benchmark.

First, the MCP server. Coolify became the first self-hosted PaaS to ship an MCP server inside the product, letting Claude Code, Cursor, or any MCP client deploy services, connect databases, and read build logs in natural language. The benchmark's sharpest workflow contrast comes from this: deploying Ollama took 30 seconds via Claude Code on Coolify against a manual SSH-and-Compose session on Dokploy. (Our earlier take on the MCP launch was deliberately skeptical about how far "AI-driven deploys" really go — worth re-reading before you treat the MCP server as a finished operator rather than a fast path for standard operations.)

Second, template breadth: 280+ one-click services against Dokploy's 100+, with Ollama as a first-class one-click install including Llama3-8B. The benchmark's "past 3–4 deployed apps, Coolify's investment pays back" line is really about this library — every app past the first few is increasingly likely to already exist as a template you configure rather than a Compose file you write.

Third, project health signals that matter on a multi-year horizon: 55,689 GitHub stars against Dokploy's ~24K at the time of the test, an Apache 2.0 license with no resale restrictions (Dokploy is source-available with resale restrictions on advanced features — irrelevant for solo developers, decisive for agencies building a PaaS offering on top), and practical wins like native Cloudflare Tunnel integration for exposing services without firewall holes. None of these show up in an idle-RAM reading, which is precisely why a benchmark-only comparison underrates Coolify.

The honest counterweight, and the benchmark states it plainly: Coolify v4.0's database backup and restore UX is still partial, with production-grade restores requiring SSH. Dokploy is at least honest about being CLI-first for restores from the start. If automated, UI-driven restores are on your requirements list, neither panel fully delivers today.

Where Dokploy still wins​

Dokploy's case is not about what it lacks — it is about what it gets right for a specific deployment profile, and the benchmark gives it full credit on three dimensions.

The mental model. Fewer screens, fewer toggles, fewer configuration layers between you and a running container. For a first self-hosted deployment this is not a cosmetic preference; it is the difference between seeing exactly what is running and why, versus learning a dashboard's geography before you can diagnose anything. Error visibility cuts the other way — Dokploy makes you SSH for Docker logs where Coolify shows inline build logs — but for one or two apps, the simplicity dividend outweighs the debugging tax.

The footprint. The 0.8 GB idle figure plus ~1% idle CPU is a genuine advantage on a $5 box, and the benchmark's RAM-budget math shows it converting directly into deployable headroom. Dokploy also installs a minute faster (3 vs 4 minutes), which matters exactly once and is still worth noting for the "Friday evening, new VPS" scenario this whole category optimizes for.

The Swarm story. Dokploy has shipped Docker Swarm multi-node support since early on, while Coolify's Swarm integration is newer — v4.0-era — and officially experimental. If clustering is a deciding factor today rather than a roadmap item, Dokploy's is the more mature implementation; Christian Lempa's February 2026 "Dokploy vs Coolify: Docker Swarm changes the game" video walks through that advantage in detail. Note the trap here, though: Swarm maturity answers "which panel clusters better," not "whether Swarm is the clustering you want" — a distinction the next section takes apart.

What a one-box benchmark cannot tell you​

Here is where intellectual honesty requires correcting a tempting oversimplification: it is not true that either panel has "no story" for a second server. Both support managing remote servers over SSH from one dashboard. Coolify's standard multi-server pattern — validated remote servers, a shared Docker registry, per-server Traefik instances, plus a dedicated remote build server to keep compile load off the hosting box — is documented and real. Dokploy's Swarm clustering is real too. The benchmark simply does not test any of it, because it ran on one box.

The actual ceiling is narrower and more specific than "single server." It is the gap between orchestrating containers on servers and operating machines, and both panels sit firmly on the first side of it:

• You provision every machine yourself. Neither panel creates servers, resizes them, replaces failed ones, or reconciles a fleet toward declared state. Adding capacity means renting a VPS by hand, installing Docker, and registering it — every time, on every provider, with no API-driven lifecycle behind the dashboard's server list.
• Nothing auto-scales. App replicas are possible, but there is no autoscaler reacting to load and no scheduler bin-packing workloads across nodes by available resources. The Self-Host Heroes comparison puts it directly: no native auto-scaling or multi-node scheduling à la Kubernetes.
• Moving a service between servers is manual. Dokploy tracks one-click service migration (volumes, Compose config, env vars, Traefik labels) as an open feature request — issue #861 — and Coolify has no equivalent workflow either. A server-to-server move with data is today a re-deploy plus a database dump and restore, typically 30–60 minutes per app.
• Deploys are Compose semantics. Docker Compose does stop-old-start-new; rolling deployments with zero-downtime guarantees, health-gated rollouts, and automatic rollback are not what either panel's deploy path provides.
• Swarm is the ceiling, and it is a low one. Coolify's Swarm support is experimental, requires a minimum of three same-architecture servers, and has no cluster-management UI. Dokploy's is more mature but still Swarm: fine for replicas-behind-Traefik, not a scheduler, not a machine lifecycle, and Kubernetes support on either side remains a "coming soon."
• Backups still end at SSH. Both panels' honest practitioners admit production-grade restores go through the terminal. That is acceptable for one box and a runbook; it does not compose into fleet policy.

None of this disqualifies either panel for what they are: the fastest path from a fresh VPS to HTTPS-terminated apps you own. It only means the benchmark's verdict expires the day your second server arrives. Before committing, ask the questions the one-box test never poses: who provisions machine three, what moves the stateful service off a dying disk at 3 AM, and which half of that answer is currently "me, with SSH."

Verdict: pick the panel, respect the ceiling​

For the first server, the benchmark's rule stands: Dokploy for 1–3 apps where footprint and simplicity dominate, Coolify v4.0 past that line or wherever MCP-driven workflows and Ollama matter. The 400 MB gap is real but bounded — one service of headroom, not a verdict on project quality — and Coolify's breadth, license, and community momentum are the class of advantage that compounds while RAM prices fall.

But treat either choice as the answer to "which panel for my first server," not as infrastructure strategy. The moment the workload needs provisioned machines rather than managed containers — declarative fleet state, health-checked node lifecycle, scheduling with real placement logic — you have outgrown the category both panels define, and the right move is a platform built on machine-level primitives like Cluster API rather than a bigger VPS under the same dashboard.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.