Easypanel vs Coolify vs Dokploy: Self-Hosted PaaS on a VPS

Easypanel vs Coolify vs Dokploy is really one question: how much do you care that the panel running your VPS is open source? All three install with one curl command, put a dashboard over Docker, issue Let's Encrypt certificates and deploy from git. The difference that lasts is the licence. Easypanel is commercial software with a free plan. Coolify and Dokploy are open source, with Dokploy keeping a small set of enterprise features under a separate proprietary licence.

I have already compared Coolify and Dokploy head to head in an earlier post, and Easypanel came up afterwards when its founder wrote to suggest it as a third option for people who want a simple interface, a large maintained template catalogue and direct support. Nobody paid for this post and nobody reviewed it before publication. Every price, limit and licence below comes from the projects' own pricing pages, docs and licence files as of 1 October 2026, and where I quote Easypanel's comparison page I treat it as what it is: a vendor writing about its competitors.

Licence First: One Commercial Panel, Two Open-Source Ones

The licence decides what you can do on the day you disagree with the vendor, so it comes before features. Here is where each project stands, from its own repository or its own website.

• Easypanel: proprietary. Its own comparison table lists its source code as closed core, public templates, and a maintainer wrote in the project's GitHub discussions that there are no plans to open source the core. The free plan is free forever; paid plans are licences, one per server.
• Coolify: Apache-2.0, confirmed on the GitHub repository. Its pricing page says the self-hosted edition has full access to all features with no limitation, so there is no paid tier to unlock on your own server.
• Dokploy: Apache-2.0 for everything outside any directory named proprietary, which falls under a separate LICENSE_PROPRIETARY. In the repository those directories hold audit logs, SSO, SCIM, custom roles, license keys and white-labelling, and the docs say a self-hosted instance needs a license key to use them.

That third point is more precise than the way I put it in my earlier Coolify vs Dokploy comparison, where I called Dokploy's core source-available. Reading the LICENSE.MD file itself, the core is plain Apache-2.0; only the enterprise directories are proprietary. For a solo developer or a small team that never needs SSO or audit logs, Dokploy behaves like fully open software. Easypanel does not, and that is not a criticism, it is the business model: the company sells licences and support for a closed product, and says so.

Easypanel vs Coolify vs Dokploy at a Glance

The table puts the verified facts side by side. Template counts are Easypanel's figures from its own comparison page, verified by Easypanel on 29 September 2026 according to that page; I did not recount them, and the three projects do not count the same way.

Two rows deserve a second look. The paid options are not like for like: Coolify Cloud and Dokploy Cloud host the control plane for you while your apps run on your servers, whereas an Easypanel licence is permission to run the panel yourself on one more server. And the backup row is the one that changes most between a free and a paid Easypanel install, which section five comes back to.

Installation and the Runtime Underneath

Installation is a non-event on all three, which is why it is a poor way to choose. What matters is what the script leaves behind. Easypanel's docs say the installer initialises Docker Swarm; Dokploy's installation guide says the same and documents the environment variables for tuning it. Coolify installs plain Docker and manages containers directly.

# Easypanel — fresh Ubuntu, 2 GB RAM minimum, ports 80 and 443 free
curl -sSL https://get.easypanel.io | sh
# -> installs Docker and initialises Docker Swarm on this node

# Dokploy — 2 GB RAM and 30 GB disk minimum, ports 80, 443 and 3000 free
curl -sSL https://dokploy.com/install.sh | sh
# -> also initialises Docker Swarm; tune it with DOCKER_SWARM_INIT_ARGS
#    if the default address pool collides with your private network

# Coolify — 2 cores, 2 GB RAM, 10 GB disk; Docker from the official repo, not Snap
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
# -> plain Docker, no Swarm. Back up the .env file the installer generates
#    right away: it holds the encryption secrets for what Coolify stores

# Afterwards, see what each panel actually created
docker info --format '{{.Swarm.LocalNodeState}}'   # "active" on Easypanel and Dokploy
docker service ls                                   # Swarm-based panels: your apps live here
docker ps --format '{{.Names}}\t{{.Image}}'          # Coolify: your apps live here

On Coolify, Swarm was never the main path, and it is now on its way out. The Coolify docs label Docker Swarm support as deprecated, say parts of it were never fully implemented, and state it will be removed in v5 in favour of Docker Compose replicas and Coolify's own scaling. If an older comparison, including mine, told you Coolify offers optional Swarm clusters, that is no longer advice to build on: for new multi-server setups the docs recommend multiple servers behind an external load balancer.

Swarm on a single node costs almost nothing and gives Easypanel and Dokploy a ready path to more nodes, rolling updates and service-level resource limits. It also means your apps are Swarm services rather than ordinary containers, which matters when you debug: docker ps shows tasks with generated names, and docker service logs is the command you actually want.

Templates, Builders and Git Deploys

The template catalogue is Easypanel's strongest card, and it is also the hardest number to compare. Easypanel's comparison page claims 845 one-click templates against 293 for Coolify and 532 for Dokploy, while its own pricing page describes a catalogue of 790 plus. Both figures are the vendor's own. The template definitions live in a public GitHub repository, easypanel-io/templates, so you can read exactly what a template deploys before you click it, which is the same property Coolify and Dokploy have by virtue of being open source.

