Coolify vs Dokku vs Kamal: Self-Hosted PaaS for Startups 2026

Something shifted in the startup infrastructure world around 2024. Teams that had been happily paying Heroku, Vercel, and Railway started doing the math and realizing they were spending $200 to $500 per month on hosting that could run on a $5 to $20 VPS. The catalyst was not just cost. It was the maturity of open-source PaaS tools that finally made self-hosting accessible to teams without dedicated DevOps engineers.

Coolify launched its v4 release and suddenly you had a Heroku-like dashboard running on your own server. Dokku, the "Docker-powered mini-Heroku," continued its decade-long run as the most battle-tested self-hosted option. And Kamal, born from the 37signals team that runs Basecamp and HEY on bare metal, offered a fresh approach to deploying containerized apps over plain SSH. Each tool solves the same problem differently: give small teams production-grade deployment without the managed platform tax.

The economics are stark. A Hetzner CX22 VPS with 4 GB RAM and 2 vCPUs costs roughly $5.39/month. Install Coolify on it, and you can run a Next.js frontend, a Node.js API, a PostgreSQL database, and a Redis instance on a single box. The equivalent setup on Vercel Pro plus a Railway database runs $40 to $80/month. On AWS with managed services, you are looking at $100 to $200/month. That is a 60 to 90% cost reduction for the same workload.

But cost is only part of the story. Self-hosting gives you data sovereignty, no vendor lock-in, no surprise pricing changes, and the ability to run workloads that managed platforms restrict (long-running processes, websocket servers, GPU compute, custom binary dependencies). The trade-off is operational responsibility. You own the server, the updates, the backups, and the 3 AM alerts. The question is not whether self-hosting saves money. It does. The question is which self-hosted PaaS makes the operational burden manageable for your team.

Coolify, Dokku, and Kamal look similar from a distance. All three deploy containerized applications to servers you own. But their architectures are fundamentally different, and those differences shape everything from setup complexity to multi-server scaling.

Coolify: Docker Compose with a Web UI

Coolify is a self-hosted application management platform that runs as a Docker container on your server. It provides a polished web dashboard where you can connect Git repositories, configure environment variables, set up databases, manage domains, and monitor deployments. Under the hood, Coolify uses Docker and Docker Compose to orchestrate your services. When you deploy an application, Coolify pulls your code, builds a Docker image (using Nixpacks or a Dockerfile), and runs it as a container alongside your other services.

The key architectural decision in Coolify is that it manages everything through a central control panel. Your Coolify instance connects to remote servers via SSH, installs Docker on them, and deploys containers remotely. This means you can manage multiple servers from a single Coolify dashboard. Coolify handles SSL certificates automatically via Let's Encrypt, configures Traefik or Caddy as a reverse proxy, and provides built-in database management for PostgreSQL, MySQL, MongoDB, and Redis.

Coolify v4 (the current version) is built with Laravel, uses a PostgreSQL database for its own state, and communicates with target servers over SSH. It supports deploying from GitHub, GitLab, Bitbucket, or any Git repository. It also supports one-click service deployments for popular applications like WordPress, Plausible Analytics, Supabase, and dozens of others.

Dokku: Heroku Buildpacks via CLI

Dokku is the oldest and most Unix-philosophy-aligned option. It runs on a single server and provides a command-line interface that mirrors Heroku's workflow. You create an app with dokku apps:create myapp, push code via git push dokku main, and Dokku builds and deploys it. There is no web UI (though community plugins exist). Everything happens through SSH commands.

Dokku uses Heroku buildpacks (via herokuish) or Dockerfiles to build your applications. It manages Nginx as a reverse proxy, handles SSL via Let's Encrypt, and supports plugins for PostgreSQL, MySQL, Redis, RabbitMQ, and other services. Each application gets its own Docker container, and Dokku manages networking between containers automatically.

The critical difference from Coolify: Dokku is designed for a single server. It does not have built-in multi-server support. You can deploy multiple applications on one Dokku host, but scaling across servers requires manual setup or third-party tools. Dokku also stores its configuration as flat files on the host filesystem, making it simple to back up but also tightly coupled to the host machine.

Kamal: SSH-Based Container Deployment

