A Coolify review on the internet usually comes in one of two flavours: enthusiastic tutorials (“from $400 to $5 a month!”) and frustrated forum posts from people whose deploy has been stuck on “building” for an hour. Both are right; they are just talking about different things. Coolify is an open-source platform you install on your own server, and it gives you what you know from Vercel, Netlify or Heroku: connect a Git repository, push, done. The question is not whether that works. The question is what happens under the hood and what you trade for it. This review is our real-world Coolify experience, measured rather than guessed.
We tested Coolify on our own server on 15 November 2026 — not with screenshots of the dashboard, but with a stopwatch: Coolify 4.7.5 (the current stable release, published on 10 November 2026) plus a separate throwaway target server running Docker 29.9.3. We deployed a real Node.js application from the official examples repository, measured downtime during rebuilds by polling every 100 milliseconds, deliberately rolled out a broken deploy, and removed everything afterwards. Four findings up front:
1. The first deploy of a tiny Node app took 77 seconds and produced a 1.04 GB image. The second deploy of the same commit finished in 6.3 seconds, because Coolify skips the build.
2. A broken deploy is not caught automatically. With fixed port mappings, Coolify reported “finished”, removed the old container, and the app then sat in a restart loop. Only with a health check and without port mapping did Coolify roll back cleanly to the old version.
3. Coolify itself needs around 420 MiB of RAM at idle and about 2 GB of images before you have deployed a single app of your own.
4. Automatic updates are on by default (daily at 00:22). Between 9 and 10 November 2026 alone, six versions were released (4.7.0 to 4.7.5).

What is Coolify, exactly?
Coolify is a self-hosted PaaS (Platform as a Service). In practice: you get a web dashboard that starts applications, databases and ready-made services on your servers, without you touching Docker commands, reverse proxy configs or certificates yourself. Under the hood everything is Docker. Every app, every database and every one-click service runs as a container. In front of them sits a reverse proxy (Traefik by default, Caddy as an option) that obtains Let’s Encrypt certificates automatically.
Some key facts, as of 15 November 2026:
- License: Apache 2.0 — genuine open source, not a “source available” construction.
- Adoption: around 66,000 stars on GitHub, project started in January 2021.
- Price: Self-hosted is free with no feature limits. If you do not want to run the dashboard yourself, Coolify Cloud costs $5 per month (two servers included) plus $3 per additional server. In both cases you bring the servers your apps run on.
- Architecture: The dashboard is a Laravel (PHP) application with PostgreSQL as its database and Redis for queues. On top of that there is a “helper” container that runs builds, and “Sentinel”, a small metrics agent on every target server.
The single most important sentence for understanding Coolify: it connects to every server it manages over SSH, as root. Even the server Coolify itself runs on is reached via SSH (as “localhost” through host.docker.internal). That is elegant, because the same mechanism works for one server or twenty. It also has security consequences, which we get to below.
If you are still deciding whether to leave Vercel at all, read our comparison Vercel Alternative first. There we place Coolify alongside Netlify, Cloudflare, Render and the bare self-managed server. This article is the deep dive: what happens once you have picked Coolify?
Our test setup: how we checked Coolify
We did not want to unleash Coolify on our production server. It runs real services, and a normal Coolify installation changes a few things on the system (more on that in a moment). So the setup looked like this:
- Coolify 4.7.5 using the official compose files and images from
cdn.coollabs.io, as throwaway containers, reachable only on127.0.0.1. - A separate target server as an isolated Docker-in-Docker container with its own SSH daemon. Coolify never controlled the Docker engine of our real server.
- Test application:
javascript/runtimes/nodejsfrom the official repositorycoollabsio/coolify-examples, a small Fastify app with three dependencies. Built with Nixpacks, Coolify’s default build pack. - Downtime measurement: During each deploy, a loop on the target server requested the app every 100 milliseconds and logged the HTTP status.
To be clear about the scope: we read the official installer (install.sh) but did not run it on a fresh server. Statements about what the script changes on your system are based on its source as of 15 November 2026. Everything else — start times, memory, deploys, downtime and rollback — we measured ourselves.
Coolify review part 1: the installation
The official install is a one-liner:
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
The script is now more than 1,200 lines long and surprisingly carefully written. It is still worth knowing what it does beforehand, because a few things are not what you would expect from an “installer”:
1. It checks disk space. The script expects at least 30 GB of disk and 20 GB free, otherwise it warns you. That is realistic. As you will see shortly, Coolify eats disk faster than you think.
2. It installs Docker if needed. Debian, Ubuntu, the Red Hat family, Arch, Alpine and SLES are supported. Minimum version is Docker 24.
3. It modifies /etc/docker/daemon.json. Coolify sets log rotation for all containers (max-size 10m, max-file 3) and its own address pool for Docker networks (10.0.0.0/8 in /24 blocks). Then it restarts Docker — but only if no containers are running. If something is already running, the script skips this step with a warning, and you have to run it again with DOCKER_POOL_FORCE_OVERRIDE=true. That is a good decision by the developers, because a Docker restart stops every running container. Anyone putting Coolify on a server with existing services should know this. How Docker networks work in the first place is covered in Docker Networking Explained.
4. It adds its own SSH key for root. The script generates an Ed25519 key, stores the private half under /data/coolify/ssh/keys/ and appends the public half to ~/.ssh/authorized_keys. That is how Coolify talks to its own server. Worth knowing when you clean up authorized_keys later: the line with the comment coolify belongs to it.
5. It opens port 8000. After installation the dashboard is reachable at http://YOUR-IP:8000, unencrypted and public. Ports 6001 and 6002 are added for the dashboard’s realtime connection.