Builders are close to identical across the three, because they draw on the same open tools. Easypanel's docs list Dockerfile, Railpack, Nixpacks and Cloud Native Buildpacks through the pack CLI with Heroku and Paketo builders, pick Dockerfile automatically when one is in the build path, and otherwise fall back to Nixpacks. Dokploy lists Nixpacks as its default plus Railpack, Dockerfile, Heroku and Paketo buildpacks and a Static type served by Nginx. Coolify offers Nixpacks, Railpack in beta, Static, Dockerfile and Docker Compose. Easypanel's app service deploys from GitHub with an auto-deploy webhook, from any Git host over an SSH deploy key, from a Docker image or from an uploaded archive.

Databases, Backups, Domains and SSL

All three provision Postgres, MySQL, MariaDB, MongoDB and Redis from the dashboard, issue Let's Encrypt certificates automatically and route custom domains through a managed reverse proxy. Easypanel's pricing page lists automatic SSL and per-service custom domains with host and path routing and 13 built-in Traefik middlewares, plus Cloudflare Tunnel support. What its paid Hobby tier adds is a custom wildcard domain for the default service URLs, not custom domains as such.

Backups are where the plans diverge. On Easypanel, scheduled database backups appear in the list of things Hobby adds to Free, with destinations including S3-compatible storage such as Cloudflare R2 and Backblaze B2, Dropbox, Google Drive, FTP or SFTP and local disk. Coolify's self-hosted edition has no paid tier, so its S3 backups are simply there. Dokploy documents backups for both databases and volumes in its free core.

Multi-Server Support and the Support Model

Scaling past one box and getting help when something breaks are the two places where money changes hands, and each project draws the line differently.

• Easypanel licenses per server: one licence is the right to run Easypanel on one node, VM or instance. Managing several servers as one cluster with worker nodes is a Business-plan feature that the pricing page still labels alpha.
• Coolify manages any number of servers over SSH from one free self-hosted instance. Its paid Cloud plan is about not running the control plane yourself, not about unlocking servers.
• Dokploy self-hosted supports remote servers and Swarm nodes in the free core. Its paid tiers are Cloud plans plus enterprise features such as SSO, custom roles and audit logs.

Support is Easypanel's other strong card, with one wrinkle in its own wording. The comparison page says support is included on every paid plan. The pricing FAQ is narrower: on standard plans support runs through the Discord community, and on Business you get assistance directly from the team, with priority support listed for that tier. I would plan around the FAQ's version. Coolify is community-first, with limited email support on Cloud, and Dokploy offers Discord on free and Hobby, email and chat on Startup, and phone and video on Enterprise.

Vendor Lock-In and What Happens If You Stop Paying

Easypanel answers the stop-paying question directly in its pricing FAQ: if you cancel, Easypanel continues to work on the free plan and existing projects keep running normally. That is a fair policy. The consequence to plan for is that you are back to the free plan's limits, three projects and no paid features such as database backups, and that the panel itself is closed source, so if the company ever stopped shipping there would be no community fork to move to. Coolify's docs make the opposite guarantee structural: workloads are standard Docker containers that keep running even if Coolify becomes unavailable. Dokploy without a licence key simply loses the enterprise features. Whatever you choose, run an exit drill once while everything still works.

# 1. On a Swarm-based panel, recover what the panel would have to tell you:
#    image, environment and mounts of every service, as plain JSON.
for svc in $(docker service ls --format '{{.Name}}'); do
  docker service inspect "$svc" \
    --format '{{json .Spec.TaskTemplate.ContainerSpec}}' \
    | jq '{Image, Env, Mounts}' > "spec-$svc.json"
done

# 2. Volumes are where the data is — list them before you trust any backup
docker volume ls

# 3. Take a database dump that does not depend on the panel's backup feature
#    (Wrong: assuming the panel's scheduled backup exists on your plan)
#    (Right: a dump you made, in a place you control)
docker exec "$(docker ps -q -f name=myproject_db | head -n1)" \
  pg_dump -U postgres -Fc postgres > "db-$(date +%F).dump"

# 4. The rebuild path is your repo: Dockerfile or compose file, plus the env
#    you just exported. If those two exist, the panel is replaceable.

None of the three hides your apps in a format only it can read. They are Docker images, Swarm services or containers, Docker volumes and environment variables, and every one of those can be read with the Docker CLI. The real lock-in is softer: template-specific wiring, panel-managed backups you never tested restoring, and environment variables that exist only in the panel's database.

Who Should Pick Which

• Pick Easypanel if you want the most polished click-through experience, the biggest catalogue of maintained templates, and a company you can pay for direct help, and you are comfortable running a closed-source panel. Budget for at least Hobby on any server whose databases matter, so backups are covered.
• Pick Coolify if an open licence with no paid tier on your own server is a requirement, you run plain Docker on one or many servers, and community support is enough. Do not start new Swarm work on it.
• Pick Dokploy if you want an open-source panel built on Docker Swarm from the start, with a paid path to SSO and audit logs later. Expect a pre-1.0 project: its latest release as I write is v0.30.8, published on 29 September 2026.

For the deeper Coolify against Dokploy detail, including database tooling and idle resource use on a small VPS, see my earlier Coolify vs Dokploy self-hosted PaaS comparison. This post adds the commercial option to that picture rather than repeating it.

The rule I would carry away is to compare self-hosted panels on licence, backups and support before features, because those three decide what happens on your worst day. Easypanel is a good commercial product with a usable free plan and a clear cancellation policy; Coolify and Dokploy are open source and free on your own server. All three can run the same Docker image tomorrow, so make sure yours can.