Introduction
For many small and medium-sized businesses, the cost of running workloads on hyperscalers can be too high, while data sovereignity and control remain non-negotiable priorities - this is especially true for the finance and health-care industry in Switzerland.
At the same time, operating a full Kubernetes cluster—even with a managed control plane—brings more overhead than most teams can justify. Not everybody is running a fully-fledged micro-service application that needs global scaling capabilities.
Integrating a PaaS platform like Azure App Service into your CICD toolchain often adds unncessary complexity and feels more suited for large enterprises than for SMB needs. It doesn't provide the unified Developer Experience (DX) you might be looking for.
If you've been nodding throughout these first paragraphes, and you are looking for a self-hostable alternative to services like Heroku, Vercel, Netliy, Azure App Service, etc. than this article is for you.
I'll compare CapRover, Coolify and Dokploy, three off-the-shelf Internal Developer Platforms, that make it simple for your team to deploy and manage applications and databases with simple effort.
I've deployed and tested these platforms on a VPS running Ubuntu 24.04 As of writing the latest versions where CapRover 1.14.0, Coolify v4.0.0-beta.431, and DokPloy v0.25.4. All solutions are based on Docker & Docker Swarm.
These are the aspects I had a closer look at
- Maturity & community support
- Installation, upgrading & maintenance
- Docker Compose & Docker Swarm support
- API & CLI
- Multi server setup & clustering
- Domain name management & automatic HTTPs support (ACME)
- User, Teams & Permission Management
- Git Push Deployments with GitHub
- Logging, Monitoring & Notifications
- Backup capabilities of platform configuration & volumes
- Multi environment support (PROD, STAGING, DEV, ...)
- Preview deployments
Let's start with an overview describing CapRover, Coolify and Dokploy.
A brief description of the projects
CapRover
CapRover claims to be an extremely easy to use app/database deployment & web server manager for your Node.js, Python, PHP, ASP.NET, Ruby, MySQL, MongoDB, Postgres, WordPress, ... applications.
It's blazingly fast and very robust as it uses Docker, nginx, LetsEncrypt and NetData under the hood behind its simple-to-use interface.
Coolify
The platform carries the claim of "self-hosting with superpowers". An open-source & self-hostable alternative to Vercel, Heroku, Netlify and Railway for easily deploying websites, databases, web applications and 280+ one-click services to your own server.
Dokploy
The web dsite states "Dokploy is a stable, easy-to-use deployment solution designed to simplify the application management process. Think of Dokploy as a free alternative self-hostable solution to platforms like Heroku, Vercel, and Netlify."
Maturity & community support
When deciding for a critical platform solution, we don't want to be left without community support.
So, to get an understanding of how active a GitHub project is, I usually glance at the last commit date, and compare other metrics, e.g. amount of sponsors, stars, repo creation timestamp (created_at) and the number of contributors.
Of course, this is only a high-level view on the activness of a project, but still provides some sense on how mature and allive a code base is.
Here are the numbers.
| Coolify | CapRover | Dokploy | |
|---|---|---|---|
| Contributors | 474 | 65 | 211 |
| Stars | 45.4k | 14.5k | 24.8k |
| Repo created at | 2021-01-25 | 2017-10-25 | 2024-04-19 |
| Sponsors | 34+ | 137 | 50+ |
| Downloads | 100K+ | 100M+ | 1M+ |
Installation, upgrading & maintenance
CapRover
Before installing CapRover, you need to manually set up Docker CE, which is a straightforward process. Next, you need to create a wildcard domain, e.g. *.mydomain.com, and install the CLI tool on your developer machine via npm. Once prepared, installation is as simple as running a single docker run command via SSH.
Since CapRover itself runs in a container, in-place upgrades are easy and can be triggered directly from the Web UI. According to the documentation, upgrades cause only a brief interruption of running apps.
CapRover also provides scheduled Docker cleanup tasks, helping keep disk usage under control.
Coolify
To install Coolify, start with a fresh VPS with at least 2 GB RAM and 2 cores, and run the installation script — Docker CE will be installed automatically. After the first login, a user account is created and a setup wizard guides you through the initial configuration.
Coolify supports automatic (scheduleable) and manual updating. A test upgrade from v4.0.0-beta.431 to v4.0.0-beta.432 when smoothly without any interruption.
Another nice feature is that it allows you to patch your servers straight from the Coolify UI (running e.g. apt update , currently experimental)
It also includes a scheduled Docker cleanup feature that is capable of:
- Removing stopped containers managed by Coolify
- Deleting unused images
- Clearing the build cache
- Removing old Coolify helper images
- Optionally removing stale volumes and networks
Dokploy
To set up Dokploy, your VPS should have at least 2 GB RAM and 30 GB disk space. Installation is very simple: just run the script provided in the documentation. It will automatically install Docker CE. After the first login, a user account is created.
Upgrades are handled via a short shell script, though the documentation does not clarify whether they cause downtime.
In addition to scheduled Docker cleanup tasks, Dokploy also supports running custom scripts on a cron-based schedule.
Docker Compose & Docker Swarm support
CapRover
Since CapRover uses a custom format for it's deployments (captain files/one-click templates), it provides only limited Docker Compose support. Only a subselection of Docker Compose parameters can be used.
Coolify
The platform fully supports native Docker Compose syntax and displays environment variables from the Compose file directly in the Web UI.
You can create Docker Compose based Resources either from a public or a private repositoriy. Coolify also allows copying and pasting Docker Compose definitions into a text field.
I liked that in all cases the Docker Compose file serves as the single source of truth, ensuring no unexpected side effects. At the time of writing I encountered a validation logic bug documented here.
kevincam3
Coolify supports an experimental Docker Swarm mode: you register a Swarm manager (and optionally workers) with Coolify, allowing it to coordinate deployments across nodes.
In this setup, your Swarm must use an external container registry so that all worker nodes can pull the images the manager builds.
Dokploy
Integrates well with Docker Compose and Docker Stack. You can point to a public Git Repo holding a docker-compose.yaml or pull a definition from your private GitHub repo. Alternatively, you can input raw compose definitions into a text field. Feels mature and well integrated.
API & CLI
CapRover
CapRover does not directly expose an API, but it provides experimental API access through the CLI command caprover api. The JavaScript-based CLI allows you to:
- Perform actions to prepare CapRover on a server
- Deploy your app to a specific CapRover machine
- Call a generic API (experimental)
Coolify
It provides an API secured by a Bearer token, which can be generated from the UI and supports different permission levels such as root, write, deploy, read, and read:sensitive. However, it does not include a CLI.
Dokploy
Dokploy exposes a feature-rich API secured with JWT authentication, where API keys can be scoped by organizations. Rate limiting is supported, and a Swagger interface is available. It doesn't provide granular token or API permissions.
In addition Dokploy provides a JavaScript-based CLI-tool via npm, that allows you to create, deploy and manage applications, databases, environments and projects.
Multi server setup & clustering
CapRover
This platform supports clustering through Docker Swarm, though it also requires the use of an external container registry. Nodes can be joined to the swarm as either workers or managers via the UI, which involves generating SSH keys, but in my experience it was simpler to add nodes manually.
One limitation is that the documentation lags behind, making some steps less straightforward than they should be.
Coolify
Coolify allows deploying the same application to multiple servers. You can add a load balancer in front of them to enable HA scenarios (requires manual setup). This feature is currently marked as experimental.
You can also add a dedicated build server to offload the build process from the machine actually hosting the applications. This keeps the load separated, so it doesn't affect the applications performance. This feature requires a container registry where the build server can push his images to.
Dokploy
When installing Dokploy on a single VPS, the same server handles application builds, hosts the applications, and serves the management UI simultaneously. This doesn't scale well for larger setups, why Dokploy supports a multi server setup.
With the multi-server setup, you can separate the management UI from building & hosting. The integration is straight forward, and can be carried out mostly from the UI (besides adding the public SSH key). You won't need an additional container registry.
After successful setup, you can select a server when creating a new service.
I didn't find a way to further separate building from hosting with the multi-server feature.
But Dokploy also offers a clustering feature. The idea of using clusters is to allow each server to host a different application and, using Traefik along with the load balancer, redirect the traffic from the dokploy server to the servers you choose. The reverse proxy remains on the manager node.
It allows to deploy multiple replicas of an application and distribute them across worker nodes (Docker Stack and Applications only, doesn't work for Compose).
For this setup to work, a container registry is required, and ideally the Docker Swarm nodes should communicate over a private network with each other.
For high-availability, you can scale Traefik to multiple replicas and use an external load balancer for that (not tested, maybe for another article)
Domain name management & automatic HTTPs
CapRover
By default every new deployed application is reachable under the wildcard domain, that got created prior installation (e.g. my-app.subdomain.domain.tld). New domains can be bound and configured from within the UI. CapRover comes with builtin support for Let's Encrypt and supports HTTP to HTTPS redirection.
Coolify
The platform supports configuring wildcard domains, e.g. *.example.com. This allows you to use generated domain names for each application under that domain, e.g. my-app.example.com.
If you don't configure a wildcard domain, the domain auto-generation process will generate domain names under the service/domain sslip.io for quick access & testing. But of course you can also set a custom domain www.somethingelse.com
Coolify also supports automatic redirection of e.g. example.com to www.example.com and allows enforcing HTTPs
Dokploy
Dokploy provides two ways to add domains, free domains and domains you bought. Free domains are provided by traefik.me but are limited to HTTP only.
The UI also supports uploading your own x509 certificates, this can also be used to enable HTTPs for traefik.me . It further supports automatic SSL certificate provisioning via Let's Encrypt (ACME). You can also use other custom certificate providers
User, Teams & Permission Management
CapRover
It offers a Pro plan that includes two-factor authentication, but otherwise only supports single-user mode.
Coolify
Coolify supports creating multiple teams (though this feature did not work in my test with version v4.0.0-beta.431), inviting new users, and assigning them one of three roles: admin, owner, or member. Additionally, it offers two-factor authentication for logins.
Dokploy
It allows organizing resources by organizations and supports two-factor authentication. New members can be invited, though in the self-hosted version this requires manually sharing the invitation link, while in the cloud version it works directly. See this issue for further details.
Invitations are scoped to organizations, meaning users only gain access to resources within the org they are invited to, unless they receive separate invitations for additional orgs.
Currently, only one admin role is allowed per instance, but multiple permission levels are available to manage users effectively.
Git Push Deployment with GitHub
CapCover
It supports push-based deployments by configuring a webhook in your repository that triggers on a branch push. Once CapRover receives the webhook call, it pulls the code, builds it, and deploys it automatically, though the UI for this feature appears limited.
Coolify
Supports automatic deployments on commits and pull requests, working with both public and private repositories. For private repos, integration is possible via either a GitHub App or deploy keys. When using the GitHub App, enabling auto-deploy is as simple as ticking the Auto Deploy box in the resource configuration.
Dokploy
Automatic deployment can be set up using either webhooks or the Dokploy API, though this is limited to Applications and Docker Compose.
For GitHub, autodeploy works out of the box with no additional configuration, and once Git integration is complete, you only need to set the trigger type on the application provider.
Logging, Monitoring & Notifications
CapRover
It provides a monitoring dashboard and a server-side Nginx log analyzer, with metrics powered by Netdata (though only available on the leader node).
Logs can be viewed per app, but the functionality is quite limited. Notifications are handled through the Netdata module, supporting delivery via email, Slack, Telegram, and Pushbullet.
Coolify
Notifications can be triggered for deployments, backups, scheduled tasks, and server events such as cleanups or disk usage.
They can be sent via email, Discord, Telegram, Slack, or Pushover, and logs can also be drained to third-party applications like Axiom and New Relic.
Dokploy
It provides basic graphs for CPU, memory, and disk usage, along with notifications for events such as app deployments, build errors, database backups, Docker cleanup tasks, and Dokploy restarts.
Notifications can be sent through Slack, Telegram, Discord, email, Gotify, or ntfy, but external log drains are not supported.
Configuration Backup & Volume Backup
CapRover
Backup and restore functionality is still experimental. While it works for most resources, images require using a Docker registry and volumes need a custom solution—both approaches having their own pros and cons..
Coolify
Coolify offers two ways to back up the instance itself: automatic backups to S3 storage or manual backups triggered on demand. However, it does not provide an automatic or UI-integrated solution for backing up and restoring volumes, though the documentation offers clear guidance on how to handle this manually.
Dokploy
Dokploy supports configuration backups to an S3 destination, covering the entire file system and database, with the option to schedule them regularly.
It also provides integrated database backups and supports volume backups for applications and Docker Compose. Named Docker volumes can be selected from a list and backed up to S3, with the option to temporarily stop containers during the process to avoid file locks or corruption, making it a very convenient solution.
Multi environment support
CapRover
Doesn't support environments
Coolify
It supports three types of shared variables: team-based, project-based, and environment-based (such as prod, staging, or dev). However, environment-level variables were unclear in usage, and team-based variables did not work in testing.
Dokploy
You can configure environment variables at different scopes: project-wide variables that apply to all applications, environment-level variables limited to a specific environment, and application-scoped variables that affect only a single application.
Preview Deployments
CapRover
Doesn't support preview deployments
Coolify
It offers a great way to test applications before merging into the main branch by creating preview deployments that act like a staging environment.
Preview URLs can be templated with identifiers such as the pull request ID (e.g., PR 123 becomes 123.example.com). Automated preview deployments can also be enabled, making each new pull request instantly available at its own preview URL by simply ticking Preview Deployments under Configuration → Advanced.
Dokploy
Preview deployments only work with applications sourced from GitHub and linked via a GitHub App, and they should be used exclusively with private repositories to prevent external users from triggering builds and deployments.
You can limit the number of preview deployments per application, use either auto-generated or custom domains, and apply label filters to control which pull requests trigger a preview deployment.
Verdict
A key capability missing across all three platforms is robust observability integration.
CapRover
I found that CapRover lacks in documentation. I also found its UI quite basic and sometimes buggy. E.g. when I removed a worker node from the Swarm, the UI was not updating. Also the featureset is quite limited compared to the Coolify & Dokploy.
Besides that it still a respected and widely used solution according to high download metric of 100M+ on Docker Hub.
Coolify
I found the UX sometimes a bit difficult to understand intuitively, e.g. when looking for the HTTPs settings. Also when create new applications which are sourced via a private Git repositoriy, it would be nice to have search function since the list of repos can get long. Also having backup support for volumes would be aweseome to have.
Other than that, the platform is quite mature with a lot of features at hand. I liked the multi-server setup to horizontally scale the installation. Also the documentation is in a very good shape!
Dokploy
Although being the youngest of these three projects, Dokploy is my personal favorite.
I find it a feature-rich PaaS platform with a pretty good documentation. Installation is dead simple and it provides full Docker Compose support. The UX is well designed and I liked the support for multiple organizations allowing for clear separation between stacks. A highlight is the nicely integrated backup feature allowing for scheduled backups of volumes, databases and configuration.
Further reading