The first minutes: first come, first admin
After start-up, Coolify redirects every visitor to the registration page. It says “Create the root account”, with a note to create it within 10 minutes. We played this through via the form: first account created, redirect to /onboarding, and from that moment on /register redirects to the login page. The database then shows is_registration_enabled = false. Nobody else can sign up on their own.
That is better than some other tools (in our Portainer vs Dockge test, Dockge had no protection at all). But there is still a window in which anyone who knows your IP and port 8000 can claim the admin account — and server IPs get probed by scanners every few minutes. Our recommendation: create the account immediately after installation. For a clean setup, pass ROOT_USER_EMAIL and ROOT_USER_PASSWORD to the installer as environment variables. The script supports this, and then the open window never exists.
Start-up time and resource use
With images already pulled, the health endpoint /api/health returned 200 after 8.7 seconds. After stopping all three containers and starting them again, it took 2.8 seconds.
Disk usage is more interesting. This is what sits on disk for Coolify alone:
| Image | Size | Where |
|---|---|---|
coollabsio/coolify:4.7.5 | 801 MB | Coolify server |
postgres:15-alpine | 417 MB | Coolify server |
redis:7-alpine | 58.5 MB | Coolify server |
coollabsio/coolify-helper:1.0.19 | 702 MB | every target server |
coollabsio/sentinel:1.1.5 | 52.7 MB | every target server |
That is a good 2 GB before your first application exists. If Coolify runs on the same server as your apps (the normal case for small setups), it all lands on one disk.
For memory, we measured after roughly 30 seconds of idle:
| Container | RAM |
|---|---|
| Coolify (PHP, Horizon, scheduler) | 386 MiB |
| PostgreSQL | 25–33 MiB |
| Redis | 5–6 MiB |
| Sentinel (on the target server) | 6 MiB |
So about 420 MiB just for management. Inside the Coolify container there were 41 processes, 24 of them for PHP-FPM, Nginx, Horizon and the scheduler. On a 2 GB server that leaves roughly 1.5 GB for your actual applications and their builds. That is enough for a small Node app, but it gets tight once Next.js starts building. Builds run on the same server by default, and a Next.js build can briefly need well over 1 GB. How much RAM to plan for realistically is broken down in How Much RAM Does a Server Need?.
Our rule of thumb from the test: for Coolify plus one or two small apps, 4 GB RAM and 40 GB disk. Below that it works, but you will spend more time fighting memory than deploying.
A hands-on look at costs and pitfalls when moving to Coolify (GREZA, July 2026).
Connecting a server: what Coolify really needs
We connected the target server via the API: store the private SSH key, create a server with IP, port 22 and user root, then validate. After about 30 seconds the server showed as “reachable” and “usable”, and the Sentinel container was already running on it.
Two things stood out:
The “localhost” server is there from the start. On first setup, Coolify automatically creates a server named localhost with the description “This is the server where Coolify is running on. Don’t delete this!”. It points to host.docker.internal, user root, port 22. In our test setup the matching key was missing, so Coolify could not get in. We checked the SSH log of our real server: during the test window there were only the usual internet scanners, not a single login from Coolify. In a normal installation, however, this entry gives Coolify root access to its own host.
Keys exist twice. In the database, Coolify stores private keys and environment variables encrypted (with the Laravel APP_KEY, recognisable by the eyJpdiI6 prefix). But as soon as a key is used, Coolify writes it in plain text to /data/coolify/ssh/keys/, with mode 600 and owner UID 9999. That is technically necessary, since SSH needs a key file. It does mean: anyone with read access to /data/coolify holds the keys to all your servers. That directory must never end up in an unencrypted backup somewhere.
The API, by the way, is disabled by default. Only after enabling it in settings can you create tokens, and a token with the root ability can do everything: add servers, deploy apps, read environment variables. Treat such tokens like the root password.
The first deploy: 77 seconds and 1 GB
Now for the actual reason people install Coolify. We added the example app as a public Git repository: branch main, subdirectory /javascript/runtimes/nodejs, build pack Nixpacks, port 3000. Coolify automatically assigned an address of the form http://<uuid>.<ip>.sslip.io — a wildcard DNS service that resolves any IP embedded in a hostname, so you can test without your own domain.
The flow according to the deploy log:
- Coolify detects Docker 29.9.3 with BuildKit on the target server.
- It starts the helper container on the target (the first time, the 702 MB image is pulled).
- It clones the repository into the helper, commit
4c57d59. - Nixpacks detects a Node application and generates a build plan.
- The Docker image is built, the old container removed, the new one started.
Result: 77 seconds from click to “finished”. The app then answered with {"hello":"from nodejs #2"}. The image was 1.04 GB — for an app with three dependencies and about 50 lines of code. After four builds, the target server additionally held 3.2 GB of build cache, 2.2 GB of it reclaimable.

