Self-Hosted PaaS in 2026: Coolify, Dokploy, Dokku, CapRover, Kamal and Ployz Compared

All six self-hosted PaaS tools in this comparison are free on your own server: Coolify, Dokploy, Dokku, CapRover, Kamal and Ployz. What you pay for is the server, about $7 to $10 a month for a 4 GB VPS at Netcup or Hetzner. The optional extras are small: Coolify Cloud is $5 a month, Dokploy Cloud $4.50 per server, and Dokku's official web UI is $849 once.

Since price won't decide it, the real question is what each tool does when you add a second server, whether it runs your Docker Compose file, whether it backs up your database, and whether you get a dashboard or a config file.

Facts checked 2026-10-01 on each project's own pricing page, docs and GitHub repo, linked next to each claim. I haven't run these six side by side for this article, so you won't find install times or idle RAM numbers from me. Where a limit comes from a project's docs, I quote it.

I build Ployz, one of the six, so read my opinions with that in mind. Coolify and Dokploy beat it on several things that matter, and I'll say where.

How do the self-hosted PaaS options compare?

"Multi-server" here means your apps can run across more than one machine, not only that one dashboard can see several servers. Stars and latest release are from GitHub on 1 October 2026.

Every one of them is actively maintained. The oldest latest release is Kamal's from June, and Kamal is also the smallest, so there's less to change.

What is a self-hosted PaaS?

A self-hosted PaaS is software you install on a server you rent, so you get Heroku- or Vercel-style deploys without paying a platform for compute. You push code, it builds a container, puts it behind HTTPS and restarts it when you push again. You keep the server bill and the work of running the server; the platform markup goes away.

The hosted platforms bundle three things: the deploy workflow, the compute and the support. A self-hosted PaaS gives you the first one and leaves you the other two. That's the whole trade. On a hosted platform you pay for each service, seat and gigabyte, which I broke down fee by fee in the hidden costs of PaaS. On your own server you pay one flat price for the machine and run as much on it as fits.

What the tools don't take off your plate: OS updates, firewall rules, SSH keys, disk space and, for some of them, database backups. None of the six patches your server's operating system for you.

Who should use a self-hosted PaaS?

I think a self-hosted PaaS fits a solo developer or small team running a few web apps, workers and databases, whose hosting bill has grown past the price of a server. It fits less well if you never want to SSH into anything, need someone to call at 3am, or run one tiny static site that a free tier covers.

The bill is what pushes most people here. My first month on Laravel Cloud was about $600. Railway was $500+ a month and climbing, mostly from one busy database. Today one dedicated server at €80 a month runs more than I ever ran on Railway. If your bill looks like that, see what your own platform charges in Railway pricing, Render pricing or Vercel pricing, and compare it with a $7 server.

What does a self-hosted PaaS cost?

The tools cost nothing on your own server. The bill is the server: €8.26 a month incl. VAT for a Netcup VPS 500, or $6.49 plus about $0.60 for IPv4 for a Hetzner CX23 in Europe. Hosted dashboards are optional: Coolify Cloud from $5 a month, Dokploy Cloud from $4.50 per server. Dokku's UI is a one-time $849.

In the US, Netcup's Manassas datacenter costs about €1 more a month; Hetzner's CX line is Europe only.

And the tools on top, on monthly billing:

Both clouds take 20% off for yearly billing. The tools ask for little: Coolify wants 2 GB of RAM (install), Dokploy 2 GB (install), Dokku 1 GB (install). Start on 4 GB so your builds and databases have room.

Single server or multi-server: does it matter?

It matters the day one server isn't enough or you want to replace it. On one server, all six work. Across servers they split: Kamal, CapRover and Ployz spread apps by design, Dokploy does through a Swarm cluster, Coolify runs copies but leaves traffic spreading to you, and Dokku needs Kubernetes (k3s) to go past one box.

The details, from each project's docs:

• Coolify: "Adding deployment servers does not distribute traffic by itself," and attaching servers "does not create a complete highly available system." The multi-server page doesn't support Compose apps, and Coolify blocks a second server when an app has persistent storage (multiple servers). You rent or build the load balancer.
• Dokploy: remote servers each run apps on their own; the cluster mode is Docker Swarm with managers, workers and a registry for images (cluster).
• Dokku: "runs on a single server of your choice" (docs). Its k3s scheduler joins more nodes, at 2 GB per node, which means you're now running Kubernetes.
• CapRover: "Add nodes to your Docker Swarm cluster and let CapRover handle load balancing" (caprover.com).
• Kamal: you list server IPs in deploy.yml and it deploys to all of them.

This is the gap I built Ployz for. I wanted to go from one server to two and retire the old one without Kubernetes, Swarm or a three-server minimum. In Ployz you add a server with one command; it joins an encrypted WireGuard network, services reach each other by private DNS name, and every server runs its own Caddy load balancer, so there's no load balancer to rent. A service can run up to 50 replicas. What it can't do yet is move a database from one server to another. That's coming.

Which self-hosted PaaS runs Docker Compose files?

Coolify and Dokploy run full Compose files, from Git or pasted in, and add proxy labels for you. CapRover's support is partial and experimental. Dokku, Kamal and Ployz don't take Compose files at all. If your app or the open-source tool you want to host already ships as a docker-compose.yml, that narrows it to two.

Two catches, from the docs. Coolify says "Rolling updates are not supported for Docker Compose applications" (rolling updates), so Compose apps restart on deploy. CapRover's Compose "does not implement the complete Compose specification" and ignores fields like build, networks and deploy (docs).

Compose also drives the template catalogs. Dokploy's templates repo had 532 blueprints and Coolify's 386 on 1 October (Dokploy, Coolify). CapRover has "dozens" of one-click apps. Ployz has one-click Postgres, Redis, MySQL and MongoDB and nothing else yet.

Which self-hosted PaaS backs up your database?

Coolify and Dokploy back up databases to S3-compatible storage on a schedule, built in. Dokku does it through its database plugins. CapRover backs up its own settings but not your databases. Kamal and Ployz have no database backups, so you write a pg_dump cron job and send it somewhere off the server.

• Coolify covers Postgres, MySQL, MariaDB, MongoDB and ClickHouse, not Redis (backups), and added volume backups in 4.3.0.
• Dokploy backs up databases and named volumes to S3 (backups), and can back up itself.
• Dokku's official Postgres plugin schedules S3 backups.
• CapRover backs up /captain/data/; for databases it says to use "the proper method of backup for your specific database, like mongodump" (backup docs).
• Kamal runs databases as accessories, which "are not updated when you deploy, and they do not have zero-downtime deployments" (accessories). Backups are yours.

Ployz is plainly behind here. Its one-click databases are regular services with a volume, not managed databases, and Ployz doesn't back them up. Coolify's docs have the line everyone should remember: "A successful backup only proves that Coolify created a file." Test a restore, whichever tool you pick.

Which ones have preview environments?

Coolify, Dokploy and Ployz create a preview environment for each pull request. Coolify works with GitHub, GitLab, Bitbucket and Gitea; Dokploy and Ployz are GitHub only. Dokku can do it through its GitHub Action. CapRover and Kamal have no built-in pull request previews.

Coolify posts the preview address back on the pull request (previews). Dokploy's previews are off by default, and it warns against them on public repos "since external people can execute builds and deployments in your server" (previews). Dokku's GitHub Action creates and destroys review apps. In Ployz each preview gets its own HTTPS address on your servers, previews are unlimited on your own servers, and if you save a preview's settings they ship with the merge.

Which self-hosted PaaS has the best UI?

Coolify and Dokploy have the fullest free dashboards: apps, databases, backups, logs and templates in one place. CapRover's dashboard is simpler. Dokku is a CLI unless you buy Dokku Pro for $849. Kamal has no UI by design. Ployz shows your whole app on one canvas with live status, and dashboard edits are staged and reviewed before they deploy.

The UI also decides who on your team can help. A teammate who never SSHes in can read logs and redeploy from Coolify or Dokploy. Ployz can't invite a teammate yet. With Dokku or Kamal they'd need a terminal and server access.

One difference people miss: self-hosted Coolify, Dokploy, CapRover and Dokku need nothing outside your server. Ployz needs Ployz Cloud, and deploys go through it. You can self-host Ployz Cloud too, but it still uses Ployz's relay and hosted DNS. If Ployz Cloud goes down your servers keep serving, but you can't deploy until it's back. If a fully self-contained dashboard matters to you, that's a point for the others.