Kamal takes a radically different approach. It is not a platform that runs on your server. It is a deployment tool that runs on your local machine (or in CI) and deploys containers to remote servers over SSH. Think of it as Capistrano for Docker containers. You define your deployment in a config/deploy.yml file, run kamal deploy, and Kamal SSHs into your servers, pulls your Docker image from a registry, and starts it behind a Traefik reverse proxy.

Kamal does not install anything persistent on your servers except Docker, Traefik, and your application containers. There is no daemon, no database, no control plane. Your servers are stateless deployment targets. This means Kamal has almost zero operational overhead on the server itself, but it also means there is no web dashboard, no built-in monitoring, and no centralized management UI.

Kamal was built by the 37signals team specifically for deploying Rails applications to bare metal servers. It has since expanded to support any Docker container, but the Rails ecosystem tooling and conventions remain strong. Kamal 2 (released in 2024) simplified the configuration format and added support for accessories (databases, Redis, etc.) and asset bridging for zero-downtime deployments.

The first 30 minutes with each tool tells you a lot about who it was built for. We have set up all three on fresh Hetzner and DigitalOcean VPS instances, and the experiences are dramatically different.

Coolify: Five Minutes to Your First Deploy

Coolify's setup is genuinely impressive. SSH into a fresh Ubuntu server, run the one-line install script, and wait about two minutes. Coolify installs Docker, pulls its own containers, sets up a PostgreSQL database for its internal state, and starts the web UI on port 8000. You open the browser, create an admin account, and you are looking at a dashboard that feels like a self-hosted version of Railway.

From there, you connect your GitHub account (or paste a Git URL), select a repository, and Coolify auto-detects your framework. It picks the right Nixpack build configuration for Next.js, Rails, Laravel, Django, Go, or whatever you are running. Set your domain, and Coolify provisions an SSL certificate and configures the reverse proxy automatically. Your first deployment takes about 3 to 5 minutes including build time.

Coolify also provides a marketplace of one-click services. Need a PostgreSQL database? Click "New Resource," select PostgreSQL, and it spins up a managed container with automatic backups to S3 if you configure it. Need Plausible Analytics or Uptime Kuma? Same process. This marketplace approach is what makes Coolify accessible to founders and junior developers who do not want to write Docker Compose files.

Dokku: Familiar if You Know Heroku

Dokku's installation is a single script that takes about 5 minutes on a fresh Ubuntu or Debian server. After installation, you interact with Dokku exclusively through SSH commands. The workflow is almost identical to Heroku. Create an app, add a Git remote pointing to your Dokku server, and git push. Dokku detects your runtime, builds your app, and deploys it.

Setting up a database requires the plugin system. Run dokku plugin:install postgres, then dokku postgres:create mydb, then dokku postgres:link mydb myapp. Dokku injects a DATABASE_URL environment variable into your app container. If you have used Heroku add-ons, this feels natural. If you have not, it is a lot of CLI commands to memorize.

SSL setup requires the Let's Encrypt plugin: dokku plugin:install letsencrypt, configure your email, then dokku letsencrypt:enable myapp. It works reliably, but every feature is a plugin you install and configure separately. Dokku gives you exactly the pieces you need and nothing more.

Kamal: Configuration File Driven

Kamal's setup starts on your local machine, not the server. You add the Kamal gem to your project (gem install kamal or add it to your Gemfile), run kamal init, and edit the generated config/deploy.yml file. This file defines your servers, Docker image registry, environment variables, and accessories.

The first deploy runs kamal setup, which SSHs into your servers, installs Docker, pulls Traefik, and deploys your application. Subsequent deployments use kamal deploy. The entire process takes 2 to 5 minutes depending on your Docker image size and server location.

Kamal requires a Docker registry (Docker Hub, GitHub Container Registry, or a private registry) to push your built images before deploying them. This is an extra moving piece that Coolify and Dokku do not require, since they build images directly on the target server. The trade-off is that Kamal can deploy the same pre-built image to multiple servers, which is cleaner for multi-server setups.

Running databases on the same infrastructure as your application is where self-hosted PaaS delivers the biggest cost savings compared to managed services. An RDS PostgreSQL instance starts at $15/month for the smallest tier. Running PostgreSQL in a Docker container on your VPS costs nothing beyond the server itself. But managed databases exist for a reason: automatic backups, failover, and monitoring. Each of these tools handles the responsibility differently.

