Coolify vs Dokploy in 2026: Resource Usage Tested on Identical VMs

Coolify vs Dokploy is the most common question once you decide to leave Vercel or Heroku and run your own PaaS. Both are open source, both give you a web dashboard on top of Docker and Traefik, and both install with one curl | sh command. So I installed both on identical fresh Ubuntu 24.04 VMs and measured what they actually cost a small server at idle: RAM, disk and what each installer puts on the box.

Short version: on a fresh install, Coolify 4.4.6 idled at about 460–520 MiB of container RAM and added 3.0 GB of disk. Dokploy 0.30.8 idled at about 831 MiB and added 5.0 GB, mostly from one 3.25 GB image. I also run this site on Coolify, so the second half covers what self-hosting with it is like day to day.

TL;DR: Coolify or Dokploy?#

• Pick Coolify if you want the lighter idle footprint, the biggest one-click catalogue (280+ services), and the larger community.
• Pick Dokploy if you like Docker Swarm, want volume backups and GitLab, Gitea or Bitbucket integrations built in, or prefer a TypeScript codebase you can read and patch.
• On a 2 GB VPS, both fit, but Coolify leaves noticeably more room for your apps.

How I tested Coolify and Dokploy#

I didn't want to touch my production Coolify server for this, so each tool got its own throwaway VM:

• Same base image: Ubuntu 24.04 LTS cloud image, 2 vCPUs, 4 GB RAM, 40 GB disk, nothing else installed. An idle VM used 388 MB of RAM and 1.6 GB of disk before either installer ran.
• Official installers only: curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash and curl -sSL https://dokploy.com/install.sh | sh, exactly as their docs say.
• Versions: Coolify v4.4.6 (released October 9, 2026) and Dokploy v0.30.8 (September 29, 2026), the latest stable releases on test day. Docker Engine 29.9.1.
• Measurements: after install, I waited for every container to report healthy, then took three docker stats samples 15–20 seconds apart, plus free -m, df and docker system df. No apps were deployed, no admin account created: this is the price of the platform itself.

What I didn't measure, and why. My test box can't run hardware virtualisation (KVM), so both VMs ran under full CPU emulation (QEMU TCG). Emulation slows the CPU down a lot but doesn't change how much memory a process allocates or how many bytes an image takes on disk. So RAM, disk and image sizes below are real. CPU usage and install times are not: Dokploy's install took 23.6 minutes under emulation, and Coolify's installer even timed out its own 60-second health check before the containers came up healthy a few minutes later. On a normal VPS both installers finish in a few minutes, but I'm not going to put an emulated stopwatch number next to either. I also didn't benchmark build or deploy speed, because builds run on the same Docker engine and depend mostly on your app, not the panel.

Coolify vs Dokploy resource usage at idle#

Here's the per-container RAM from docker stats, as the range across three samples:

Coolify's main container drifted down as it settled, from 455 MiB to 395 MiB. Dokploy's stayed flat at 774 MiB across all three samples. Whole-VM RAM (which includes the Docker daemon, containerd and the OS page tables, but not file cache) was 1,193 MB for Coolify and 1,381 MB for Dokploy, against 388 MB for the bare OS. So on a 2 GB server, Coolify leaves you roughly 800 MB for apps and Dokploy roughly 600 MB. That's tight for both, and it's why I'd treat 4 GB as the practical minimum if you also build on the same server.

Disk usage and Docker image sizes#

Disk is where they differ most. Measured with df against the 1.6 GB baseline:

• Coolify: +3.0 GB. Six images totalling 2.27 GB: the Coolify app (863 MB), its helper image for build jobs (652 MB), postgres:15-alpine (417 MB), traefik (253 MB), redis:7-alpine (58 MB) and the sentinel metrics agent (50 MB).
• Dokploy: +5.0 GB. Three images totalling 3.90 GB, and one of them is the Dokploy app image at 3.25 GB. The rest is postgres:16 (451 MB) and traefik (193 MB).

That big Dokploy image also explains its higher RAM: it's a full Node.js/Next.js application, while Coolify's PHP app runs inside a slimmer image. Dokploy's own docs ask for 30 GB of disk, and Coolify's ask for 10 GB. Either way, your apps' images, build cache and database volumes will quickly dwarf the platform itself, so plan disk for those, and prune old images regularly.

Architecture: Docker Compose vs Docker Swarm#

The biggest design difference isn't visible in the dashboard:

