~8m36:52
Dreams of Code

Coolify vs Dokploy: Why I decided to use one over the other

Sep 16, 2025

Read: ~8m · You save: 29 min

Coolify vs Dokploy: Why I Chose One of Them

Coolify or Dokploy? The author honestly compares two self-hosted PaaS platforms by resources, UI, deployment, databases, and licenses. The result may surprise you.

Over the past few months, most of our production services have been deployed on VPS servers using Dokploy. Dokploy replaced our previous Docker Stack-based setup. Coolify was one of the main alternatives considered when choosing a platform. Below, we describe the characteristics of both platforms, the results of the comparison across key categories, and the reasons for choosing Dokploy.

General Overview

Coolify and Dokploy belong to the class of platform as a service (PaaS) solutions. Such platforms allow developers to deploy, manage, and scale applications without working with infrastructure.

Popular PaaS platforms, such as Vercel, Netlify, and Railway, are proprietary. Coolify and Dokploy are built on open-source technologies and can be self-hosted. This provides the following advantages:

  • full control over infrastructure and data;
  • the ability to deploy on a VPS or your own hardware;
  • more predictable long-term costs without the unexpected bills that are possible with serverless platforms, such as Vercel;
  • no platform restrictions on languages and frameworks;
  • the ability to migrate applications to another service without being tied to a specific vendor's ecosystem or pricing model.

Coolify

  • Author: Andras Bachai. The project was started in 2022, and since mid-2023 development has been full-time.
  • Technologies: the application is written in PHP, and at the time of writing it used a version based on Laravel. Docker is used for building and deploying applications.
  • Development activity: since February 2022, the repository has more than 12,000 commits, a significant portion of which were made recently.
  • Popularity: more than 44,000 stars on GitHub.

Dokploy

  • Author: Mauricio Su. The project was started in April 2024.
  • Technologies: Docker for building and deploying. The web application is built on Next.js using TypeScript libraries, in particular better and sonner.
  • Development activity: more than 4,000 commits and more than 24,000 stars on GitHub. In terms of development pace, the author assesses that Dokploy significantly outpaces Coolify.

The choice of technology stack is important to the author, since they more often contribute to projects that use a familiar stack. The author has contributed to the project multiple times.

Comparison Methodology

Two instances of VPS KVM2 with identical specifications were used for the comparison to eliminate competition for resources:

  • 2 vCPU;
  • 100 GB SSD;
  • 8 GB RAM;
  • 8 TB of traffic per month;
  • cost of $6.99 per month with a 24-month term.

The high resources of the VPS are one of the advantages of Coolify and Dokploy over serverless platforms, where the cost of transferring 8 TB of data can be significant.

The operating system on both servers was the latest LTS version of Ubuntu. The servers were configured from scratch, because installing one of the applications from a ready-made image would not have been comparable in terms of ease of installation. The setup order was as follows:

  1. Configuring SSH keys and the root password.
  2. Installing and registering Tailscale.
  3. Configuring a firewall that closes SSH to the public internet.
  4. Creating DNS records for each server, pointing to its IP address.

Comparison by Category

Ease of Installation and Setup

Installation. Both platforms install with a single command, and the process takes a few minutes. Coolify shows detailed information about each installation step. The author noted that Coolify also adds jokes to the installation process, which the author called unfortunate.

After installation, both platforms display a combination of an IP address and a port for accessing the web interface. The first administrator account is created over HTTP. The author considers this approach unsatisfactory but understandable. He would like to be able to configure HTTPS during installation. In his own setup, the author solved this by connecting through Tailscale, so data is transmitted over an encrypted WireGuard channel. The Coolify installer also displays the node's private IP addresses, which can be used to connect to the instance through Tailscale.

Initial Setup. Coolify offers an onboarding procedure, which the author rated as convenient for beginners. In the author's configuration, Coolify could not set up the local server for deployment because it could not connect to itself over SSH. The cause was a firewall that blocked SSH except on the Tailscale interface.

Attempts to solve the problem by adding UFW rules, including allowing SSH on the Docker interface and on all bridge networks, did not work. SSH from the Coolify container worked only with the firewall disabled. The solution was a rule that denies SSH on the eth0 interface and allows it for the 10.0.0.0/8 subnet, which covers all Docker networks. After this, the local server in Coolify was configured successfully.

