Coolify vs Dokploy vs Kamal 2: Picking the Right Self-Hosted PaaS

I’ve been paying managed PaaS bills for years. Heroku’s pricing got worse after the free tier died. Vercel starts free but the bandwidth charges sneak up on you once real traffic hits. At some point I did the math: a $6/month Hetzner VPS could run everything I was paying $40-60/month for across Heroku and Vercel combined.

The problem was never the server cost. It was the overhead of managing raw Linux boxes. Writing Nginx configs, setting up systemd services, handling SSL renewals, doing zero-downtime deployments by hand — that’s the stuff that eats your weekends.

That’s why self-hosted PaaS tools exist. They give you the convenience of a managed platform on your own hardware. Right now, three tools dominate this space: Coolify, Dokploy, and Kamal 2. I’ve deployed production apps to all three over the past year, and they each solve the same problem in fundamentally different ways.

This article is the comparison I wish I had when I started. If you already know which tool interests you, we have dedicated guides for installing Coolify and installing Dokploy.

Quick comparison

Before digging into the details, here’s the high-level picture:

Coolify: the full-featured dashboard

Coolify is what most people think of when they hear “self-hosted Heroku.” It gives you a polished web interface where you connect your GitHub account, point it at a repository, and it handles the build, deployment, SSL, and routing. If you’ve used Vercel’s dashboard, you’ll feel at home.

I wrote a full Coolify v5 review recently, so I won’t repeat everything. But here’s the short version of what makes it stand out:

The template library is massive. Over 280 one-click services — databases, Redis, monitoring tools, wiki software, you name it. I run Plausible Analytics, PostgreSQL, and Redis all deployed through Coolify templates, and it took maybe 10 minutes total. Adding a new database is two clicks.

Git-push deployments work the way you’d expect. Push to main, Coolify builds and deploys. It supports preview deployments for pull requests too, which is useful if you want to test branches on a real server before merging.

Backups are built in. You can schedule PostgreSQL and MySQL backups directly from the UI and push them to S3-compatible storage. I use Cloudflare R2 for this, and Coolify handles the scheduling and rotation.

Where Coolify struggles

The biggest problem is resource consumption. Coolify runs a Laravel backend, a PostgreSQL database, Redis, queue workers, and a Caddy reverse proxy. All of that idles at roughly 1.5–2 GB of RAM before you deploy a single app. If you put Coolify on a 2 GB VPS, you’ll get OOM-killed the moment you try to run anything meaningful alongside it.

The other annoyance is that proxy debugging can be painful. When something goes wrong with Caddy routing, the error messages aren’t always helpful. I’ve spent more time than I’d like restarting Coolify’s proxy container and waiting for it to regenerate configs.

Still, if you have a server with enough RAM and you want one dashboard to manage everything, Coolify is the most complete option available. The install process takes about 10 minutes.

Dokploy: the lightweight middle ground

Dokploy competes directly with Coolify but takes a leaner approach. It gives you a web dashboard for deployments and basic database management, but it runs on a fraction of the resources.

I covered the full Dokploy installation in a separate guide. The short version: run a single curl command, wait two minutes, and you have a working PaaS on your server. Dokploy uses Docker Compose and Traefik under the hood, and the dashboard is clean and fast.

What Dokploy does well

Resource efficiency is the main selling point. Dokploy idles around 400–500 MB of RAM. That means you can actually run it on a cheap 2 GB VPS and still have room for a couple of Node.js apps and a PostgreSQL database. For side projects and small SaaS apps, this matters a lot.

Docker Swarm is built in. If you outgrow a single server, Dokploy lets you add worker nodes and distribute containers across them using Docker Swarm. Coolify doesn’t have this yet (it’s coming in v5). For anyone who needs multi-node scaling without jumping to Kubernetes, this is a real advantage.

Docker Compose support is native. You can paste a full docker-compose.yml file into Dokploy and it runs it as-is. I’ve covered this in detail in how to deploy Docker Compose apps in Dokploy. If you already have compose files for your self-hosted tools, switching to Dokploy is trivial.

Dokploy also handles automated backups to Cloudflare R2 and supports deploying Python apps with Railpack and uv, which is nice if you’re running FastHTML or Flask apps. You can also update Docker Compose stacks directly from the UI.

Where Dokploy falls short

