Install

The official installer expects a fresh Debian/Ubuntu box with Docker installable. It will install Docker for you if missing:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

The script:

  1. Installs Docker, Docker Compose, jq, openssl, etc.
  2. Pulls and runs the Coolify control-plane stack (PHP/Laravel app + Postgres + Redis + Soketi for websockets).
  3. Generates secrets, writes them to /data/coolify/.env.
  4. Starts the UI on port 8000 (HTTP) and exposes a self-signed cert endpoint on 8443.

Browse to http://<ip>:8000, create the admin user. The first user created is the root admin; subsequent signups can be turned off in Settings.

Add your first server

Coolify can deploy to the host it's running on, to remote VPSes via SSH, or to a Docker Swarm/k8s if you want to scale later. The simplest start is to deploy to the local host:

  1. Servers → Add a New Server → "localhost" pre-filled.
  2. The server's SSH key is auto-generated; the install script already added it to ~root/.ssh/authorized_keys on this host.
  3. Click "Validate Server & Install Docker Engine." Within a couple of minutes it reports "Ready."

To add a remote VPS later: paste its IP and SSH user, copy the displayed public key into the VPS's authorized_keys, validate.

Add a project and a Git source

Projects → Add → name it. A project is a logical container for related resources (apps, databases, services).

Sources → Add a Source → pick GitHub App / GitHub OAuth / GitLab / Gitea / Bitbucket. The GitHub App is the smoothest path: Coolify generates the manifest, you install the app on the org/account, webhooks for "branch X pushed" land at Coolify automatically.

Deploy a Git repo

  1. Inside the project: Add a New Resource → Application → pick the Git source.
  2. Select the repo and branch.
  3. Build Pack — Coolify auto-detects, but the options are:
    • Nixpacks — zero-config, detects language, builds an OCI image. Works for most Node/Python/Go/Rust/PHP apps.
    • Static — for built static site output (Astro/Hugo/Next-export). Specify a build command and output directory.
    • Dockerfile — uses the repo's Dockerfile.
    • Docker Compose — uses docker-compose.yml from the repo.
  4. Ports exposed: pick the container port (e.g. 3000 for Node).
  5. Domain: pick a subdomain. Coolify points DNS for you only if it manages your DNS; otherwise create an A/CNAME pointing at the server.
  6. Click Deploy.

The Deployments tab streams the build log. First build for a typical Node app takes 2–5 min; subsequent rebuilds are seconds thanks to layer caching.

Auto-deploy on push

If the Git source is connected via webhook, "auto-deploy on push to <branch>" is one checkbox. Each push triggers a rebuild + atomic swap; if the new container fails health checks within a configurable window, Coolify rolls back to the previous image.

Databases

In the project: Add a New Resource → Database → Postgres / MySQL / MariaDB / MongoDB / Redis / KeyDB / Dragonfly / Clickhouse. Coolify spins up a managed-style instance:

  • Generated credentials shown once; rotatable from the UI.
  • Volume mounted at a stable host path.
  • Internal DNS name (e.g. postgresql-app:5432) that other apps in the same project can resolve.
  • One-click backups to S3 / B2 / local on a schedule.

To use it from an app, set DATABASE_URL=postgresql://user:pass@postgresql-app:5432/dbname in the app's environment.

Domain and SSL

Coolify uses Traefik as its edge proxy. Each app/service has a Domain field; Traefik requests a Let's Encrypt cert via HTTP-01 the first time the domain resolves to this server. Wildcard certs need a DNS provider configured (Settings → Server → Traefik → DNS challenge), with the provider's API token.

One-click services

Services → New Resource → pick from a library of 70+ pre-configured stacks: Plausible, Umami, Ghost, Outline, n8n, Wordpress, Strapi, Directus, MeiliSearch, MinIO, Vaultwarden, Authentik, Grafana, Uptime Kuma, Filebrowser, Penpot, and many more. Each is a curated docker-compose with sane defaults; Coolify wires the domain and storage.

Backups

Two layers:

  1. Coolify's own state — /data/coolify/ contains the control-plane database, secrets, SSH keys, and configuration. A restic backup of that directory is sufficient to rebuild Coolify on a fresh box.
  2. App / database volumes — each managed database has built-in scheduled backup to S3/B2. App-level volumes (file uploads, sqlite, etc.) need a separate restic job pointed at the Docker volume mount.

Caveats worth knowing

  • Coolify owns the Docker daemon on connected servers. Don't mix manually-run containers with Coolify-managed ones on the same host without understanding labels — Coolify's Traefik label scheme can collide.
  • The control plane is the single point of failure for management; data-plane apps keep running if the control plane stops, but new deploys/rollbacks don't.
  • For multi-node setups, Coolify supports Docker Swarm out of the box; Kubernetes support exists but is much less mature than the single-host case.

When Coolify is the wrong tool

If "kubectl apply" is already the deploy story you want, K3s (that tutorial) is closer to the metal. If the goal is to declare infra in code, NixOS or Terraform are more honest. Coolify shines when the goal is specifically "feel like Heroku, on hardware you own" — that's exactly what it does, and it does it well.