The author noted that the solution required knowledge of network configuration. Because the expected solutions did not work, the setup experience was negative. The author also pointed out that blocking SSH is a common security measure, so the problem is not entirely Coolify's fault.

Dokploy worked immediately after installation. Dokploy has no onboarding, and the author felt it was not needed. The author deleted the resource that Coolify had created by default.

The remaining steps, including configuring a domain name and HTTPS, were performed similarly on both platforms. The main differences are related to the interface.

Category Verdict: Coolify is better for the installation process. For overall setup experience, Dokploy is the winner, since it worked with the author's security and firewall configuration without any additional steps, while Coolify's onboarding, in the author's opinion, did not provide any significant benefit.

Resource Consumption

Resource consumption was measured several times during use of the platforms. The first measurement was taken a few hours after installation, with no other services running, to establish a baseline. Data was collected through the hosting panel, which displays server usage metrics.

MetricDokployCoolify
RAM, baselineabout 1 GBabout 1 GB
CPU load without services0.8–1.5%6–7%
CPU load with metrics enablednot specifiedup to 25% (peaks)

Memory consumption was similar for both platforms. The author rated it as high, which is related to the technologies these platforms use. For small instances, this may matter. On a VPS with a large amount of memory, such as Hostinger, the author believes there is no problem.

CPU load differed significantly. Coolify idled at 6–7% even though no services were running. After deploying identical services, memory consumption grew on both platforms, and the growth was noticeably larger on Coolify. Coolify's CPU load also increased after services were launched and rose even more after metrics were enabled.

To rule out the influence of VPS configuration, Coolify was deployed on several other VPS instances. The results matched. The author concluded that Coolify uses more CPU cycles when idle. The difference is small but important for a single-node configuration. The author assumes that most users start with a single node.

Category Verdict: Dokploy wins.

Resource Structure

The resource hierarchy looks like this:

  • Teams (Coolify) / organizations (Dokploy). The highest level of grouping. They allow users and projects to be combined. In Coolify, servers are also distributed among teams. In Dokploy, any team has access to any server.
  • Projects. Group related services and applications together.
  • Environments (Coolify only). Multiple environments can be created within a project. A production environment is created by default.
  • End resources. In Dokploy they are called services; in Coolify, resources.

The key difference: in Dokploy, services belong to a project, while in Coolify, resources belong to an environment, which belongs to a project. This affects shared variables. In Coolify, shared variables can be set at the project or environment level. In Dokploy, they can be set only at the project level.

Environments in Dokploy can be created manually, for example by naming projects dev or prod. However, the author considers Coolify's default environments more intuitive, although accessing services requires an additional level of nesting. The author noted that the need for environments is subjective, but he considers having environments in Coolify useful even if the user does not use them.

Category Verdict: Coolify wins.

User Interface and User Experience

The author acknowledges that this category is subjective. In his assessment, Dokploy is easier to navigate. Because it uses Next.js, the interface works as a single-page application, which, in the author's opinion, makes it more responsive. Dokploy's interface is also more consistent.

In Coolify, the author identified several problems:

  • Save button. It is often placed next to the section heading, which the author finds inconvenient.
  • Saving changes. Some fields are saved automatically, while others require clicking a button. In some cases, clicking the save button triggered validation of fields located in a different section.
  • Notifications. The pop-up save notification, in the author's opinion, is distracting but does not solve the problem of inconsistent behavior.
  • Passwords. Each time the user left a page with a password field, the browser offered to save the password.
  • Project support banner. The banner appeared on every navigation and blocked interaction with the bottom of the page. It can be temporarily dismissed, but it reappears after a month. It can be disabled completely in Coolify's settings.

In Dokploy, the save button is located at the bottom of the section, applies to all changes in the section, and has noticeable contrast. The author considers Dokploy more convenient to use.

According to the developers, Coolify fixed the UI/UX issues in version 4.

Category Verdict: Dokploy wins by a significant margin.

Application Deployment and Configuration

Both platforms support:

  • deploying custom applications from a Git repository, a Docker image, or Docker Compose;
  • deploying templates for popular services, which simplifies getting started for beginners;
  • building applications without a Dockerfile using Nixpacks;
  • selecting a deployment server: local or remote in a multi-server configuration;
  • configuring the start command, environment variables, and other parameters.

