Coolify vs Dokploy vs CapRover: Self-Hosted PaaS on a VPS (2026)

If you have ever stared at a Railway or Render invoice and thought "I could run this myself for the price of a coffee," you are exactly the person these three tools were built for. Coolify, Dokploy and CapRover all promise the same thing: a Heroku-style deploy button on a server you own. Push your code, get a URL, automatic SSL, a managed database next to it. No per-seat pricing, no usage-based surprises.

But "they do the same thing" is where most comparison posts stop, and that is useless when you actually have to pick one. So I did the boring part: I provisioned a clean 4 GB Hetzner CX22 VPS and installed each one in turn, deploying the same small Laravel + Postgres + Redis stack on each. This is what I found, what broke, and which one I now install by reflex.

The 30-second answer

If you do not want to read 2,500 words: pick Coolify if you want the most features and the biggest service catalog and you have at least 2 GB of RAM to spare for the panel itself. Pick Dokploy if you run multi-container apps from a docker-compose.yml and you want the lightest, fastest panel. Pick CapRover only if you value a battle-tested, boring tool from 2017 and your apps are single-container with one-click templates.

Everything below is the reasoning behind that, with the real numbers I measured.

What a self-hosted PaaS actually replaces

Across the 7 aggregator sites I run on a mix of Hostinger shared hosting and VPS boxes, the deploy story has always been the messy part. FTP for the cheap sites, hand-rolled SSH + git pull scripts for the bigger ones, and a tangle of cron jobs I have to remember exist. A self-hosted PaaS collapses all of that into one dashboard that handles the four things you would otherwise script by hand:

• Build — clone from GitHub/GitLab, build a Docker image (Nixpacks, Buildpacks, or your own Dockerfile).
• Route — a reverse proxy (Traefik, Caddy or nginx) that maps your domain to the container.
• TLS — automatic Let's Encrypt certificates and renewal.
• Data — one-click Postgres, MySQL, Redis, MongoDB next to your app, with backups.

That is the category. Now the contenders.

Quick comparison table

Coolify: the maximalist

Coolify is the one everybody has heard of, and v4.0 finally shipped as a stable release in early 2026 after roughly a year of beta cycles (the last betas were in the v4.0.0-beta.43x range, which tells you how long the road was). The headline additions in v4 are a built-in MCP server, a redesigned dashboard, and a service catalog that crossed 280+ one-click apps.

What I like: the catalog is genuinely huge. If there is a popular open-source tool, Coolify almost certainly has a template for it. The multi-server management is the most mature of the three — you can register servers from different providers and manage them all from one panel, which matters once you outgrow a single box. The GitHub App integration for auto-deploy-on-push is the smoothest of the three.

What stung: idle RAM. On my CX22, Coolify's own stack (the panel, its database, its Redis, the proxy) sat at roughly 500–700 MB before I deployed a single application, and I measured idle CPU bouncing around 6% even with nothing happening. On a 2 GB server that leaves you about 1.3–1.5 GB for actual apps, which goes fast once you add a Postgres and a worker. Coolify is not the tool to put on a $4/month 1 GB VPS — it will technically install and then thrash.

Dokploy: the lightweight that grew up fast

Dokploy is the newcomer (first releases in 2024, sitting around v0.25.x by mid-2026) and it is the one that surprised me most. It is built on Docker Swarm for orchestration and Traefik for routing, and the architectural decision that pays off daily is native, first-class Docker Compose support.

This is the real differentiator. My test app was a Laravel API + Postgres + Redis + a queue worker — four services. In Dokploy I pasted my existing docker-compose.yml, pointed it at the repo, and it brought up the whole stack with the networking and dependencies intact. In CapRover I would have had to deploy each service as a separate "app" and lose Compose's networking model entirely. That difference alone decides the tool for a lot of real-world projects.

On resources Dokploy is the efficiency winner among the feature-rich options: roughly 350 MB idle RAM and a measured 0.8% idle CPU, versus Coolify's 6%+. On the same 2 GB server that is closer to 1.6–1.7 GB left for your apps. The service catalog is smaller (80–100 templates) but I rarely use one-click templates anyway — I bring my own Compose file.

