Dora NodaThe most useful Dokploy-vs-Coolify pricing artifact of 2026 was published by a competitor. On September 10, Northflank shipped a Dokploy vs Coolify guide with a line most comparisons skip: "Prices below were checked on 10 September 2026." No stale plan names, no "starting at" hand-waving — live numbers for both panels' managed tiers, checked the same day.
Read it with the vendor-authored label attached (Northflank sells the managed-Kubernetes answer at the end), and it still surfaces the decision that matters: per-server licensing math once the fleet is three boxes, not one. Here is that math, worked out to totals at every fleet size, under one stated rule — cheapest documented managed plan at each connected-server count:
| Connected servers | Dokploy Cloud (panel fee) | Coolify Cloud (panel fee) | Cheaper panel |
|---|---|---|---|
| 1 | $4.50 (Hobby) | $5.00 (base covers two) | Dokploy by $0.50 |
| 2 | $9.00 (2 × Hobby rate) | $5.00 (base) | Coolify by $4.00 |
| 3 | $15.00 (Startup, 3 incl.) | $8.00 ($5 + $3) | Coolify by $7.00 |
| 5 | $24.00 ($15 + 2 × $4.50) | $14.00 ($5 + 3 × $3) | Coolify by $10.00 |
Dokploy Cloud wins at exactly one server — by fifty cents. Coolify Cloud wins at every size above that, and the gap widens with each box because the marginal server costs $4.50 on Dokploy and $3.00 on Coolify. Self-hosted, both tie at $0, which is exactly why the managed-math crossover is the interesting bit: the moment you stop babysitting the panel, server two flips the answer.
And here is the thesis the table can't show: both panels stop at machine two. Neither provisions the box, reconciles machine lifecycle, autoscales, replicates your database, or backs up its own single brain. The price-verified lens prices the panel honestly — then the comparison structurally cannot answer the fleet question, because neither product is a fleet manager.
What the price-verified lens gets right
Vendor docs are accurate and still misleading, because each vendor frames its own bundle. A same-day third-party check surfaces three things the pricing pages bury.
First, the marginal server cost. Dokploy's headline is $4.50 per server per month (Hobby, annual) or $15 per month for Startup with three servers included; additional servers cost $4.50 each. Coolify's is $5 per team for two connected servers, then $3 per additional server. The marginal numbers — $4.50 versus $3.00 — are the actual slope of your bill, and every server past the bundle widens Coolify's lead by another $1.50 a month. Headline-to-headline ($4.50 vs $5.00) flatters Dokploy; slope-to-slope tells the growth story.
Second, what the headline assumes. Northflank quotes Dokploy's annual rates and Coolify's monthly base in the same breath, and both vendors offer ~20% off on annual billing — so treat every cell above as "billed annually, give or take a billing-cycle wobble." The honest footnote on the Dokploy column: a solo dev inside Hobby's documented limits (one user, two environments) could argue for the bare $4.50-per-server rate at any size — $13.50 at three boxes, $22.50 at five. It still loses to Coolify's $8 and $14 at those sizes, which is why the table uses Startup at 3+: teams land there, and the edge case doesn't flip the result either way.
Third — the big one — both clouds manage only the control plane. Your workload servers are extra on every row: you still rent the VPS boxes, patch the host OS, and own storage, networking, backups, and recovery. The panel fee buys "never SSH into the dashboard host," not "never SSH again." Work the full total at three Hetzner-class boxes (~$6/month each, one app plus Postgres and Redis):
| 3-box total | Panel fee | 3 × VPS (~$18) | Monthly total |
|---|---|---|---|
| Dokploy Cloud (Startup) | $15.00 | ~$18 | ~$33 |
| Coolify Cloud | $8.00 | ~$18 | ~$26 |
| Either, self-hosted | $0 | ~$18 | ~$18 |
The $7-a-month delta ($84 a year) is real but second-order next to the structural fact: at three boxes, the panel fee is 45% of the Dokploy total and 31% of the Coolify total. Past this size, "which panel" matters less than "who provisions and heals the machines" — a line item neither panel has, because neither panel does it.
Dokploy's side of the ledger
Dokploy's multi-server story is the more genuinely clustered of the two: one server, independent remotes over SSH, or a Docker Swarm cluster where services replicate across managers and workers and Traefik routes to healthy replicas. For stateless services, joining a Swarm worker is the smoothest second-machine operation either panel offers — one join, and scaling to two replicas genuinely spans two boxes.
Price that against three caveats the comparison gets right to keep visible. Dokploy is still pre-1.0 (v0.29.x at mid-2026), so panel behavior can shift under you. In January 2026 the project split its licensing: the core stays Apache-2.0, but future paid features ship under a separate source-available license — fine for most teams, but read it if license purity is a hard requirement. And the Swarm ops gaps are documented, not theoretical: no monitoring for remote servers, registry credentials applied to a single selected server rather than fanned out to every Swarm worker (so unselected workers fail image pulls), and a UI that pins the install host as the Swarm manager. Swarm-native is real leverage with real sharp edges.
Coolify's side of the ledger
Coolify's model is more literal: attach servers over SSH to one dashboard, then pick a target server per app or database. There is no cluster scheduler placing workloads — you do, per workload — plus a dedicated remote build server option so compiles stop stealing CPU from production. Swarm-as-destination exists but is experimental, and multi-server deploys mean the same image on matching standalone servers with an external load balancer you configure yourself. As one operator guide puts it: multiserver, not true clustering.
The packaging contrast is where Coolify wins on principle: self-hosted Coolify has zero paywalled features, and the Cloud base fee covers two servers rather than one — which is exactly why the crossover table flips at server two. The ceiling is the mirror of Dokploy's: the dashboard host is a single control-plane point of failure (lose it and deploys, TLS renewals, and scheduled backups stop until it's restored), and "experimental Swarm" is not a topology to plan against.
The question neither answers at machine two
This is the structural gap no panel-vs-panel table can fill, because both contestants stop at the same line. After adding server two under either panel, five things are still manual:
- Provision the box. Both panels attach servers you bring — an IP, a port, an SSH key. Renting, imaging, and hardening the machine is a provider console, an API call, or Terraform you own.
- Declare and reconcile machine lifecycle. Neither panel holds a desired state for your machines and converges toward it. Configuration drift between box one and box three is detected by you, on a bad day.
- Autoscale. Every node joins manually: register, join, or point-and-click per server. Nothing watches load and raises machines; nothing drains and retires them when the spike passes.
- Replicate the database. Both deploy Postgres, MySQL, or Redis as a container with a local volume pinned to one node. Swarm replicates stateless services; it does not replicate volumes. Your app spans two boxes and your data lives on one disk.
- Back up the single brain. Coolify's dashboard host, Dokploy's Swarm manager — each panel has exactly one of them, and the backup-and-restore runbook for the control plane itself is yours to write and yours to have tested.
None of this disqualifies the panels. It scopes them: they are excellent answers to "run my app with TLS and deploys on servers I own," and machine two extends that answer to stateless capacity — not to data, not to fleet automation. (This site's September 19 second-machine walkthrough works each panel's mechanism and cost in full; the checklist above is the part no mechanism section can retire.)
Northflank's guide, to its credit, ends where its incentives point: managed Kubernetes, per-second billing, BYOC into your cloud account. That pitch deserves its vendor-authored discount — and a sharper observation. Northflank prices the infrastructure layer the panels leave to you. The panels price the deployment layer. Somebody still owns the machines in between, and "the team, manually, forever" is a cost neither quote includes.
Picking your path
The price-verified math compresses to a two-branch rule:
- One box, wants real clustering: Dokploy. Swarm-native replication is the least-friction path to services genuinely spanning machines, at the price of pre-1.0 churn, the split license, and fifty cents of panel savings that evaporate at server two.
- Two-plus boxes, cost-first: Coolify. The $5 two-server base plus $3 marginal servers is simply the cheaper managed curve at every realistic fleet size, with zero paywalled features if you self-host instead.
And know the graduation signal. When the fleet — not the app — becomes the job (machines as declared code, load-driven scaling, healing without clicking), panels stop being leverage and start being ceiling. That's the declarative-machines conversation: infrastructure that provisions and reconciles itself on hardware you own, rather than a dashboard over boxes you still raise by hand.
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.
