Coolify or Dokploy? Two app platforms tested side by side

The short answer

Pick Coolify if you want the most done for you on one server: backups to the server itself or to S3, rollbacks with no extra setup, automatic updates, and every feature free. Pick Dokploy if you want a lighter-feeling dashboard with faster deploys, plan to spread apps over several servers with Docker Swarm, and have an S3 bucket and a container registry anyway. Both need a server of their own, and both ran comfortably on a VC-P Alloy.

What we tested

We installed each platform on the same Melonslab VC-P Alloy (2 vCPU, 8 GB) with Debian 13, one after the other, following our guides for Coolify and Dokploy. Between the two, we removed the first one completely, Docker included, so each started from the same clean server and was measured on its own.

On both, we did the same job:

• deployed the same small Node.js app, built from its Dockerfile in a public Git repository, with a PostgreSQL database and its own name with a Let's Encrypt certificate;
• pushed a change to the repository, deployed it, and rolled back to the version before;
• backed up the database, deleted its table, and restored it from the backup in the dashboard;
• restarted the server and checked that the app, the database and the dashboard came back by themselves.

Everything above worked on both. Multi-server setups were not tested: we had one server.

The numbers

Memory is the sum of each platform's containers as Docker reported it, a few minutes after a restart. Most of Dokploy's memory is its one main container, at about 880 MB; Coolify's main container used about 490 MB, and its database, Redis, proxy and monitoring agent the rest. Dokploy's own image alone is 3.25 GB, which is most of the disk difference.

Setup

Both install with one script, which sets up Docker and the Traefik proxy on ports 80 and 443. Neither belongs on a server that already runs other web services: both run as root and take over those ports, so each needs a server of its own.

Coolify creates the admin account during the install, from the name, email address and password you give the script. Nobody can reach a setup page before you. Its dashboard also answers on ports 8000, 6001 and 6002, which our guide closes once the dashboard has its own name. Telemetry is on by default, and our guide switches it off.

Dokploy finishes with a page on port 3000 where whoever arrives first creates the admin account. Our guide closes that port straight after the install and reaches the page through an SSH tunnel. It is one more step to get right, and the cost of skipping it is someone else owning your server. We found no telemetry in Dokploy.

Dokploy also marks Docker's packages as held, at version 28.5, so they are left out of upgrades until you lift the hold with apt-mark unhold. Coolify installs the latest Docker and leaves its packages alone.

Deploying from Git

Both did the same job in the same few steps: a public repository, a branch, a build type, a port, a name. Both build from a Dockerfile, or detect the language themselves: Coolify uses Railpack by default, Dokploy Nixpacks, and both offer the other as well. Both connect to GitHub, GitLab and others for private repositories and deploys on every push, and both give each app a webhook address to trigger a deploy from anywhere.

Dokploy was quicker every time. Its deploys took about 10 to 20 seconds, Coolify's 35 seconds to a minute, because Coolify runs every build in a helper container and checks the repository out again even when it can reuse an image.

Both start the new version before stopping the old one. We sent a request every half second while deploying: Dokploy's redeploy dropped none. During Coolify's rollback, which swaps containers the same way as a deploy, both versions answered for about 20 seconds, and one request in about 150 failed at the switch.

Rollbacks are where they differ most. Coolify keeps the images of earlier deploys on the server and lists them under Rollback, ready to use. Dokploy rolls back only to deploys made after Configure Rollbacks is switched on, and only with a container registry to keep the images in. We ran a registry on the server for the test, and rollbacks then worked quickly. Without a registry, Dokploy has no rollback.

Coolify's rollback checks the old commit out of the repository again before it reuses the image, so the repository has to be reachable for a rollback to work.

Databases and backups

Both start PostgreSQL, MySQL, MariaDB, MongoDB and Redis from the dashboard, with generated or chosen passwords, kept off the internet unless you open a port. Coolify also offers ClickHouse, KeyDB, Dragonfly and an experimental SQLite; Dokploy offers libSQL.

Coolify backs up on a schedule to the server itself, to /data/coolify/backups, and to an S3-compatible bucket if you add one. Back Up Now took a backup in about 2 seconds. Restoring from Import Backup worked, after typing a confirmation and the account's password.

Dokploy backs up databases, and app volumes, to S3-compatible storage only. With a bucket on the server for the test, a manual backup landed in it, and Restore Backup brought the table back. Without a bucket, there are no backups at all, so plan one in before you rely on Dokploy.

Either way, a backup that stays on the server is lost with it. Use a bucket somewhere else, such as on Garage on another server.

Domains and certificates

Both requested Let's Encrypt certificates on their own, for the dashboard and for the app, and redirected HTTP to HTTPS.

Coolify adds a www. name next to each name you enter, and a temporary sslip.io address, which you can delete. Its Domains page shows whether each name points at the server. Dokploy adds exactly the name you enter, and Validate DNS checks it.

Apps behind Coolify saw each visitor's real address over IPv4 and IPv6. Behind Dokploy, visitors over IPv6 showed up as 172.18.0.1, Docker's own network, because Dokploy's network has no IPv6. Over IPv4, Dokploy passed the real address too.

More than one server

Both can deploy to more servers over SSH from the same dashboard. Dokploy runs everything as Docker Swarm services from the start, so adding nodes to a swarm is part of its design. Coolify adds servers one by one, each running its own Docker. We did not test either with more than one server.

Updates

Coolify updates itself every night by default. You can switch it off or change the time under Settings and Updates.

Dokploy does not update itself. Check for updates under Settings and Web Server looks for a new version, and you start the update.

Coolify's own data is in /data/coolify, and its encryption keys in /data/coolify/source/.env, which you keep a copy of. Coolify can also back up its own database under Settings and Backup. Dokploy keeps its configuration in /etc/dokploy and its own PostgreSQL database.

Licence and cost

We checked both projects' licences and pricing pages on 14 October 2026.

Coolify is Apache 2.0, and self-hosted Coolify has every feature, free. Its own paid service, Coolify Cloud, runs the dashboard for you at $5 a month including two of your servers, and $3 a month for each server after that; your apps still run on your own servers.

Dokploy is Apache 2.0, except for the code in its proprietary folder. Self-hosted Dokploy deploys apps, databases and backups without a licence, and its dashboard has pages for SSO, audit logs and white labelling that ask for an Enterprise licence key, priced on request. Dokploy Cloud costs $4.50 a month per server on its Hobby plan, which is limited to one user, and from $15 a month on its Startup plan.

Which one to pick

Pick Coolify if you run your apps on one server and want it to look after itself: local and S3 backups, rollbacks without a registry, nightly updates, and nothing behind a licence. Its weaknesses are slower deploys, more containers, and telemetry you have to switch off yourself.

Pick Dokploy if fast deploys and Docker Swarm matter more to you, and you have an S3 bucket and a registry, or will set them up. Its weaknesses are a first-come setup page, backups and rollbacks that depend on outside services, no IPv6 in its network, Docker held at an older version, about 300 MB more memory, and SSO and audit logs only with a paid licence.

Both ran comfortably on a VC-P Alloy with 2 vCPU and 8 GB, which also leaves room for builds. Follow our Coolify guide or our Dokploy guide on a fresh server of its own.