The honest caveat: Dokploy is young. Some edges are rough, the docs occasionally lag the release, and the multi-server story (Swarm worker nodes) works but is less polished than Coolify's cross-provider management.

CapRover: the dependable veteran

CapRover has been around since 2017 and it shows — in both good and bad ways. Good: it is the most mature and stable of the three, the setup is straightforward, and it has a large library of one-click app templates that mostly just work. If your workload is "one container, one database, done," CapRover will run for years without you thinking about it.

Bad: Docker Compose support is the weak point. CapRover is fundamentally oriented around single-container apps and templates. Multi-service stacks force you into separate apps or custom workarounds outside CapRover's management, which defeats much of the point in 2026. The UI feels dated next to Coolify v4 and Dokploy, and the development pace has visibly slowed — v1.14.x is solid but the gap between releases has widened.

It is the lightest on resources (you can squeeze it onto a 1 GB box if you are careful), which keeps it relevant for tiny single-app deployments where Coolify would be overkill.

How I tested this

I want to be specific about the setup so you can weigh the numbers, because "it's fast" with no methodology is worthless. The box was a Hetzner CX22: 2 vCPU (shared), 4 GB RAM, 40 GB NVMe, Ubuntu 24.04 LTS, in the Nuremberg region. For each tool I started from a freshly reimaged server, ran the official one-line installer, waited for the panel to settle for 10 minutes, then read idle RAM and CPU off docker stats and free -m before deploying anything. Then I deployed the same reference app — a Laravel 11 API with a Postgres 16 database, a Redis 7 cache, and a single queue worker — and measured again.

That reference app matters because it is deliberately mundane. It is the shape of maybe 60% of the projects I have shipped across 50+ builds: a web framework, a relational database, a cache, and a background worker. If a panel makes that easy, it makes most real work easy. If it fights you on that, no amount of one-click templates saves it.

I am not pretending this is a lab-grade benchmark with statistical runs. It is a practitioner's smoke test on the exact tier most readers will actually rent. Numbers will shift on different hardware, kernels and tool versions — treat them as ratios between the three tools, not absolute guarantees.

Reverse proxy, TLS and the parts that bite later

All three give you automatic Let's Encrypt certificates, but the proxy underneath differs and that surfaces the day you need something non-default. Dokploy and CapRover both lean on Docker Swarm; Dokploy fronts it with Traefik while CapRover uses nginx. Coolify uses Traefik by default (with a Caddy option) and can run without Swarm at all on a single node.

Why care? Because the moment you need a custom header, a websocket upgrade, a path-based route, or a wildcard certificate, you are editing that proxy's config — and the three expose it very differently. Coolify gives you the most direct access to custom Traefik labels through the UI. Dokploy exposes Traefik configuration cleanly too and its Swarm model makes rolling updates and zero-downtime restarts the default behavior. CapRover's nginx config is editable but the templating is its own dialect you have to learn. In my experience the Traefik-based tools (Coolify, Dokploy) are easier to reason about once you already know Traefik, which is increasingly the default proxy in the self-hosted world.

One concrete gotcha I hit: on the first Dokploy deploy, the queue worker container kept restarting because the Swarm health check was stricter than my local Compose run. The fix was a five-minute edit to the healthcheck interval, but it is the kind of thing that does not happen on a single-container CapRover app. More power, more surface area to get wrong.

Backups and disaster recovery — do not skip this

This is where I have the strongest opinion, formed the hard way running daily imports of 100–200 records across 7 sites: the panel is not your backup strategy. All three offer scheduled database backups to S3-compatible storage, and you should absolutely configure them — Coolify and Dokploy both make this a few clicks to point at an S3/R2/B2 bucket. But the dashboard lives on the same VPS as your data. If the disk fails or the provider has a bad day, an on-box backup dies with the server.

My rule across every project: backups go to an off-box bucket (I use Cloudflare R2 and Backblaze B2), and I test a restore at least once before I trust it. I have seen too many "we had backups" stories where the backups were on the same dead machine. Configure the panel's S3 backup, point it off-box, and verify you can actually pull a dump down and re-import it. A backup you have never restored is a hope, not a backup.

The benchmark I actually care about: idle overhead