Differences:

  • Git providers. Dokploy supports GitLab and Bitbucket in addition to GitHub. Coolify supports only GitHub.
  • Build types. Dokploy supports Railpack, Heroku buildpacks, and Paketo buildpacks in addition to Nixpacks.
  • AI assistant. Dokploy allows connecting an LLM and generating and configuring deployments through an AI assistant. The author did not use this feature in production but found it interesting and well implemented.

The author believes Dokploy has a slight edge over Coolify thanks to its larger number of Git providers and build types. For users who do not use GitHub or prefer building with something other than Nixpacks or Docker, Dokploy clearly wins, in the author's opinion. For the author's own use case, both platforms fully meet the requirements.

Category Verdict: Tie, one point to each platform.

Databases

Both platforms offer a dedicated database deployment service with features necessary for production use. The key feature is scheduled data backups to S3-compatible storage.

Differences:

  • Database image. Coolify allows selecting only a tag from the base Docker image. Dokploy allows selecting a full image. For example, in Dokploy you can use a custom PostgreSQL image with the required extensions. In Coolify, this requires creating a new service from scratch.
  • Supported databases. Both platforms support PostgreSQL, MySQL, Redis, MariaDB, and MongoDB. Coolify additionally supports Dragonfly DB, KeyDB, and ClickHouse. These databases can be deployed manually in Dokploy as well. Dragonfly DB is available in Dokploy as a template.
  • Volume backups. Dokploy supports volume backups to S3-compatible storage, while Coolify does not. This allows Dokploy to provide a production-ready mode of operation for databases.

The author uses Neon for PostgreSQL and does not deploy databases through the platform. He noted that the ability to deploy databases with scheduled backups is still important.

Category Verdict: Tie, one point to each platform.

Additional Features

Preview Deployments (Review Apps)

Preview deployments were the reason the author switched from Docker Stack. Both platforms create a version of the application for each pull request on the configured branch. This makes it possible to test changes in a separate environment before merging.

Differences:

  • Environment variables. Coolify automatically copies variables from the main environment. Dokploy requires them to be set again. The author noted that both approaches have advantages and disadvantages.
  • Dynamic variables. The author would like to set environment variables for each preview deployment dynamically. Both platforms provide an API for updating variables across all preview deployments, but not for an individual deployment.
  • Triggering via API or webhook. The author considers it useful to be able to start a review app through an API or webhook. Currently, deployments start automatically or manually via a button in the interface. Triggering through the API would allow other tasks to run before the deployment starts, such as creating a new database branch in Neon. For Dokploy, there is an open issue, but the feature has not yet been implemented.

The author has implemented their own scheme: an integration between Neon and Dokploy creates a new branch with production data for each review. The trigger is run manually through the API rather than through a built-in feature.

API and CLI

Both platforms provide an API and CLI for task automation. In the author's assessment, Coolify's API has roughly the same capabilities as Dokploy's API. When comparing the CLI READMEs, it turned out that Coolify's CLI does not support all API operations, whereas Dokploy's CLI does. The author uses Dokploy's API for their own CI/CD pipeline, which performs additional tasks before creating a review app. According to the author, the pipeline works well.

Notifications

Both platforms send notifications about deployments, metrics, backups, and scheduled events. Channels: Slack, Telegram, Discord, and email via SMTP. Coolify additionally supports email through an integration with Resend, which the author uses as their primary transactional email service.

Differences:

  • Pushover (Coolify). A push notification service for iOS, Android, and desktop computers. It is paid once for each device.
  • Gotify (Dokploy). Oriented toward automation. The author describes it as an analogue of open-source AWS SQS. Gotify can be connected to other platforms, such as n8n, and used as a basis for adding Pushover support or building automations for any notifications.

The author considers Dokploy to have a slight advantage in this respect.

Multi-Server Configurations and Clustering

Both platforms support remote servers for deployment, which offloads work from the server running the platform itself. The author considers this configuration mandatory for a production environment.

Coolify allows a remote server to be designated as a dedicated build server. This reduces the load on the hosting server and protects application performance from the impact of builds. The author finds this feature useful and would like to see it in Dokploy. For Dokploy, there is an open issue. The author builds most applications in CI/CD, so the feature is less critical for them.