Coolify: Built-In Database Management

Coolify treats databases as first-class resources. From the dashboard, you can create PostgreSQL, MySQL, MariaDB, MongoDB, or Redis instances with a few clicks. Each database gets its own Docker container with persistent volumes. Coolify shows you connection strings, lets you configure resource limits, and provides a basic web UI for viewing logs.

The backup story is where Coolify really differentiates. You can configure automatic database backups to S3-compatible storage (AWS S3, Backblaze B2, MinIO) on a cron schedule. Coolify handles the pg_dump or mysqldump, compresses the backup, uploads it, and manages retention. This is a feature that typically requires a separate backup tool or custom scripts on other platforms. For teams that need peace of mind without writing cron jobs, this matters.

Coolify also supports deploying full service stacks via Docker Compose. If your project has a docker-compose.yml that defines your API, database, Redis, and worker processes, Coolify can deploy the entire stack as a unit. This is useful for complex applications with many interdependent services.

Dokku: Plugin-Based Services

Dokku manages databases through official plugins. The PostgreSQL, MySQL, Redis, and MongoDB plugins follow the same pattern: install the plugin, create a service, link it to your app. Dokku handles container networking so your app can reach the database via an internal hostname.

Backups in Dokku require manual configuration. The PostgreSQL plugin supports dokku postgres:export mydb > backup.sql, but scheduling automated backups means writing a cron job yourself. Some teams use the dokku-letsencrypt pattern of cron-based automation, but it is your responsibility to set up offsite backup storage and rotation.

Dokku's plugin ecosystem is its strength and limitation. There are plugins for everything (Elasticsearch, RabbitMQ, InfluxDB, Memcached), but quality and maintenance vary. The official plugins maintained by the Dokku team are solid. Community plugins may lag behind or have unresolved issues. Always check the last commit date before relying on a community plugin.

Kamal: Accessories for Databases

Kamal calls ancillary services "accessories." You define them in your deploy.yml configuration. A PostgreSQL accessory tells Kamal to run a PostgreSQL container on a specified server with a persistent volume, specific environment variables, and port mappings. Kamal starts the accessory container alongside your application.

There is no built-in backup management. You are responsible for setting up backup scripts, cron jobs, and offsite storage. Kamal gives you the deployment mechanism but does not manage the lifecycle of your data. For teams comfortable writing a pg_dump cron job that ships backups to S3, this is fine. For teams that want turnkey database management, Coolify is the better choice.

One advantage of Kamal's approach: since accessories are defined in your deploy.yml, your database configuration lives in version control alongside your application code. This makes it easy to reproduce your entire infrastructure from a single configuration file, which is valuable for disaster recovery and for spinning up staging environments that mirror production.

Deploying your application is the easy part. Keeping it running reliably for months and years is where the real work lives. Managed platforms handle monitoring, logging, and maintenance for you. With self-hosted PaaS, you own these responsibilities. The three tools offer very different levels of built-in support.

Coolify: Dashboard Monitoring and Notifications

Coolify provides basic monitoring through its web dashboard. You can view container logs in real-time, see CPU and memory usage per service, and check deployment history. Coolify also supports notification channels (Slack, Discord, Telegram, email) for deployment events and health check failures.

For production workloads, Coolify's built-in monitoring is a starting point but not sufficient. You will want to add an external monitoring tool. The good news is that Coolify can deploy monitoring stacks from its marketplace. You can spin up a Grafana plus Prometheus stack or deploy Uptime Kuma for uptime monitoring, all managed through the same Coolify dashboard. This is a practical middle ground: you still self-host your monitoring, but Coolify handles the deployment and configuration.

Server maintenance (OS updates, Docker updates, security patches) is your responsibility. Coolify does handle its own updates through a one-click update button in the dashboard, which is convenient. But the underlying Ubuntu/Debian host needs regular apt update && apt upgrade cycles, and you should monitor disk space, especially if you are running databases with growing data volumes.

Dokku: Logs and CLI Inspection

Dokku exposes logs through dokku logs myapp (equivalent to heroku logs). You get stdout/stderr from your application container. For persistent logging, you need to configure a log drain that ships logs to an external service like Papertrail, Logtail, or a self-hosted Loki instance.