Why so big? Nixpacks builds on a general-purpose base image with the Nix package manager and installs Node (in our case Node 22.11.0) plus tooling. That is convenient, because you do not write a single line of Dockerfile. It is not lean, though. If you want to save disk and build time, switch the build pack in Coolify to Dockerfile and write a multi-stage Dockerfile on node:22-alpine. In our experience the same app then ends up at a fraction of the size.
One detail from the log that saves trouble later: the container has the restart policy unless-stopped. If the app crashes, Docker restarts it. That is sensible — but, as you will see shortly, it can also hide a broken deploy.
Second deploy: 6 seconds
We repeated the deploy immediately without any change. Coolify reported: “No build configuration changed & image found … with the same Git Commit SHA. Build step skipped.” Done after 6.3 seconds. So Coolify remembers the finished image per commit. For a quick restart after changing an environment variable, that is ideal.
With “Force Rebuild”, Coolify builds anyway. In our three further runs that took 68 to 74 seconds, barely faster than the first build. With Nixpacks, the build cache helps less than you would hope.
Downtime during deploys: 1.2 seconds, or none
Now the part most tutorials skip. What do your visitors see while Coolify rolls out a new version?
During a forced rebuild we polled the app every 100 milliseconds. 646 requests over about 68 seconds: 634 returned 200, 12 got no response. The twelve failures were consecutive — roughly 1.2 seconds of downtime at the moment the old container was stopped and the new one started.
Why any downtime at all? The log says it plainly: “Application has ports mapped to the host system, rolling update is not supported.” In the first run we had mapped the app’s port to the host (3100:3000), the way you know it from docker run -p. Two containers cannot bind the same host port at the same time, so the old one has to go before the new one starts.
The Coolify way: no port mapping — enter a domain instead and let traffic flow through the built-in reverse proxy. Then Coolify can start the new container, check it, and only afterwards remove the old one. That is called a rolling update. How a reverse proxy works in general is explained in What Is a Reverse Proxy?.
The broken deploy: our most important finding
A deployment tool shows its quality not when everything works, but when something goes wrong. So we deliberately changed the app’s start command to node gibtsnicht.js (“doesn’t exist”), a file that is not there. We ran this test twice.
Run A: with port mapping, without a health check. Coolify built the image, removed the old container, started the new one and reported the deploy as “finished”. Green, no error. In reality the app crashed immediately, Docker kept restarting it because of unless-stopped, and the container sat at “Restarting (1)”. The app status in Coolify read restarting:unknown. Our polling loop counted 311 failures, and the app stayed down until the measurement ended. The old, working version had already been deleted at that point.
Run B: no port mapping, with a health check on /health. First we deployed the correct version with a health check (71 seconds, then running:healthy). Then the broken start command again. This time Coolify started the new container next to the old one, waited out the 5-second start period, ran the health check, got “unhealthy”, showed the error from the container log (Cannot find module '/app/gibtsnicht.js') and then wrote: “New container is not healthy, rolling back to the old container.” The deploy was marked “failed”, and the old version kept running with status running:healthy.
That is the difference between a deployment tool that protects you and one that merely executes commands. Coolify can be either. By default it leans towards the latter. The health check is not active automatically for new applications, and port mapping is the first step in many guides.
Our most important recommendation from the entire test: give every application in Coolify a health check path (a route that only returns 200 when the app is genuinely ready) and work with domains instead of port mappings. Without those two settings, a green “finished” says nothing about whether your site is reachable.
What happens when Coolify itself goes down?
A common worry: if the Coolify dashboard crashes or gets stuck during an update, is everything gone? We stopped all three Coolify containers (app, database, Redis). The deployed application on the target server kept running without interruption and answered requests normally. Sentinel kept running too.
That follows from the architecture: Coolify is only the conductor. The containers belong to Docker on the target server, which handles restarts on its own. What stops working without Coolify: new deploys, GitHub webhooks, scheduled database backups and certificate renewals that Coolify triggers. The proxy (Traefik) runs as its own container and renews its certificates itself. A dashboard outage of a few hours is annoying, but not an emergency.
A step-by-step installation on Ubuntu 24.04 (RackNerd, June 2026). Note: the channel belongs to a hosting provider.
Updates: the part that costs the most nerves
Coolify moves fast. That is good for new features and tiring for operations. The GitHub release list for November 2026:
| Version | Date |
|---|---|
| 4.5.3 | 28 October 2026 |
| 4.6.0 | 2 November 2026 |
| 4.7.0 | 9 November 2026, 11:38 UTC |
| 4.7.1 | 9 November 2026, 14:01 UTC |
| 4.7.2 | 9 November 2026, 17:21 UTC |
| 4.7.3 | 9 November 2026, 20:41 UTC |
| 4.7.4 | 10 November 2026, 12:19 UTC |
| 4.7.5 | 10 November 2026, 14:57 UTC |
Six versions in a little over 27 hours. These are almost always bug fixes after a larger release — and that is exactly the point: a major release ships with bugs that get fixed in the hours that follow.
Now the catch: the database of our fresh installation contained is_auto_update_enabled = true with the schedule 22 0 * * * — every night at 00:22 — plus a check for new versions every hour. If you change nothing, you may well get that morning’s 4.7.0 installed automatically the following night. For a tool with root access to all your servers, that is bold.
Our recommendation: turn off automatic updates (in settings, or at install time with AUTOUPDATE=false) and apply updates deliberately, ideally a few days after a release and after a fresh backup of /data/coolify and the Coolify database. Many users in forums report that a stuck update sometimes only resolves with a restart of the Coolify container. With a planned update slot, at least that does not happen at half past midnight.
Security: the central question with Coolify
Let us sum up what we learned about security:

Coolify is a master key. It has root SSH access to every connected server, the keys sit in plain text under /data/coolify/ssh/keys/, and it knows every environment variable — database passwords and API keys of your apps included. Whoever takes over Coolify takes over everything. That is true for any comparable tool, but it should be said out loud.
What you should actually do:
- Do not leave port 8000 open. Set your own domain for the dashboard in Coolify (it then runs over HTTPS) and block 8000, 6001 and 6002 in the firewall. Careful: Docker bypasses UFW rules for published ports. How to handle that properly is covered in UFW Firewall Setup.
- Create the admin account immediately, or set it via
ROOT_USER_EMAIL/ROOT_USER_PASSWORDat install time. - Enable two-factor authentication for the admin account.
- Enable the API only when needed, and create tokens with as few abilities as possible.
- Harden SSH. Coolify needs key-based root login. Password login should still be off, and Fail2ban does not hurt.
- Back up
/data/coolifyencrypted. The directory holds keys, configuration and the.envwith theAPP_KEY. Without theAPP_KEY, the encrypted values in the database are useless after a restore. Without encryption, the backup itself is a security risk.
Our Coolify experience in daily use: the good and the annoying
After the test, and based on many experience reports we know, our verdict looks like this:
What is genuinely good:
- Git-push deploys with zero configuration. Add the repo, Nixpacks detects the language, the app runs. For prototypes and small projects, that is unbeatable.
- One-click services. Databases, n8n, Plausible, Uptime Kuma and many more at the click of a button. That saves real time compared with hand-written Docker Compose files.
- Rolling updates with rollback, if configured correctly (health check, no port mapping). That worked flawlessly in our test.
- Apps keep running without Coolify. The dashboard is not a single point of failure for your websites.
- Cost. Self-hosted is free with no feature limits. Add a server from roughly €5–10 per month.
What is annoying:
- A green “finished” does not mean “running”. Without a health check, Coolify reports success even when the app is stuck in a restart loop.
- Disk hunger. 2 GB baseline, over 1 GB per Nixpacks image, gigabytes of build cache. Without a regular clean-up plan, you will eventually hit a full disk. What helps then is in Linux Disk Full.
- Fast release cadence, applied automatically by default.
- Troubleshooting needs Docker knowledge. When something hangs, you end up back on the command line with
docker logsanddocker ps. Coolify takes away the routine, not the need for understanding. - Hard-wired names. A small detail from our test: Coolify expects its database and Redis to be reachable as
coolify-dbandcoolify-redis. We had renamed the containers at first, and the dashboard went into an endless loop withgetaddrinfo for coolify-redis failed. With the official files you never notice. If you like to tinker, you should know.
Coolify vs the alternatives: when is it worth it?
Coolify is not the only platform of its kind. The obvious alternatives are Dokploy (similar concept, younger, built on Docker Swarm), CapRover (older, leaner, fewer features) and plain Docker Compose management with tools like Portainer or Dockge. At the other end are managed platforms like Vercel, Render or Railway.
| If you … | then … |
|---|---|
| run several small projects or client sites on your own servers | Coolify is a real win |
| have a single app with its own compose file | you do not need Coolify; a systemd service or Compose is enough |
| have no time for updates, backups and troubleshooting | stay with a managed provider or use Coolify Cloud |
| understand Docker in principle | you will get on well with Coolify |
| do not know Docker at all yet | read What Is Docker? first, or the first error will leave you stranded |