Connecting a remote server is done over SSH. The author uses Tailscale and does not expose SSH to the public internet. Both platforms work with this configuration. To connect, you need to use the machine's Tailscale IP address or its fully qualified Tailscale domain name, which are displayed in the admin panel.

Clustering in both platforms is implemented via Docker Swarm. Coolify labels this feature as experimental.

Scheduled Tasks

Both platforms allow a cron task to be set up inside a service or resource to run periodically in a container or image. Dokploy additionally allows scheduling runs directly on the machine with a bash script. Tasks are more commonly run in containers. Such tasks are useful for data backups and periodic operations.

Monitoring and Metrics

Both platforms provide server and service metrics. Dokploy includes metrics by default. In Coolify, they must be enabled manually.

Dokploy's metrics can be sent to its built-in notification system, including Gotify. This makes it possible to trigger automations based on events, such as when CPU or memory usage exceeds a threshold. The author considers this capability necessary for a production system, including for autoscaling.

After enabling metrics in Coolify, the author noticed an increase in server CPU load, in some cases up to 25%. Metrics from Sentinel, Coolify's built-in solution, contained no disk usage data, or the author could not find it. The author managed to set up disk-full notifications through a workaround. The author suspects that such notifications are difficult to use for autoscaling, since they are not integrated with an automation system the way Gotify is.

As of the time of writing, Coolify's metrics are classified as experimental features.

Volume Backups

Dokploy supports backing up Docker volumes to S3-compatible storage. The feature works for arbitrary volumes, not just databases. The author could not confirm the presence of such a feature in Coolify.

Traffic Routing

Both platforms use Traefik as the default ingress service. The configuration allows setting rate limiting, authentication, redirects, load balancing, and other parameters.

  • Dokploy. Settings are located on the Advanced tab of the service. Some actions are available through the interface, while more advanced changes are made directly in the traffic configuration.
  • Coolify. The main traffic configuration is located in the Proxy menu of the service settings and takes the form of a YAML file. The configuration for individual applications is located at the bottom of the resource settings: port mapping, HTTP Basic Auth, and container labels. The author prefers the container labels approach, but inconsistent saving in the Coolify interface created difficulties for them.

Advantages of Coolify

The author highlighted two aspects on which a user might choose Coolify:

  1. Cloudflare Tunnels. Coolify supports Cloudflare Tunnels out of the box. This makes it possible to deploy Coolify and ingress without exposing the machine to the internet and without port forwarding. The feature is useful for home labs and improves security. Dokploy also supports Cloudflare Tunnels, and it has a corresponding template. However, in the author's view, Coolify provides this feature as a built-in capability, which fits the purpose of a PaaS: freeing the user from managing infrastructure. For the author, who deploys applications on a VPS and uses Cloudflare Proxy, this feature is not required.

  2. License. Coolify is distributed under the Apache 2.0 license and is considered a fully open-source project.

Dokploy is also distributed under Apache 2.0, but part of its code is excluded from the license. The excluded parts are:

  • Docker Compose templates;
  • multi-node support;
  • schedules;
  • preview deployments;
  • multi-server configuration features.

These features may not be sold or offered as a service without the authors' consent. In the author's view, Dokploy therefore is not fully open-source software and falls into the category of "source available." The author considers this a significant drawback. He proposes distributing these features under the AGPL v3 license, which protects the authors' intellectual property and removes ambiguity for self-hosting.

The author noted that for some users, the license will be the main factor in choosing Coolify. The author considers his own choice of Dokploy a compromise, since, in his assessment, Dokploy offers a better production experience.

Final Result

CategoryWinnerCoolify PointsDokploy Points
Ease of installation and setupDokploy01
Resource consumptionDokploy01
Resource structureCoolify10
UI/UXDokploy01
Application deploymentTie11
DatabasesTie11
Feature setDokploy01
LicenseCoolify10
Total46

Dokploy received an additional point for its feature set, since the author believes it offers more features for production environments. Coolify received a point for its license.

According to the author, the final choice was determined by his personal priorities. The main factor was the user interface. The author believes that the interface is what holds Coolify back, although the platform itself remains a strong product. The scores may differ for users who care about Cloudflare Tunnels or other features available in Coolify.