Monitoring in Dokku is entirely external. There is no built-in dashboard, no resource graphs, no alerting. You install your own monitoring stack (Prometheus, Grafana, Netdata, or a hosted service like Datadog). Dokku provides dokku ps:report for container status and dokku resource:report for resource limits, but these are point-in-time snapshots, not time-series data.

Dokku updates itself through apt upgrade dokku, and the update process is generally smooth. The Dokku team maintains good backward compatibility between versions. Plugin updates happen separately per plugin.

Kamal: Minimal Built-In Tooling

Kamal provides kamal app logs to tail your application logs and kamal audit to see a record of deployment commands. Beyond that, monitoring and logging are entirely your responsibility. Kamal's philosophy is that it handles deployment, not operations.

For teams using Kamal, the typical monitoring stack is an external service (Datadog, New Relic, or a self-hosted Prometheus/Grafana setup deployed separately). Since Kamal deploys plain Docker containers, any container-compatible monitoring agent works. You can include a monitoring sidecar in your Docker Compose or deploy monitoring as a Kamal accessory.

Server maintenance follows the same pattern as any bare-metal server: you SSH in, run updates, reboot when needed. Kamal does not abstract server management. It assumes you are comfortable managing Linux servers directly.

Cost is the primary driver for most teams considering self-hosted PaaS. Let us compare real numbers across four deployment scenarios, from a solo founder's MVP to a growing startup with multiple services. For context on managed platform pricing, see our cloud platform comparison.

Solo Founder: One App, One Database

• Self-hosted (Coolify/Dokku on Hetzner CX22): $5.39/month for the VPS. Run your app and PostgreSQL on the same server. Total: ~$6/month including backups to Backblaze B2 ($0.005/GB).
• Vercel Pro + Railway: $20/month Vercel Pro for the frontend, plus $5/month Railway Pro base fee, plus ~$10/month for a PostgreSQL database on Railway. Total: ~$35/month.
• Railway alone (full-stack): $5/month base fee plus ~$15 to $25/month in resource usage for an API server and database. Total: ~$20 to $30/month.
• Savings with self-hosted: 75 to 85%.

Small Team: Three Services, Two Databases, Redis

• Self-hosted (Coolify on Hetzner CX32): $8.49/month for a VPS with 8 GB RAM and 4 vCPUs. Run a Next.js frontend, a Node.js API, a background worker, PostgreSQL, and Redis. Total: ~$9/month.
• Vercel Pro + Railway Pro: $20/month Vercel (1 developer), plus $5/month Railway base, plus ~$30 to $50/month in resource usage. Total: ~$55 to $75/month.
• AWS (ECS Fargate + RDS + ElastiCache): $50 to $100/month for Fargate tasks, $30/month for the smallest RDS instance, $15/month for a small ElastiCache node, plus load balancer and data transfer. Total: ~$120 to $180/month.
• Savings with self-hosted: 85 to 95% vs AWS, 80 to 88% vs Vercel/Railway.

Growing Startup: Multi-Server, High Availability

• Self-hosted (Coolify managing 3 Hetzner servers): Two CX32 application servers ($8.49 each) plus one CX42 database server ($15.59). Total: ~$33/month. Coolify manages all three from its dashboard and handles load balancing via Traefik.
• Vercel Enterprise + managed databases: $2,000+/month for Vercel Enterprise, plus $100 to $300/month for managed databases. Total: $2,100 to $2,300/month.
• AWS (properly architected): $500 to $1,500/month depending on traffic and service configuration.
• Savings with self-hosted: 93 to 98% vs Vercel Enterprise, 85 to 95% vs AWS.

These numbers make a compelling case, but they come with caveats. Self-hosted infrastructure requires someone on your team who can troubleshoot Docker networking issues, diagnose database performance problems, and respond when disk space fills up at midnight. If that person's time costs more than the hosting savings, managed platforms remain the better deal. Our guide on reducing your cloud bill covers strategies that work regardless of whether you self-host or use managed platforms.

The Hidden Costs of Self-Hosting

Every cost comparison should include the time cost. Expect to spend 2 to 4 hours on initial setup, 1 to 2 hours per month on maintenance (updates, monitoring checks, backup verification), and 2 to 8 hours on incident response if something breaks in production. For a solo founder whose time is worth $100/hour, that is $300 to $500 in labor per year. Still far less than the $360 to $900/year premium for managed platforms in the solo founder scenario, but not trivial.