Here is the practical math that nobody puts in the marketing pages. On a 2 GB VPS — the most common cheap tier on Hetzner, Contabo and DigitalOcean — your usable application RAM after the panel is:

• CapRover: ~1.65–1.75 GB free
• Dokploy: ~1.6–1.7 GB free
• Coolify: ~1.3–1.5 GB free

That 200–400 MB delta sounds trivial until your app is a PHP-FPM pool plus a Postgres with a reasonable shared_buffers plus a Redis. In my experience running production databases at scale, the panel's overhead is the difference between a server that breathes and one that starts swapping under the first traffic spike. If you are on a 2 GB box and you intend to actually use it, the lighter panel buys you real headroom.

Decision matrix

What I actually run

After the side-by-side, my default reach is now Dokploy for new projects — specifically because the apps I ship (Laravel + Vue, occasionally Next.js) are multi-service and I already maintain Compose files for local development. Reusing the exact same docker-compose.yml in production removes a whole class of "works on my machine" drift. The low idle overhead is a bonus that lets me run it comfortably on a 2 GB box.

I keep Coolify on a beefier 8 GB VPS where I host a cluster of small internal tools, because the 280+ template catalog and multi-server view genuinely save me time there, and the RAM cost is irrelevant on that box. I would not put a new CapRover install in front of a fresh project today, but I respect that the existing CapRover deployments I have seen just keep running, which is worth a lot.

One operational warning that applies to all three: a self-hosted PaaS puts your control plane on the same box as your apps. If the VPS goes down, so does your deploy dashboard. Keep your reverse-proxy config and database backups exported off-box. I learned to treat the panel as convenience, not as the source of truth — the source of truth is the git repo and the backup bucket.

Frequently asked questions

Is Coolify or Dokploy free?

Both are free to self-host under a source-available license. Each also offers a managed cloud control plane for roughly $4.50 per connected server if you would rather not run the panel yourself. CapRover is free under Apache 2.0 with no paid cloud tier.

Can I run any of these on a $5 VPS?

CapRover and Dokploy will run on a 1–2 GB server with room left for a small app. Coolify technically installs on 2 GB but the panel's 500–700 MB idle footprint leaves little headroom; give it 4 GB if you can.

Which one handles multi-container apps best?

Dokploy, clearly. Its native Docker Compose support lets you deploy an entire multi-service stack from one file with networking and dependencies preserved. CapRover treats each service as a separate app, and Coolify supports Compose but Dokploy makes it the default path.

Do I still need Docker knowledge?

For basic deploys, no — the UI handles builds and routing. But the moment something breaks, all three drop you to Docker and Traefik/nginx logs, so a working understanding of containers and reverse proxies pays off fast.

Can I migrate between them later?

Yes, and it is not painful if your apps are defined in a Dockerfile or docker-compose.yml that lives in your repo. The panel is just orchestration — your build definition is portable. This is the strongest argument for keeping a clean Compose file regardless of which panel you choose.

Do these work with GitHub private repos?

All three support private repositories. Coolify's GitHub App integration is the smoothest — install the app once and it can list and auto-deploy any repo you grant it. Dokploy supports GitHub, GitLab, Bitbucket and Gitea via app tokens or deploy keys. CapRover leans on webhooks and a deploy token, which works but feels more manual than the other two.

What about non-Docker apps?

All three build a container for you even if you never wrote a Dockerfile, using buildpacks or Nixpacks to autodetect Node, PHP, Python, Go and friends. It works for standard apps, but the moment you need a system library or a specific runtime version, writing your own Dockerfile is more predictable than fighting the autodetector.

Bottom line

These three tools occupy the same category but they are not interchangeable. Dokploy wins on Docker Compose and efficiency, Coolify wins on catalog size and multi-server maturity, and CapRover wins on sheer stability for simple single-container workloads. Match the tool to the shape of your app and the size of your VPS, keep your backups off-box, and you can leave Railway-tier invoices behind for the cost of a small server.

Sources and version data drawn from the official Dokploy comparison docs and 2026 platform reviews; resource numbers are from my own install tests on a Hetzner CX22 (4 GB / 2 vCPU). Measure on your own hardware before committing.