The author noted that the assessment reflects the current state of the platforms. The Coolify developers have released version 4 with UI/UX improvements. Dokploy may receive changes to its license. The author also acknowledges the possibility of developing his own platform.

Introduction

The author explains why they chose Dokploy and clarifies that Coolify was one of the main competitors.

  • The author uses Dokploy to deploy most production services on VPS instead of their previous setup on Docker Stack.
  • In the previous video, Coolify was one of the main contenders, but the reasons for choosing Dokploy were not disclosed.
  • The most frequent question in the comments to the previous video was why Coolify was not chosen.

Platform Overview

Both platforms are open-source, self-hosted PaaS solutions, unlike the proprietary Vercel, Netlify, and Railway.

  • Coolify and Dokploy are platforms as a service (PaaS) that let you deploy, manage, and scale applications without working directly with infrastructure.
  • Popular proprietary PaaS options: Vercel, Netlify, and Railway.
  • A self-hosted approach gives full control over infrastructure and data, the ability to deploy on a VPS or your own hardware, and predictable long-term costs.
  • Serverless platforms such as Vercel can produce unexpected bills.
  • There are no restrictions on languages or frameworks, and migration is possible without vendor lock-in.

Coolify and Dokploy: Technologies

Coolify was created by Andras Bachai and uses PHP/Laravel and Docker; Dokploy was created by Mauricio Su with Next.js and Docker.

  • Coolify was created by Andras Bachai, the project started in 2022, and he has worked on it full-time since mid-2023.
  • Coolify is written in PHP (Laravel) and uses Docker for building and deployment.
  • Coolify has more than 12,000 commits on GitHub since February 2022 and more than 44,000 stars.
  • Dokploy was started in April 2024 by developer Mauricio Su, with more than 4,000 commits and 24,000 stars.
  • The Dokploy web application is built with Next.js and TypeScript packages such as better-auth and sonner.
  • The author chooses platforms whose stack they understand better, since they contribute to them.

Preparing the VPS

For testing, the author uses two Hostinger KVM2 VPS instances running Ubuntu LTS, configured from scratch.

  • Hostinger KVM2: 2 vCPU, 100 GB SSD, 8 GB memory, 8 TB of traffic per month.
  • The KVM2 costs $6.99 per month on a 24-month term; the promo code dreams of code gives an additional 10% discount.
  • The author installs Ubuntu LTS, sets up SSH keys, a root password, Tailscale, and a firewall that closes public SSH.
  • DNS records pointing to each instance's IP are configured for every VPS.

Installation and Setup

Both platforms install with a single command; Coolify shows the process in more detail, but it ran into an SSH problem with the firewall closed.

  • Both platforms install in a few minutes with a single command.
  • Coolify shows more information about installation steps and includes jokes about dads.
  • Admin access is over HTTP; the author connects via Tailscale, and the data is encrypted with WireGuard.
  • Coolify could not connect the local server because it could not connect to itself over SSH due to the public SSH ban.
  • Solution: a rule that blocks SSH on the eth0 interface and allows the 10.0.0.0/8 subnet for Docker networks.
  • Dokploy worked right after installation without any additional configuration.
  • Winner for ease of setup — Dokploy; for installation, Coolify is better.

Resource Usage

Dokploy consumes significantly less CPU at idle; memory usage of both platforms is around 1 GB.

  • Memory of both platforms is around 1 GB at idle.
  • Dokploy's CPU at idle is 0.8–1.5%, while Coolify's is 6–7% without running services.
  • Coolify's load increased after launching services and enabling metrics, reaching 25% at peak.
  • Testing on several VPSs confirmed that Coolify uses more CPU at idle.
  • The category winner is Dokploy.

Resource Structure

Coolify uses organizations, projects, environments, and resources; Dokploy uses teams, projects, and services without environments.

  • Coolify has teams, and servers are tied to teams; in Dokploy, any team has access to any server.
  • Coolify supports environments within a project, with production as the default.
  • Dokploy has no environments, but they can be simulated with dev and prod projects.
  • Shared variables in Coolify are defined for a project or an environment; in Dokploy, only for a project.
  • The category winner is Coolify.

UI and UX