Our checklist for getting started with Coolify
If you want to try Coolify now, this is the order we recommend after our test:
- A server with at least 4 GB RAM and 40 GB disk, freshly set up, with no other services. Our basics for that are in Linux Server Setup.
- Install with
AUTOUPDATE=falseand a pre-set root account. - Straight after: set a domain for the dashboard, block port 8000, enable two-factor.
- First app without port mapping, with a domain and a health check path.
- Try a deliberately broken deploy. If Coolify rolls back, everything is configured correctly.
- Set up backups for
/data/coolifyand for your apps’ databases, stored off the server. The logic behind that is explained in The 3-2-1 Backup Strategy. - A calendar slot: once a month, apply updates and look at
docker system df.
Frequently asked questions
What is the overall verdict of this Coolify review?
Good, with caveats. Coolify does exactly what it promises: git-push deploys, automatic certificates and one-click services on your own server. In our test with version 4.7.5 the first app was live after 77 seconds. The weak spots are in the details: without a health check Coolify does not detect broken deploys, automatic updates are on by default, and disk usage is high.
Is Coolify free?
Yes. The self-hosted version is open source (Apache 2.0) and has no feature limits. You only pay for your server. If you do not want to run the Coolify dashboard yourself, Coolify Cloud costs $5 per month (two servers) plus $3 per additional server. Your apps still run on your own servers.
How much RAM does Coolify need?
In our measurement, Coolify itself used about 420 MiB at idle (dashboard 386 MiB, PostgreSQL 25–33 MiB, Redis 5–6 MiB). Your apps and their builds come on top. 2 GB RAM is the absolute minimum; 4 GB is realistic for daily use.
Is Coolify secure?
Coolify is as secure as your setup. It has root SSH access to all connected servers, and the keys sit in plain text in /data/coolify/ssh/keys/. After installation, the dashboard is reachable unencrypted on port 8000, and the first visitor can create the admin account. With your own domain, closed ports, two-factor authentication and encrypted backups, the risk is well manageable.
Can I run Coolify and my apps on the same server?
Yes, that is the standard for small setups. Coolify then manages itself as “localhost”. For more stability you can later connect a second server just for apps. Builds then run there and do not load the dashboard.
What happens to my apps if Coolify crashes?
They keep running. In our test we stopped all Coolify containers, and the deployed app answered without interruption. Without Coolify there are simply no new deploys, no webhooks and no scheduled backups until the dashboard is back.
Does Coolify support zero-downtime deployments?
Yes, but only under certain conditions. If the app maps a port directly to the host, rolling updates are not possible; we measured about 1.2 seconds of downtime. With a domain through the proxy and a health check path, Coolify starts the new container next to the old one and only switches once it is healthy.
Why are Coolify images so large?
Because of the default build pack, Nixpacks. It builds on a general-purpose base image with Nix and installs the full runtime. Our small Node app ended up at 1.04 GB. With your own multi-stage Dockerfile on an Alpine base image, the image gets much smaller.
Should I enable automatic updates in Coolify?
We recommend turning them off. Coolify releases at a high cadence — in November 2026, six versions within a little over 27 hours. Apply updates deliberately, a few days after release and after a fresh backup.
Coolify or Dokploy?
Both aim for the same thing. Coolify is older, has more one-click services and a larger community. Dokploy is younger and leans more heavily on Docker Swarm. We have not tested Dokploy ourselves. If you have already found Coolify guides that fit your project, that is a good reason to go with Coolify.
Can I move away from Coolify later?
Yes, and that is a big advantage over closed platforms. Your apps are ordinary Docker containers, your databases live in ordinary volumes. You can write your own compose files and switch Coolify off at any time. Plan time for it, though: proxy, certificates and backups are then your job.
Conclusion: our Coolify review in one sentence
Coolify is the most comfortable way to use your own servers like a cloud platform — but it does not take operations off your hands; it hides them behind a nice dashboard. Our measurements show both sides: 77 seconds from repository to running app, a clean rollback on a broken deploy, and apps that keep running without Coolify. On the other side: a green “finished” for an app that is not running, a 2 GB disk baseline, and nightly auto-updates in a project that shipped four versions in a single day.
If you apply the six settings from our checklist (domain instead of port 8000, health check, no port mapping, auto-update off, two-factor, backups), you get a platform that can keep up with Vercel for small and medium projects at a fraction of the cost. If you do not want that, a managed provider is the more honest choice. An overview of those options is in our article Vercel Alternative.