Coolify on a VPS: deploy your apps from Git

Coolify is an open-source panel that brings the Heroku workflow to your own server: point it at a Git repository and it builds the image, runs the container, wires up the domain and requests the HTTPS certificate. It also runs databases and can drive other servers over SSH.

We installed it with the official script on a fresh VPS in Montréal, deployed a Node app from a public repository, timed the deployments and created a PostgreSQL database. Every number below comes from that machine, which we destroyed afterwards. The version installed was Coolify 4.6.0.

1. Which plan

Coolify's documentation asks for at least 2 cores, 2 GB of memory and 10 GB of disk, plus room for images, volumes and backups. Our Nano has the memory but a single vCPU, so it sits below the official minimum and we did not test it. The smallest plan that meets the requirements is Starter.

Keep the IPv4 address: Let's Encrypt and visitors without IPv6 need it. Our test ran on an hourly Starter with Ubuntu 24.04.

2. Install with the official script

The script runs as root. Give it the admin account up front: without these variables the sign-up page stays open on port 8000, and whoever reaches it first becomes the admin, with root access to the server.

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo env \
  ROOT_USERNAME=admin \
  ROOT_USER_EMAIL=you@example.com \
  ROOT_USER_PASSWORD='A-long-password-1!' \
  bash

The password needs an uppercase letter, a lowercase letter, a digit and a symbol. On our Starter the install took 3 min 1 s: 1 min 7 s for Docker Engine, 1 min 7 s to pull Coolify's images, 42 s to start. Afterwards /register redirected to /login: sign-up was closed.

The script then prints the panel address, http://your-ip:8000, and tells you to copy /data/coolify/source/.env off the server. Do it: that file holds the keys that encrypt Coolify's secrets.

3. What Coolify takes when idle

Measured one minute after the install, with no app deployed:

So Coolify costs about 640 MB of memory and 2.8 GB of disk before your first deployment. The main container (the Laravel app) accounts for 392 MB on its own; its PostgreSQL uses 37 MB, the Traefik proxy 19 MB, Redis 5 MB. On 4 GB, close to 3 GB is left for your apps.

4. Deploy an app from Git, with HTTPS

We used Coolify's official Node example, a small Fastify API in the public coollabsio/coolify-examples repository. In the UI: new project, new resource, “Public Repository”, then the repository URL, the main branch, the base directory /javascript/runtimes/nodejs and port 3000. We did it through Coolify's API so the timing would be clean:

curl -X POST http://your-ip:8000/api/v1/applications/public \
  -H "Authorization: Bearer $COOLIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"project_uuid":"…","server_uuid":"…","environment_name":"production",
       "git_repository":"https://github.com/coollabsio/coolify-examples",
       "git_branch":"main","base_directory":"/javascript/runtimes/nodejs",
       "build_pack":"nixpacks","ports_exposes":"3000",
       "domains":"https://app.example.com","instant_deploy":true}'

You create the token in the UI once the API is enabled in the settings. For HTTPS, all it takes is a domain whose A record points at the VPS's IPv4 and an https:// address in the domain field: Traefik requests the Let's Encrypt certificate and redirects HTTP to HTTPS.

First deployment: 2 min 44 s from the request to the end of the deployment. Building the image took 2 min 29 s of that, including 75 s to install Node through Nix (Coolify builds with Nixpacks by default, no Dockerfile needed) and 30 s to export the image. The Let's Encrypt certificate was in place 13 seconds later, so the app answered over HTTPS 2 min 57 s after the request.

One trap in this example: it has an /env route that returns every environment variable of the container. Handy to check a configuration, dangerous the moment a database password lands there. Remove it before you build on this example.

5. Redeploying: 11 seconds to two and a half minutes

The everyday case is the third row: a new commit reuses the layers already built (Node, system packages) and only redoes the code copy and npm ci. You trigger a deployment from the UI, from a repository webhook, or from the API:

curl -X POST "http://your-ip:8000/api/v1/deploy?uuid=APP_UUID&force=false" \
  -H "Authorization: Bearer $COOLIFY_TOKEN"

Coolify swaps the container without downtime: it starts the new one, lets the proxy route traffic to it, then stops the old one. During the new-commit redeploy we hit the site every half second: 52 requests, 52 responses with status 200.

6. A PostgreSQL database in 17 seconds

In the same project, “New Resource”, then PostgreSQL. Through the API, the database was running 17 s after the request, on PostgreSQL 16.15 with a generated password. Coolify returns an internal URL of this shape:

postgres://postgres:PASSWORD@DATABASE_UUID:5432/postgres

The database is not published to the Internet: port 5432 stays on the coolify Docker network that the apps share. From the Node container, a TCP connection to that name succeeded; put the URL in a DATABASE_URL variable of the app and you are done. The data lives in a Docker volume on the VPS disk. Coolify offers scheduled database backups, to the server or to S3 storage; we did not test them here.

With the app and the database running, the machine used 1250 MB of memory and 7.5 GB of disk, 1.6 GB of it build cache after three builds.

7. Coolify or Easypanel

Our VPS can be delivered with Easypanel preinstalled. Both panels cover the same basics (Docker, Git, domains, HTTPS, databases); they part ways elsewhere.

Pick Easypanel if you want a panel that is ready without installing anything, on the smallest machine, for a few sites or templates. Pick Coolify if you want open-source software that is free when you host it, an API to plug into your CI, or several servers managed from one place. Our image catalogue also has a coolify entry (see the image list); this article sticks to the official script, which is what we measured.

8. The limits

• The panel is exposed over plain HTTP. After the install, ports 8000 (panel), 6001 (real-time updates) and 6002 (web terminal) listen on every address, unencrypted. The proxy also publishes port 8080 (its dashboard, which we found disabled). Give the panel an HTTPS domain, then close 8000, 6001 and 6002, as Coolify's documentation recommends, and 8080 as well.
• UFW is not enough. Docker writes its own rules and a published port walks through UFW (here is why). Filter with the cloud firewall instead: 22 for your addresses, 80 and 443 for everyone.
• Updates are automatic. On our instance, auto-update was on by default, every day at 00:48 UTC. Convenient, but a new release can change behaviour overnight. Turn it off in the settings if you would rather pick the moment, and read the release notes before updating.
• Memory and disk. Coolify's 640 MB are taken all the time. Builds use more for a few minutes and leave cache behind: Coolify cleans Docker every night and whenever the disk passes 80 %, but on 40 GB, keep an eye on space once apps pile up.
• One server is one point of failure. Panel, apps and databases share the same machine. Keep Coolify's .env file and database backups off the server.

The whole test took 23 minutes on an hourly Starter, billed one hour: 0.033 CAD.