According to the author, Dokploy is more convenient and consistent in its interface; Coolify has inconsistent saving behavior and intrusive banners.

  • Dokploy is built on Next.js and feels like an SPA, which makes it respond faster.
  • In Coolify, save buttons are located next to section headings, some fields save automatically, and the rest require a button press.
  • In Dokploy, the save button is located at the bottom of the section and saves all changes in that section.
  • In Coolify, the browser keeps prompting to save a password when navigating away from pages with password fields.
  • The Coolify support banner appears on every navigation, blocks the bottom part of the page, and returns after a month; it can be disabled in settings.
  • The winner of this category is Dokploy.

Application Deployment

Both platforms support deployment from Git, Docker images and Docker Compose, and templates; Dokploy supports more Git providers and builders. Tie.

  • Both platforms deploy from Git repositories, Docker images and Docker Compose, and offer templates.
  • Dokploy supports GitLab and Bitbucket, while Coolify mainly supports GitHub.
  • Dokploy supports Nixpacks, Railpack, Heroku buildpacks and Paketo buildpacks; Coolify supports Nixpacks.
  • Dokploy offers deployment via an AI assistant connected to an LLM.
  • Result: a tie, one point to each platform.

Databases

Both platforms can set up scheduled backups to S3-compatible storage. Dokploy is more flexible in choosing the database image and also backs up volumes. A tie.

  • Both platforms support scheduled database backups to S3-compatible storage.
  • In Coolify you can only choose a tag of the base image; in Dokploy, any image.
  • Coolify supports Postgres, MySQL, Redis, MariaDB, MongoDB, as well as Dragonfly, KeyDB, and ClickHouse.
  • Dragonfly is available in Dokploy as a template; volume backups exist only in Dokploy.
  • The author uses Neon for Postgres and does not deploy databases on the platform.
  • Verdict: a tie, one point each.

Additional Features

Both platforms support preview deployments, but they differ in variable handling, API, notifications, and building on a separate server.

  • A preview deployment is created on a pull request, allowing changes to be checked before merging.
  • Coolify automatically copies environment variables; in Dokploy they must be set again manually.
  • There is no dynamic per-preview variable configuration via API for a separate deployment; the API allows updating variables for all previews.
  • The author would like to trigger previews via API or webhook; in Dokploy this is an open issue.
  • The author creates a Neon database branch via API before the preview deployment.
  • Both have an API and CLI, but Coolify's CLI does not support all API operations.
  • Coolify supports Pushover (paid per device), Dokploy supports Gotify (automation, an open-source analogue of AWS SQS).
  • Both support Slack, Telegram, Discord, and SMTP; Coolify additionally supports Resend.
  • Coolify allows dedicating a server only for building; Dokploy does not, and the issue is open.
  • Both support multi-server setups and Docker Swarm clustering; Coolify's Swarm support is experimental.
  • Scheduled tasks (cron) are available in both; Dokploy can run a bash script on the machine.
  • Metrics: in Dokploy they are enabled by default, in Coolify they must be enabled manually; Dokploy metrics can be sent to Gotify for automation.
  • Coolify Sentinel does not show disk usage; the author found a way to send disk alerts.
  • Volume backups are available only in Dokploy.
  • Traffic configuration: in Dokploy it is in the Advanced tab; in Coolify it uses proxy and container labels, which the author prefers.

Licensing and Cloudflare Tunnels

Coolify has built-in support for Cloudflare Tunnels and a fully open Apache 2.0 license, whereas Dokploy is partially closed and is described as source-available.

  • Coolify supports Cloudflare Tunnels out of the box, which is useful for a homelab without port forwarding.
  • Dokploy also works with Cloudflare Tunnel, and there is a template for it.
  • Coolify is fully open source under Apache 2.0.
  • Dokploy is under Apache 2.0, but some code (compose templates, multinode, schedules, preview deployments, multi-server) cannot be sold as a service without the authors' consent.
  • The author would like to see these features under AGPL v3.
  • The author considers Dokploy's license a significant drawback, but Dokploy is better for his production tasks.

Final Score and Conclusions

Final score: Dokploy — 6 points, Coolify — 4. The choice depends on personal preferences and needs.

  • Dokploy earned an extra point for its feature set.
  • Coolify earned a point for licensing.
  • Final score: Coolify 4, Dokploy 6.
  • The interface was the decisive factor; Coolify's UI is its main drawback.
  • In Coolify 4.0, the developers improved the UI/UX.