The template library is small compared to Coolify. If you want to deploy something like Outline or Activepieces with a single click, you might need to write your own compose file. That’s not hard, but it’s not as convenient as Coolify’s massive template catalog.

Licensing is mixed. The core is open source, but some features are under a more restrictive source-available license. For most users this doesn’t matter, but it’s worth knowing if you plan to build commercial tooling on top of it.

The community is smaller. Coolify has 50,000+ GitHub stars and a very active Discord. Dokploy’s community is growing but you’ll find fewer tutorials and troubleshooting threads. When something breaks, you’re more likely to be reading source code than finding a Stack Overflow answer.

Kamal 2: the zero-overhead CLI tool

Kamal 2 is built by the team behind Ruby on Rails (37signals, the Basecamp/HEY people). It takes a completely different approach from both Coolify and Dokploy: there is no web dashboard, no control panel installed on your server, nothing.

Kamal is a Ruby gem you run from your laptop or your CI pipeline. It connects to your server over SSH, pulls your Docker image, starts the new container, runs health checks, and swaps traffic with zero downtime. The only thing it installs on the server is a tiny reverse proxy called kamal-proxy (about 10 MB).

What makes Kamal interesting

Zero server overhead. Your VPS resources go entirely to your applications. No dashboard eating 500 MB or 2 GB of RAM. For a single-app deployment on a cheap $4 VPS, this is the most efficient option by far.

Everything is a file in your repo. Your deployment config lives in config/deploy.yml, your environment variables in .kamal/secrets, and your Docker setup in a standard Dockerfile. There’s nothing to click, nothing stored in a remote database. git log shows you the full history of every infrastructure change you’ve ever made.

Zero-downtime deploys work out of the box. Kamal starts the new container, waits for the health check to pass, then tells kamal-proxy to route traffic to it. The old container stays running for a grace period. Rollbacks are one command: kamal rollback.

service: my-app
image: ghcr.io/myuser/my-app

servers:
  web:
    - 49.12.100.50
  workers:
    hosts:
      - 49.12.100.50
    cmd: bin/jobs

proxy:
  ssl: true
  host: myapp.com

registry:
  server: ghcr.io
  username: myuser
  password:
    - KAMAL_REGISTRY_PASSWORD

env:
  secret:
    - DATABASE_URL
    - REDIS_URL

accessories:
  db:
    image: postgres:16
    host: 49.12.100.50
    port: "127.0.0.1:5432:5432"
    env:
      secret:
        - POSTGRES_PASSWORD
    directories:
      - data:/var/lib/postgresql/data

# First-time server setup
kamal setup

# Deploy latest changes
kamal deploy

# Roll back to previous version
kamal rollback

# Open a Rails console on the server
kamal app exec --interactive "bin/rails console"

# View live logs
kamal app logs -f

# Deploy to a specific server
kamal deploy --hosts=49.12.100.50

Where Kamal gets annoying

No visual interface at all. Want to check if your app is running? SSH in, or run kamal app details. Want to view logs? kamal app logs. Want to check database status? You’re on your own. If you manage 10 services and want to glance at everything in one screen, Kamal doesn’t help you.

Database management is manual. Kamal can spin up databases as “accessories” (see the config above), but it won’t back them up, it won’t give you a UI to browse tables, and it won’t help you restore data. You need to set up pg_dump cron jobs yourself. Both Coolify and Dokploy handle this for you.

It’s Ruby-centric. While Kamal can deploy any Docker container, the documentation and community are heavily focused on Rails. If you’re a Python or Node.js developer, the examples and conventions might feel unfamiliar.

The learning curve is real. If you’ve never used Docker registries, written Dockerfiles, or configured health check endpoints, Kamal will feel steep. Coolify and Dokploy abstract most of this away.

Deployment workflows compared

Here’s what the actual deployment experience looks like with each tool:

When to use each tool

After a year of using all three, here’s how I actually decide:

Cost comparison

One of the main reasons to self-host is saving money. Here’s a rough breakdown of what similar setups cost:

These are rough numbers, but the pattern holds: self-hosting is 5-10x cheaper for equivalent workloads. The tradeoff is your time managing the server. Tools like Coolify and Dokploy cut that time to near-zero for common tasks.

For VPS providers, I’ve had good results with Hetzner for European servers.

FAQ