• Coolify runs as plain Docker containers managed with Compose. It connects to every server it manages, including the one it runs on, over SSH, which is why the installer generates an SSH key for localhost. Adding a second server means giving Coolify SSH access to it. It keeps its state in Postgres 15 and uses Redis for queues.
• Dokploy runs docker swarm init during install and deploys itself as Swarm services. Multi-node scaling uses Swarm's own model, which is nice if you already know Swarm. It also means the installer needs ports 80, 443 and 3000 free, and fails if anything is already listening there. During my install, the Dokploy service sat at "no suitable node (host-mode port already in use)" for several minutes before it started on its own.

Both use Traefik as the reverse proxy and get Let's Encrypt certificates automatically. Both support Git-based deploys, Dockerfiles, Docker Compose, databases with scheduled backups, preview deployments, teams and a built-in terminal. Dokploy's own comparison page lists volume backups and GitLab, Gitea and Bitbucket integrations as things it has and Coolify doesn't. Coolify's headline is its catalogue of 280+ one-click services.

What self-hosting with Coolify is actually like#

This site, fabwaseem.com, and its sister tools site both deploy from GitHub to a single Coolify server. Things I've learned running it, with no detail that matters to an attacker:

• Push-to-deploy just works. Merge to main, Coolify builds the Dockerfile and swaps containers. For a Next.js app, a standalone Dockerfile keeps images small and builds predictable.
• Database migrations need a plan. Once, a deploy failed health checks because the new code expected a database change that hadn't been applied yet. Nothing went down, because Coolify kept the old container serving traffic, and the next deploy with the migration step fixed it. Run migrations as part of the container start or a pre-deploy command, and take a backup first.
• Don't expose the dashboard. I reach my Coolify dashboard only through an SSH tunnel; it isn't on the public internet. Given the advisory counts below, I'd do the same with Dokploy.
• The server is now your job. Updates, disk space, backups and Docker image pruning are on you. I wrote up the full setup in how to self-host Next.js with Coolify and the costs in Coolify vs Vercel.

Security: patch both, expose neither#

Both projects are young, popular and run as root-equivalent on your server, so they attract security research. Counting the published advisories on their GitHub security pages in 2026 alone: Coolify had 61 (16 critical, 25 high) and Dokploy had 56 (33 critical, 17 high). Recent Dokploy ones include an OS command injection via the dockerImage field and a broken access check on the container terminal WebSocket. Most of these need a logged-in user, but "member becomes root" is exactly what matters when you invite teammates.

Raw counts aren't a quality score: they also reflect how many people are looking and how openly each team discloses. The practical takeaways are the same for both:

1. Create the admin account immediately after install. Coolify's docs warn that whoever registers first becomes the instance admin with root access to your server.
2. Put the dashboard behind a domain with HTTPS, then close the raw port, or keep it behind a VPN or SSH tunnel. Dokploy's docs show how to remove port 3000 once your domain works.
3. Update promptly and watch each repo's security advisories.
4. Only invite people you'd trust with root on that server.

Which one should you pick?#

• Small VPS (2–4 GB), solo developer: Coolify. The lower idle RAM and disk leave more room for your actual apps.
• You already run Docker Swarm, or want built-in volume backups and non-GitHub Git providers: Dokploy.
• You want the most one-click templates and community answers: Coolify, with 63k GitHub stars to Dokploy's 38k.
• You'll hack on the platform itself: whichever language you prefer. Coolify is Laravel/PHP, Dokploy is TypeScript.
• You don't want to run a server at all: neither. Both offer a paid cloud version that runs the control panel for you, but your apps still run on your servers.

Key takeaways#

• On identical fresh Ubuntu 24.04 VMs, Coolify 4.4.6 idled at ~460–520 MiB of container RAM and Dokploy 0.30.8 at ~831 MiB.
• Whole-VM RAM at idle was 1,193 MB for Coolify and 1,381 MB for Dokploy, against 388 MB for Ubuntu alone.
• Coolify's install added 3.0 GB of disk (6 images, 2.27 GB); Dokploy's added 5.0 GB (3 images, 3.90 GB), led by a 3.25 GB app image.
• Coolify runs plain Docker managed over SSH; Dokploy initialises Docker Swarm and needs ports 80, 443 and 3000 free.
• I tested under CPU emulation, so the RAM and disk numbers are real but CPU use and install time were not measured.
• Both projects published dozens of security advisories in 2026: lock down the dashboard, create the admin account straight away and update promptly.
• For a small VPS, Coolify leaves more room for your apps; Dokploy wins on Swarm, volume backups and Git provider integrations.

Related: if you're deploying Next.js on either one, start with my production Next.js Dockerfile, and see how UUIDv7 in Postgres performs on the same kind of small self-hosted database.