Coolify minimizes this operational overhead more than Dokku or Kamal because its dashboard centralizes most common tasks. Dokku requires more CLI familiarity but is extremely stable once configured. Kamal requires the most operational maturity because it provides the least built-in management tooling.

After deploying production applications on all three platforms for clients across different team sizes and technical backgrounds, here are our opinionated recommendations.

Choose Coolify If You Want the Easiest Path to Self-Hosting

Coolify is the right choice for founders, small teams, and agencies that want the cost benefits of self-hosting without living in the terminal. Its web dashboard is genuinely good. The one-click database provisioning, automatic SSL, built-in backup management, and service marketplace mean you can go from a fresh VPS to a fully running production stack in under 30 minutes. If anyone on your team has used Vercel, Railway, or Render, they will feel comfortable with Coolify.

Coolify is also the best choice for multi-server setups among these three options. Its SSH-based server management lets you add new servers to your cluster from the dashboard, deploy services to specific servers, and manage everything centrally. For growing startups that will need to scale beyond a single VPS, Coolify provides a clear path forward without rearchitecting your deployment workflow.

The downside: Coolify itself is a complex application (Laravel, PostgreSQL, Redis, Traefik) running on your server. It consumes resources. On a small VPS with 2 GB RAM, Coolify's own overhead is noticeable. Plan for at least 4 GB RAM on your primary server.

Choose Dokku If You Love the CLI and Want Battle-Tested Stability

Dokku has been running in production since 2013. It is the most mature, most stable, and most predictable option. If you are a developer who prefers git push over clicking buttons, Dokku's workflow is elegant and efficient. The Heroku-compatible buildpack system means most applications deploy without any configuration changes.

Dokku is also the lightest option in terms of resource consumption. It does not run a web UI or background workers for its own management. Dokku itself is essentially a collection of shell scripts that orchestrate Docker. On a 1 GB RAM VPS, Dokku leaves almost all resources for your applications.

The downside: single-server only (by default), no web UI, and manual backup configuration. Dokku is best for developers who are comfortable with SSH, cron jobs, and Linux administration. If "write a cron job to back up my database to S3" sounds like a reasonable Saturday morning task, Dokku is your tool.

Choose Kamal If You Are in the Rails Ecosystem or Want Maximum Control

Kamal is the right choice if you are deploying a Rails application, if you want your deployment configuration in version control, or if you need to deploy to bare-metal servers in a data center. Kamal's approach of treating deployment as a command you run (rather than a platform that runs on your server) gives you the most control and the least vendor lock-in, even among self-hosted options.

Kamal excels at multi-server deployment. Because it deploys from a central point (your CI server or local machine) to multiple targets via SSH, adding servers is as simple as adding IP addresses to your deploy.yml. Kamal also supports rolling deployments out of the box, deploying to servers one at a time to maintain availability during updates.

The downside: Kamal requires a Docker registry, has no built-in database management or backup tooling, and provides minimal monitoring. You need to be comfortable assembling your own operational stack. Kamal is a deployment tool, not a platform. That distinction matters when something breaks at 2 AM and there is no dashboard to check.

When to Stay on Managed Platforms

Self-hosting is not always the right call. If your team has zero Linux experience, if you are pre-product-market-fit and every hour of engineering time must go toward features, or if you need compliance certifications (SOC 2, HIPAA) that require auditable managed infrastructure, stay on managed platforms. The $20 to $50/month premium for Vercel or Railway is insurance against operational complexity at a stage when your focus should be on shipping product.

But if you have found product-market-fit, your cloud bill is growing, and someone on your team can handle basic server administration, self-hosted PaaS is one of the highest-leverage cost optimizations available. You are not just saving money month-over-month. You are building infrastructure skills and operational independence that compound over time.

At Kanopy, we help startups evaluate their infrastructure options, migrate between platforms, and set up self-hosted deployment pipelines that run reliably without a full-time DevOps hire. Whether you are moving off Heroku, optimizing your AWS spend, or setting up Coolify for the first time, we can get you running in days instead of weeks. Book a free strategy call and we will map out the right infrastructure for your stage, budget, and team.