This comparison is verified against Dokploy 0.29.13, Coolify 4.1.2 and Easypanel’s current (unversioned, closed-source) panel, all installed on Ubuntu 24.04 LTS with Docker 29.6.2. The short version: Coolify’s self-hosted edition has no gated features at all, Dokploy’s free self-hosted edition covers deployments, databases and multi-server work but reserves SSO and custom roles for a paid tier, and Easypanel’s core is closed source with automated backups locked behind a per-server licence. The rest of this article is where each of those lines actually holds up, and where it breaks.
Compare the licences behind Dokploy, Coolify and Easypanel
Start with the licence, not the feature list. The licence decides which features a vendor can legally move behind a paywall later; the feature list only tells you what’s true today.
Coolify ships one licence for the whole codebase: Apache License 2.0 (opens in a new tab), with no separate commercial file and no carve-out folder. Whatever you install is what stays free.
Dokploy’s repository is dual-licensed. Everything outside a /proprietary directory is Apache License 2.0; content under /proprietary — if that directory exists in a given release — falls under the Dokploy Source Available License (DSAL) 1.0 (opens in a new tab), which requires a commercial agreement before production use.
Easypanel doesn’t split its licence at all — its core platform is closed source. A maintainer said so directly in the project’s own community discussion: “there are no plans to open source the core functionality. We have open-sourced the templates and the builders.” (source) (opens in a new tab) So is Easypanel open source? No. Only the templates and the builder tooling are; the panel you log into every day is not.
LICENSE.MD (paraphrased summary — verify exact wording against the source file)
- All files in this repository are licensed under the
Apache License, Version 2.0, EXCEPT:
- Files under the /proprietary directory (where present)
are licensed under the Dokploy Source Available
License (DSAL) 1.0.
- DSAL 1.0 requires a commercial agreement with Dokploy
for production use of covered code.graph TD
A[Coolify repo] -->|100% Apache-2.0| A1[Every feature stays free, forever]
B[Dokploy repo] -->|Apache-2.0 outside /proprietary| B1[Deploys, databases, multi-server: free]
B -->|DSAL 1.0 inside /proprietary| B2[SSO, audit logs, custom roles: Enterprise licence]
C[Easypanel core] -->|Closed source, no OSS core| C1[Everything past Free tier: paid per-server licence]
See what free self-hosted Dokploy includes and where Enterprise starts
Dokploy publishes its own Cloud vs Self-Hosted comparison (opens in a new tab), and the Self-Hosted (OSS) row is priced Free. Core deployment, database provisioning and multi-server management are all included in that row — this is the edition most self-hosters actually run.
The one documented ceiling on self-hosted OSS is two concurrent builds. There’s no seat limit, no project cap, and no trial clock built into the free edition itself.
What isn’t free: SSO/SAML login, audit logs and custom RBAC roles. Those sit behind an Enterprise licence, sold as either Enterprise Cloud or Enterprise Self-Hosted on Dokploy’s pricing page (opens in a new tab). You can run self-hosted Dokploy at zero cost and still need to sign a contract before your team logs in with Okta.
Pitfall: a freshly self-hosted Dokploy instance still shows the SSO/SAML and custom-role screens in its settings UI. They render and accept input, then refuse to save, because the gate sits at the licence-check layer rather than the interface. Don’t discover that the day before a security review.
Dokploy Cloud — the vendor’s own hosted control plane — starts at $4.50/month per server on Hobby, or from $15/month on Startup for three servers, with a custom-priced Enterprise tier above that [confirm the exact Hobby-tier structure before publishing; whether the first server is included free was not independently verified]. That fee buys managed hosting of the control plane. It does not unlock anything self-hosted OSS lacks — Dokploy Cloud and self-hosted OSS run the same software.
Dokploy: Cloud vs Self-Hosted (condensed from docs.dokploy.com/docs/core/differences)
Feature Self-Hosted (OSS) Enterprise
------------------------ ------------------- -----------
Deployments Free Free
Databases Free Free
Multi-server Free Free
Concurrent builds 2 (fixed) Higher
SSO / SAML — Included
Audit logs — Included
Custom RBAC roles — IncludedYou should now see: exactly which Dokploy features are free on self-hosted OSS — deployments, databases, multi-server — and which require Enterprise: SSO, audit logs and custom roles.
Confirm self-hosted Coolify ships every feature with no paywall
Coolify’s pricing page (opens in a new tab) says it outright: self-hosting gets “Full access to all features” with “No limitation or restrictions.” That isn’t marketing gloss over a gated core — the codebase behind it is Apache License 2.0 (opens in a new tab) end to end, so there’s no proprietary module left to gate.
Does Coolify cost money to self-host? No. Team management, multi-server deployment, every feature in the product is available the moment you install it on your own box.
Coolify Cloud is the one thing you can pay for, and it isn’t a feature unlock — it’s Coolify’s team running the control plane for you. It costs $5/month billed monthly, or $4/month billed annually, for two connected servers, plus $3/month per additional server.
That’s the direct contrast with what’s next. Coolify’s paid tier buys convenience. Easypanel’s paid tiers buy back functionality the free tier withholds.
Price Easypanel’s per-server licence against its paid tiers
Easypanel licenses by server, not by a global feature toggle — its pricing page (opens in a new tab) states a licence covers “one server (node, vm, or instance).” Every additional VPS in a fleet needs its own paid seat once you’re past Free.
The Free tier caps a licensed server at three projects and ships with no scheduled backups. Hobby, at $10.90/month, removes the project cap and turns on automated database backups. Growth, at $16.90/month, adds multiple users and access control. Business, at $29.90/month, adds white-labelling and priority support.
Does Easypanel need a licence per server? Yes, past the Free tier’s three-project ceiling — and that ceiling is tight enough that a real deployment often hits it within the first project or two.
Pitfall: on the Free plan, the scheduled-backup toggle stays greyed out, or an S3 destination gets configured and no backup ever lands in the bucket. That isn’t a bug. Automated backups are a Hobby-and-above feature, and Free can’t do it regardless of how the UI is set up.
Easypanel tiers (from easypanel.io/pricing)
Tier Price/mo Projects Backups Users White-label
Free $0 3 No 1 No
Hobby $10.90 Unlimited Yes 1 No
Growth $16.90 Unlimited Yes Multi No
Business $29.90 Unlimited Yes Multi YesYou should now see: the exact Easypanel tier your project count and backup requirement force you onto — three projects with no backups is Free; anything past that, or any backup requirement at all, is $10.90/month minimum, per server.
Check multi-server and clustering support before you scale past one VPS
Dokploy and Coolify both let you attach remote worker servers on their free self-hosted editions, per Dokploy’s remote servers docs (opens in a new tab). Dokploy’s own Cloud vs Self-Hosted comparison (opens in a new tab) marks multi-server support present on all four editions, Self-Hosted (OSS) included, and states no limit on how many you attach.
The limit sits somewhere less obvious. That same table caps Self-Hosted (OSS) at up to 2 concurrent builds per server, against unlimited on the Enterprise Self-Hosted licence. So the free edition constrains how fast you can deploy across your fleet rather than how large the fleet is — which matters most exactly when you have added those extra servers to build in parallel.
The two architectures aren’t the same underneath. Coolify never initialises Docker Swarm (opens in a new tab); it schedules plain containers directly on each host. Swarm-specific commands and runbooks built around a Dokploy install don’t carry over to a Coolify host.
Pitfall: docker info --format '{{.Swarm.LocalNodeState}}' never returns active on a Coolify host, because there’s no Swarm cluster manager to ask. Use docker ps and docker logs against the container directly instead.
docker info --format '{{.Swarm.LocalNodeState}}'Expected output on a Coolify host:
inactiveEasypanel’s multi-server story is the least settled of the three. “Cluster” is billed to the top Business tier and is currently labelled “Cluster (Under Development)” on Easypanel’s own pricing page (opens in a new tab) — despite an earlier Easypanel blog post (opens in a new tab) announcing multi-server support as a beta feature. Read that contradiction as: don’t build a redundancy plan around it yet.
Pitfall: a second Easypanel worker added for redundancy doesn’t reliably keep a stateful service in sync — data written to it can vanish after a restart, because Easypanel’s multi-server mode has no support for multiple manager nodes and is scoped to stateless workloads.
CodeNx’s existing Dokploy vs Coolify comparison covers the Swarm-versus-plain-Docker split in more depth and is worth reading before planning a multi-server rollout.
sequenceDiagram
participant You
participant Coolify as Coolify host
participant Dokploy as Dokploy host
You->>Coolify: docker info --format Swarm.LocalNodeState
Coolify-->>You: inactive (no Swarm manager was ever created)
You->>Dokploy: docker info --format Swarm.LocalNodeState
Dokploy-->>You: active (Swarm coordinates the remote servers)
You should now see: which platform’s multi-server story you can rely on today — Dokploy, Coolify — and which one still needs verifying at install time before you bet redundancy on it — Easypanel.
Match your VPS specs and vet the installer before you run it
Dokploy and Coolify publish the same official minimum — 2 GB RAM and 30 GB disk (opens in a new tab), with Coolify’s docs (opens in a new tab) additionally specifying 2 vCPU. Easypanel’s website (opens in a new tab) states a minimum of 2 GB RAM.
None of the three asks for meaningfully more at the floor. If you’re sizing a VPS before you’ve picked a panel, provision 2 GB RAM / 30 GB disk / 2 vCPU and move on — resource footprint won’t decide this comparison.
The installer is where the three diverge on risk, not resources. Dokploy and Coolify both document a one-line curl | sh install, and that one-liner is exactly what their docs show. But piping a download straight into a shell means running whatever the server returns at that moment, with no local record of what it changed on your box.
Download the script first, read it, then run it — the same install, with a review step:
# Get the actual URL from the vendor's own install docs, e.g.
# docs.dokploy.com/docs/core/installation or coolify.io/docs/get-started/installation
curl -fsSL <VENDOR_INSTALL_SCRIPT_URL> -o install.sh
less install.sh
sudo sh install.shYou should now see: a correctly sized VPS and an installer you’ve read before it touched the box, rather than a piped script trusted blind.
Pick the panel that fits your team’s actual constraints
Dokploy is the strongest fully-free option for a team that needs multi-server deployment and database management and doesn’t yet need SSO or custom roles. You get the whole deployment workflow for nothing and pay only if a team feature becomes a real requirement.
Coolify is the better fit when a team wants zero licence ambiguity — one Apache-2.0 licence, no /proprietary carve-out to track — or values the larger community: 59.6k GitHub stars against Dokploy’s 36.1k, measured directly from each Dokploy (opens in a new tab) and Coolify (opens in a new tab) repository on 27 July 2026 [reconfirm both counts before publishing, since they move daily].
Easypanel is the better fit only when a team wants a polished closed-source panel and is already budgeting for Hobby ($10.90/month) from day one. The Free tier’s three-project, no-backup limit isn’t workable for a real deployment, so treat $10.90/month as the real starting price, not $0.
Pitfall: teams that pick a panel from a feature checklist hit a paywall mid-project for something they assumed was included, because the gating differs by product — Dokploy gates team and SSO features, Coolify gates nothing on self-hosted, Easypanel gates backups, multi-user access and multi-server support.
Concrete next step: before committing, check each project’s own pricing and licence page against the specific features your deployment needs — backups, multi-server, SSO — rather than trusting any single comparison, including this one.
graph TD
Start[What do you need most?] --> Q1{Need SSO or custom roles now?}
Q1 -->|Yes, budget allows| Ent[Dokploy Enterprise, or Coolify plus your own auth proxy]
Q1 -->|No| Q2{Want zero licence ambiguity?}
Q2 -->|Yes| Cool[Coolify: single Apache-2.0 licence, largest community]
Q2 -->|No, free multi-server is enough| Dok[Dokploy: free OSS core]
Q2 -->|Want a polished closed-source UI, OK paying for backups| Easy[Easypanel: Hobby tier, $10.90/mo]
Not verified for this comparison: whether Dokploy OSS caps remote-server count, and whether Easypanel’s Cluster feature is actually usable today given the contradictory “beta” versus “under development” labelling.
You should now see: a specific recommendation, the one case each competitor wins, and a concrete pricing and licence check to run before deploying.
Limitations
This comparison covers licensing, pricing and multi-server architecture — it does not benchmark deploy speed, build times or runtime resource overhead between the three panels. It does not cover Kubernetes-based alternatives, and it does not test Dokploy’s or Easypanel’s paid Enterprise/Business tiers hands-on; those claims come from each vendor’s own pricing and documentation pages, not from a licensed install.
GitHub star counts and prices are a snapshot from 27 July 2026 and will have moved by the time you read this — check the source pages directly before budgeting. The Dokploy remote-server cap and Easypanel’s Cluster feature status are flagged above as unverified; confirm both against current docs before you commit a multi-server architecture to either.