How much maintenance does a self-hosted PaaS take?

More than a hosted platform, less than a hand-built server. You still own OS updates, firewall rules and disk space, and you update the PaaS itself. Coolify and Dokploy ship often and have published critical security advisories, so update promptly and keep the dashboard port firewalled. Kamal leaves the least running on your server.

On 1 October, Coolify's GitHub listed 70 security advisories (21 critical) and Dokploy's 60 (34 critical) (Coolify, Dokploy). Most need a logged-in user, but these tools hold root SSH access to your servers, so keep accounts few. Coolify's 4.3.0 also shipped breaking changes to roles and the API (release); read changelogs before you update.

Zero-downtime deploys vary too. Kamal does them out of the box. Coolify waits for a health check except for Compose apps and previews. Dokploy needs a Swarm health check you add per app. In Ployz, once you set a health check, the new version must pass it before the old one stops, and services with a volume (databases) restart instead.

Which licenses should you care about?

Dokku and Kamal are MIT, Coolify is Apache-2.0 throughout. Dokploy is Apache-2.0 except a /proprietary folder (SSO, custom roles, audit logs) that needs a paid agreement in production. CapRover is Apache-2.0 with an appendix asking that changes to free features stay open. Ployz's CLI and server software are Apache-2.0 and its dashboard AGPL-3.0.

For a solo developer none of this changes anything. For a team, it decides where SSO and roles come from: free in Coolify, which has team roles with a read-only Member role (4.3.0), paid in Dokploy (license, pricing). CapRover's terms are in its LICENSE. Ployz has no team roles yet.

Is a self-hosted PaaS a real Heroku or Vercel replacement?

For the deploy workflow, yes: push to Git, get a build, HTTPS and previews. For the rest, no. You won't get a global edge network, managed databases with point-in-time restore, or someone else on call. If your app is a few services and a database, you gain far more in price than you lose.

Dokku is the closest copy of Heroku: git push, a Procfile and buildpacks. For a Vercel-style setup with previews per pull request, Coolify, Dokploy and Ployz are the ones to look at. I compared the hosted options on the same app in the best Vercel alternatives, if you'd rather stay hosted and pay less.

Where does each tool beat Ployz?

To be fair to the others: Coolify and Dokploy both beat Ployz on backups, Compose files, templates and Git providers. Coolify adds free team roles; Dokploy adds scheduled jobs and rollbacks. Dokku has cron built in and backups through plugins. All of them run fully on your server with no outside sign-in. Ployz's differences are multi-server networking, staged edits and previews.

What Ployz does: push to GitHub and it builds on your servers or in your own GitHub Actions, with no Dockerfile needed for Node, Python, Ruby, PHP, Go, Rust, Java and Elixir. ployz up --server root@your-server installs it on a Linux server with systemd and gives your app an HTTPS address. Every command takes --json, and ployz setup agent lets coding agents like Claude Code deploy. No cron, metrics, alerts, team roles, autoscaling or GitLab yet.

Which self-hosted PaaS should you pick?

Pick Coolify if your app is a Compose file, you want hundreds of one-click templates and S3 backups built in, you use GitLab, Bitbucket or Gitea, or you need free team roles. It's the safe default for one or two servers.

Pick Dokploy if you want Coolify's feature set with one app spread across servers through Docker Swarm, and you're fine running a registry and adding health checks per app.

Pick Dokku if you're leaving Heroku with a Procfile app, live in a terminal, and one server is enough.

Pick CapRover if you want a simple dashboard over a Docker Swarm cluster and will handle database backups yourself.

Pick Kamal if your deploy should be a config file in your repo with nothing running on the server but your app.

Pick a hosted platform if you never want to own a server and your app is small enough that the bill stays low.

Pick your own server with Ployz if you deploy from GitHub, want a preview for every pull request and zero-downtime deploys, and want to grow from one server to several without Kubernetes, Swarm or a rented load balancer. Plan your own database backups.

Ployz is free on your own servers: push to GitHub and it builds and deploys there, with a preview environment for every pull request.