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

I installed Coolify 4.4.6 and Dokploy 0.30.8 on identical fresh Ubuntu 24.04 VMs and measured idle RAM, disk and what each installer puts on the box. The original, with any updates, lives on fabwaseem.com.

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?

	Coolify 4.4.6	Dokploy 0.30.8
Container RAM at idle (measured)	~460–520 MiB, 5 containers	~831 MiB, 3 containers
Whole-VM RAM used at idle (Ubuntu alone: 388 MB)	1,193 MB	1,381 MB
Disk added by install (measured)	+3.0 GB	+5.0 GB
Images pulled	6 images, 2.27 GB	3 images, 3.90 GB
Official minimum	2 cores, 2 GB RAM, 10 GB disk	2 GB RAM, 30 GB disk
Orchestration	Docker + Compose, servers over SSH	Docker Swarm (initialised on install)
Dashboard port	8000	3000
Written in	PHP (Laravel)	TypeScript (Next.js)
GitHub stars (Oct 18, 2026)	63,090	37,840
License	Apache-2.0	Apache-2.0, plus a proprietary directory

• 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:

Container	Image	RAM at idle
coolify	coollabsio/coolify:4.4.6	395–455 MiB
coolify-db	postgres:15-alpine	34–38 MiB
coolify-proxy	traefik:v3.7	16 MiB
coolify-redis	redis:7-alpine	5.5 MiB
coolify-sentinel	coollabsio/sentinel:1.0.2	4.5 MiB
Coolify total		~460–520 MiB
dokploy	dokploy/dokploy:v0.30.8	774 MiB
dokploy-postgres	postgres:16	41 MiB
dokploy-traefik	traefik:v3.6.25	16 MiB
Dokploy total		~831 MiB

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.

FAQ

Is Dokploy lighter than Coolify?

Not at idle in my test. On identical Ubuntu 24.04 VMs, Dokploy 0.30.8 used about 831 MiB of container RAM and added 5.0 GB of disk, while Coolify 4.4.6 used about 460 to 520 MiB and added 3.0 GB. Most of Dokploy's footprint comes from its 3.25 GB Next.js app image.

How much RAM does Coolify need?

Coolify's docs list 2 CPU cores, 2 GB RAM and 10 GB of disk as the minimum. In my test the platform used about 460 to 520 MiB of container RAM at idle, and the whole VM used 1,193 MB. Plan for 4 GB if you also build apps on the same server.

How much RAM does Dokploy need?

Dokploy's docs ask for at least 2 GB RAM and 30 GB of disk. At idle its three containers used about 831 MiB, and the whole VM used 1,381 MB. Like Coolify, it gets tight on 2 GB once Docker builds run on the same server.

What is the main difference between Coolify and Dokploy?

Coolify runs plain Docker containers managed with Compose and connects to every server over SSH. Dokploy initialises Docker Swarm and deploys itself and your apps as Swarm services. Coolify is written in PHP with Laravel; Dokploy is written in TypeScript with Next.js.

Is Coolify or Dokploy more secure?

Neither is clearly safer. Both published dozens of GitHub security advisories in 2026: 61 for Coolify and 56 for Dokploy, many rated critical. Create the admin account right after install, keep the dashboard off the public internet or behind HTTPS, update promptly and only invite trusted users.

Can Coolify and Dokploy manage multiple servers?

Yes. Coolify adds servers by connecting to them over SSH, and can use a separate build server. Dokploy supports multiple servers and multi-node setups through Docker Swarm. Both also offer a paid cloud control panel that manages your own servers.

Is Dokploy open source like Coolify?

Coolify is Apache-2.0. Dokploy's code is Apache-2.0 except anything in a proprietary directory, which uses a separate proprietary license. Both can be self-hosted for free, and both have a paid cloud version.

How long does it take to install Coolify or Dokploy?

Both install with one official curl command and finish in a few minutes on a normal VPS. I didn't publish install times from my test because my VMs ran under CPU emulation, which made installs far slower than real hardware and would make any timing misleading.

---

Originally published on fabwaseem.com.