Self-Hosted PaaS in 2026: Coolify vs Dokploy vs CapRover vs Kamal
A self-hosted PaaS is the layer that turns a $20 virtual machine into something that feels like Vercel: git push, build, TLS, rollbacks, a Postgres next door. Five projects do it in four genuinely different ways. We compare Coolify, Dokploy, CapRover, Kamal and Dokku — and then price the migration honestly, including the part of the bill that shows up as your weekends.
First: what a self-hosted PaaS actually buys you
A bare VPS is cheap and useless. Before it runs your app you need a reverse proxy, TLS certificates that renew themselves, a build step, environment secrets, a database with backups, a way to roll back a bad deploy at 11pm, and some signal when a container dies. Every team that has self-hosted has written a worse version of that stack in bash, and then maintained it.
A self-hosted PaaS is that stack, pre-built and maintained by someone else, running on infrastructure you own. It is not a cheaper cloud — it is a different split of the work: you take on the server, and you get back the pricing page, the egress meter, and the right to run anything you want on the machine.
A bill that stops being a surprise
A VPS costs the same whether you serve a thousand requests or a million. No build minutes, no per-seat step function, no invoice that triples because a blog post did well on a Tuesday.
Workloads platforms price punitively
Long-running jobs, websockets, a real Postgres with 200 GB on it, a GPU for inference, a background worker that runs for an hour. On the same box, these are just processes.
Where the data physically sits
Picking the country your customer records live in stops being an enterprise-plan feature and becomes a dropdown when you rent the server. That alone closes some deals.
A portable exit
Everything is Docker and a compose file. Moving between Hetzner, DigitalOcean, OVH or a rack in your office is an afternoon, not a re-architecture — which is leverage even if you never use it.
What it does not do: it does not delete the operational work, it relocates it to you. Kernel patches, disk filling up, an expired credential, a failed restore — all yours now. There is no status page to point at and no support queue to escalate into. A self-hosted PaaS makes the happy path pleasant; the unhappy path is still a person with SSH access at an inconvenient hour, and that person is you.
Do you need this yet? The signals are a platform bill past roughly $300 a month, an invoice dominated by egress or build minutes, a compliance requirement about data location, or a workload your platform keeps timing out. If you are paying $20 a month for Vercel Pro and your app gets a thousand visitors a week, self-hosting will save you real money in percentage terms and almost none in absolute terms. Spend the weekend on the product instead.
Quick Verdict
The most complete option and the one most teams should start with. v4 went stable in April 2026, ~280 one-click services, native multi-server, Apache-2.0 with nothing held back for an enterprise tier.
The lean challenger: Docker Swarm plus Traefik, a cleaner interface, lower idle footprint, and a template catalog growing fast. Still numbered pre-1.0, which is the whole risk conversation.
The boring one, in the good sense. Docker Swarm, 100-plus one-click apps, and years of behaviour that has not changed under anyone. Least fashionable, least likely to surprise you.
Not a PaaS. A CLI that SSHes into your servers, runs Docker commands and exits — no control plane, no database, no dashboard to get compromised. Config lives in your repo as YAML.
The original Heroku-in-a-box. git push dokku main and a buildpack does the rest. Lightest resource use here and a decade of plugins, at the cost of a CLI-only life.
TL;DR
No single winner — pick on your constraint. Want a dashboard and a service catalog → Coolify. Small VPS where idle RAM matters → Dokploy or Dokku. Want something that has not changed in years → CapRover. Want deploys with no extra long-running service to secure → Kamal. And if your platform bill is under $100 a month, the honest answer is none of them yet.
The architectural question: how much stays running when you are not deploying?
Everything else follows from this. A control plane is a long-running service that holds state about your apps — it gives you a dashboard, webhooks and scheduled jobs, and it is also a process that consumes RAM, needs upgrading, and is exposed to the internet. Four designs, four answers.
1. Full control plane, plain Docker
Coolify. A persistent application, database and job queue run on your server and orchestrate plain Docker containers across one or many machines. You get the richest UI and the largest service catalog; you also carry roughly a gigabyte of overhead before your first app starts, and a web dashboard you must not leave open to the world.
2. Control plane on Docker Swarm
Dokploy and CapRover. Swarm — Docker's built-in orchestrator — handles rolling updates, service health and multi-node scheduling, with a UI on top. This is the cheapest path to real zero-downtime deploys and horizontal scaling without touching Kubernetes. Swarm is in maintenance mode as a project, which is a fair criticism and has not stopped it working.
3. Git receiver, buildpack builds
Dokku. A git remote on your server receives a push, builds with a buildpack or your Dockerfile, and swaps the container. There is no dashboard and almost no idle cost. Plugins add Postgres, Redis, Let's Encrypt and the rest. It is the closest thing to the original Heroku experience, and the most spartan.
4. No control plane at all
Kamal. The CLI connects over SSH, drives Docker on each host, and exits. The only thing left running is kamal-proxy, a small Go reverse proxy. Nothing to upgrade, nothing extra listening, no admin UI to be the attack surface. The cost is that there is no dashboard, no managed-service catalog, and your database is your problem from the first minute.
If you cannot decide, the practical test is who else touches deploys. A control plane with a UI is how a non-terminal teammate ships a config change without you. If you are the only person who will ever deploy, the UI is a liability you are maintaining for an audience of one.
The five, in detail
All five are free to self-host. Prices below are for the optional managed dashboards, as published in September 2026 — the meaningful number in every case is what you pay your server provider, not what you pay these projects.
Coolify
The full platform
$0 self-hosted
Cloud dashboard $5/mo for 2 servers
- v4.0 stable since April 2026, ~60k GitHub stars
- ~280 one-click services, including Ollama and most databases
- Native multi-server: one dashboard, many machines
- Apache-2.0 with no paid feature gates or BSL relicensing
- Built-in MCP server so agents can manage deploys
- Preview deployments per pull request, like a managed platform
- CaveatHeaviest idle footprint here — it wants ~1 GB before your apps. The 2 CPU / 2 GB minimum is a demo spec; 4 vCPU / 8 GB is the real one.
Best for: Teams who want the managed-platform experience back, and anyone running more than three or four services.
Dokploy
Swarm, done lean
$0 self-hosted
Cloud from ~$4.50/mo, 1 server
- Docker Swarm + Traefik under a clean, modern UI
- Lower idle CPU and RAM than Coolify on the same box
- Template catalog now rivals Coolify in size
- Apache-2.0, multi-node from the same interface
- Good fit for small VPS instances where overhead is the budget
- CaveatStill numbered in the 0.29.x range in 2026, and the 0.29.3 release shipped with a security patch script to run at upgrade time. Read the release notes before every upgrade.
Best for: Solo developers and small teams on modest servers who want a UI without paying a gigabyte for it.
CapRover
The stable incumbent
$0
free and open source, no cloud tier
- Docker Swarm with a web UI and a CLI
- 100+ one-click apps, most of them long-maintained
- Years of unchanged behaviour — upgrades rarely surprise
- Cluster mode for multiple nodes when you need it
- Netdata monitoring and automatic Let’s Encrypt built in
- CaveatThe interface shows its age next to Coolify and Dokploy, and the pace of new features is slow by design. Fewer modern conveniences like per-PR preview environments.
Best for: People who value predictability over polish, and installs that need to survive years of neglect.
Kamal
Deploys without a platform
$0
a CLI, not a service
- SSH + Docker, no orchestrator and no control plane
- kamal-proxy gives zero-downtime cutovers and automatic TLS
- Config is YAML in your repo — deploys are reviewable in a PR
- Multi-server and multi-role topologies out of the box
- Secrets from 1Password, Doppler and friends
- Instant rollback to the previous container
- CaveatNo UI, no service catalog, no managed databases. Everything a dashboard would have done for you is a decision you now make explicitly, including backups.
Best for: Experienced teams — especially Rails shops — who want deploys to be code and nothing extra running on the box.
Dokku
git push, and it is live
$0
free and open source
- The original Heroku-in-a-box, still actively maintained
- Buildpack or Dockerfile builds triggered by a git push
- Smallest resource footprint of anything here
- Mature plugin ecosystem: Postgres, Redis, Let’s Encrypt, cron
- Runs comfortably on a 1 GB instance
- CaveatCLI-only and single-server by nature. Teammates who do not live in a terminal will not be deploying anything, and multi-node is not the story here.
Best for: Solo builders with a handful of small apps who want the least software possible between git and production.
And the managed option, brieflyRailway, Render and Fly sit between the two worlds: usage-priced like a cloud, but without Vercel-class seat pricing or egress rates. For many teams the correct move is not self-hosting, it is moving down one rung to a cheaper managed platform and keeping the weekends.
We priced that comparison separately in Vercel vs Railway.
Feature comparison
"Idle overhead" is what the platform itself consumes before you deploy anything — the number that decides whether a 2 GB instance is viable.
Why this category got busy in 2026
Self-hosted PaaS tools did not get better fast enough to explain their growth. What changed is the thing they are an alternative to. Survey data through 2026 put around 86% of CIOs planning to move at least some workloads out of public cloud and back to private or on-premises infrastructure — the highest rate recorded — with AI workloads leading the move because inference on rented GPUs is where the bills got absurd.
Read the rest of that data before you quit your platform, though: only about 8% are planning a full exit, and public cloud spending is still growing. This is portfolio management, not a mass migration. Teams are moving the steady-state, predictable workloads — the ones where you know the shape of the load and are paying a premium for elasticity you never use — and leaving the spiky ones where they are.
The workloads that should move
Predictable traffic, long-running processes, data-heavy services with real egress, internal tools, staging environments, anything with a residency requirement, and inference you can serve from one GPU you rent by the month rather than by the second.
The workloads that should not
Genuinely bursty public traffic, anything where a two-hour outage is a business event, and the edge-rendered marketing site that is currently free on someone's hobby tier. Elasticity and someone else's pager are worth paying for when you actually use them.
Self-hosting is not immune to repricing: Hetzner, the provider most of these guides quietly assume, raised cloud prices twice during 2026, and the June adjustment pushed some dedicated-vCPU CPX and CCX plans up by well over 100%. You are not escaping vendor pricing power, you are trading a vendor you cannot leave cheaply for one you can. Price your plan against today's rate card, not a blog post from 2024.
What it actually costs — two teams, both doing the maths
The software is free in every column, so the comparison is server rent versus platform invoice — plus the hours, which is the line everybody leaves out. Figures are indicative September 2026 rates.
Solo founder: 1 app, Postgres, Redis, a worker
- Vercel Pro + managed Postgres~$40–70/mo
- Railway (usage)~$15–45/mo
- One 4 vCPU / 8 GB VPS + Coolify~$25–30/mo
- Your setup time, once4–8 hours
Saving roughly $20 a month against a day of work and permanent on-call. At this size self-hosting is a preference, not a financial decision — and that is a fine reason to do it, just not a business case.
Small team: 12 services, 3 environments, real egress
- Vercel Pro, 3 seats + usage~$250–600/mo
- Railway (usage)~$120–300/mo
- 2 VPS + Coolify Cloud dashboard~$70–90/mo
- Ongoing ops~4 hrs/month
Here the gap is $200 to $500 a month and growing with traffic. Four hours of maintenance is cheap against that — and the egress line, which is what usually pushes a team over, disappears entirely.
The line to hold: price your own hour. If an hour of your time is worth $75 and self-hosting saves $30 a month, the migration pays for itself in about two years, assuming nothing ever breaks. At $300 a month saved it pays back in a fortnight. The bill is not the argument — the ratio between the bill and your rate is. Audit your current stack before you move anything.
Which one should you pick?
You are leaving a managed platform and want it to still feel like one
Coolify. It is the only option here that replaces the whole experience — dashboard, databases, per-PR previews, multiple servers, logs — rather than just the deploy step. Give it 4 vCPU and 8 GB, not the documented minimum, and turn off public access to the dashboard on day one.
Your server is small and every 100 MB counts
Dokploy if you want a UI, Dokku if you do not. Coolify's overhead is real on a 2 GB box, and the point of a cheap VPS is that the apps get the RAM. Accept Dokploy's pre-1.0 status consciously: read release notes, pin your upgrades, take backups before each one.
You want to install it and not think about it for three years
CapRover. Its slow release pace is the feature. Nothing here is going to relicense, pivot its UI, or require a migration because the maintainers rearchitected. For an internal tools box or a client install you will not babysit, boring wins.
A public admin dashboard on your production box is a non-starter
Kamal. Nothing persistent to exploit, nothing to keep patched, and deploy config that goes through code review like everything else. This is the security-conscious answer, and it assumes you are comfortable owning your own database and backups from day one.
Your bill is under $100 and you are doing this because it sounds fun
Then do it on the side, not on production. Move a staging environment or an internal tool first, live with it for a month, and see whether you enjoy the maintenance before your customers depend on it. The teams that regret self-hosting are the ones that migrated production first and discovered their backup story afterwards.
Before you move production, have these five things
1. A restore, not a backup
Automated dumps to object storage off the server, plus one restore you have personally performed into a scratch instance. An untested backup is a folder of files with a comforting name.
2. Monitoring that lives elsewhere
Uptime checks and alerting from outside the box. If your alerting runs on the machine that died, you find out from a customer.
3. The dashboard off the public internet
Bind the control plane to a private network, a VPN or an SSH tunnel. A self-hosted PaaS admin panel is a credential to your whole estate, and these projects have had CVEs like everything else.
4. Unattended security upgrades
Turn them on for the OS, and put a recurring calendar entry on the PaaS upgrade itself. The failure mode of self-hosting is not a dramatic outage, it is a box nobody has patched since the migration.
5. A rebuild you have written down
One page: provision a server, install the PaaS, restore these volumes, point this DNS. If the answer to "the server is gone" is an afternoon of remembering, you have a hobby setup running a business. Write it before you need it, and keep it in the repo next to the compose files.
Frequently Asked Questions
What is the best self-hosted PaaS in 2026?
It depends on which constraint binds you. Coolify is the safest general pick — v4 went stable in April 2026, it is Apache-2.0 with no feature gating, and it ships roughly 280 one-click services plus native multi-server support. Dokploy is the leaner Docker Swarm panel with a fast-growing template catalog, but it is still pre-1.0. CapRover is the boring, long-stable Swarm option. Kamal is not a PaaS at all — it is a deploy tool with no control plane, which is exactly why some teams prefer it. Dokku is the original git-push Heroku-in-a-box and still the lightest thing that works.
Coolify vs Dokploy: which should I choose?
Choose Coolify if you want the widest service catalog, native multi-server management, and a project that has reached a stable 1.x-equivalent release. Choose Dokploy if you specifically want Docker Swarm with Traefik, a lighter interface, and lower idle resource use on a small VPS. The honest caveat on Dokploy is version numbers: it remains in the 0.29.x range, and the 0.29.3 release shipped alongside a security patch script that had to be run with the upgrade. That is normal for a fast-moving project, but it is a different risk posture than a stable release.
How much does self-hosting with Coolify actually cost?
The software is free. What you pay for is the server and your time. A comfortable single-node setup is 4 vCPU and 8 GB of RAM, which lands somewhere around $20 to $30 a month at Hetzner, DigitalOcean or Hetzner-class providers in late 2026. Coolify Cloud — a managed dashboard that deploys to your own servers — is $5 a month covering two connected servers, with additional servers around $3 each. Dokploy Cloud starts near $4.50 a month for a single server. Budget an afternoon for the initial setup and a few hours a quarter for patching, backups and upgrades.
Is a self-hosted PaaS cheaper than Vercel or Railway?
On the invoice, usually yes — often dramatically. In total cost, only past a certain size. A hobby project or a small SaaS on Vercel Pro or Railway typically runs $20 to $60 a month, and a VPS running Coolify runs $20 to $30. Saving $30 a month is not worth a weekend of your time. The maths changes when the platform bill passes roughly $300 a month, when egress or build minutes dominate your invoice, when you need data residency, or when you want to run workloads (GPU inference, long jobs, big Postgres) that managed platforms price punitively.
Do I need Docker Swarm or Kubernetes to self-host?
No. Swarm is an implementation detail that CapRover and Dokploy happen to use, and it gives you rolling updates and multi-node scheduling with far less complexity than Kubernetes. Coolify runs plain Docker with its own orchestration layer on top and can manage multiple servers without a cluster. Kamal skips orchestration entirely and drives Docker over SSH. Unless you have a specific reason to need cluster scheduling, plain Docker on one or two servers is the right default in 2026.
What happens when the server goes down at 3am?
You do. That is the real trade, and it is not solved by any tool on this page. A managed platform is partly an insurance policy: someone else is paged, someone else patches the kernel, someone else has a status page. If you self-host, you need automated off-server backups you have actually restored from at least once, a monitoring and alerting path that does not run on the box being monitored, and a documented rebuild procedure. Budget that work as part of the migration, not as a follow-up.
Is self-hosting immune to price increases?
No, and 2026 proved it. Hetzner — the provider most self-hosting guides assume — raised cloud prices twice during the year, with the dedicated-vCPU CPX and CCX lines seeing increases of well over 100% on some plans in the June adjustment. Self-hosting moves you from one vendor whose prices can change to another whose prices can change; the difference is that your workload is portable, so a repricing costs you a migration rather than a renegotiation.
Can I use AI agents to manage a self-hosted PaaS?
Coolify ships an MCP server inside the product, enabled under Settings then Advanced, which lets an MCP-capable client like Claude Code or Cursor inspect and manage deployments directly. There are also independent community MCP servers for Coolify. It is the first self-hosted PaaS with that integration as a first-party feature, and it makes "why did this deploy fail" a question you can ask rather than a log you have to read.
Related Articles
The managed rung below Vercel
Build a SaaS on Free TiersBefore you rent a server at all
Solo Founder Tech StackHow much ops one person should own
Neon vs Supabase vs PlanetScaleThe database you may stop self-hosting
Run AI Locally with OllamaThe workload driving repatriation
Best Tech Stack for SaaS 2026Everything around the deploy step