Coolify: Self-Hostable PaaS for Apps and Databases

What Coolify is

Coolify is an open-source, self-hostable platform for deploying applications, databases and services on your own servers. The README positions it as an alternative to Heroku, Netlify and Vercel: you get the push-to-deploy convenience of a hosted platform, but the workloads run on hardware you control, and the only thing Coolify needs to manage a machine is an SSH connection.

That machine can be a VPS, a bare-metal server, a Raspberry Pi or any other Linux box that accepts SSH. The project stresses that your configuration stays on your servers, and that if you stop using Coolify, the resources it deployed keep running and remain manageable. It is aimed at developers, small teams and agencies who want to run several apps, databases and side services without paying per-app platform prices or hand-writing Docker and reverse-proxy configuration for each one.

The project describes itself as "open source & free forever" and licenses the code under Apache-2.0. Alongside the self-hosted version there is Coolify Cloud, a paid instance maintained by the Coolify team.

How it works

Coolify's documentation explains its model through a handful of concepts:

• Servers are the machines Coolify manages, physical or rented. The recommended self-hosted layout is one server for Coolify itself and one or more servers for the resources you deploy.
• Resources are the things you run: a website, a database, an API or a one-click service. Each resource carries its own domains, backups, health checks and other settings.
• Environments such as development and production can live side by side on the same server.
• Projects are the top-level grouping of environments and resources, so hobby and work deployments can be kept apart.

Everything Coolify deploys runs as a Docker container. You can deploy a prebuilt image from a registry such as Docker Hub or GitHub Container Registry, or let Coolify build an image from your repository. The docs warn that building on the server is resource-heavy and suggest building elsewhere, pushing to a registry and letting Coolify deploy the image when the server is small.

Traffic reaches containers through a reverse proxy. Coolify ships with two proxy options, Caddy and Traefik, which route requests by domain so many applications can share one server without port juggling. When you enter a domain with https://, the proxy requests a certificate from Let's Encrypt and renews it automatically. The self-hosted instance itself is a set of containers (the app, a Postgres database, Redis, a proxy and a Sentinel monitoring container), with configuration, SSH keys and deployment files stored under /data/coolify.

Key features

• Deploy from Git: build from GitHub, GitLab, Bitbucket or Gitea using Nixpacks, Railpack, a Dockerfile, Docker Compose or a prebuilt image.
• Databases and one-click services: managed databases and more than 360 one-click services with persistent storage and generated credentials.
• Deployment automation: deploy on every Git push, create pull-request preview deployments, trigger deployment webhooks and roll back to retained application images.
• Networking: custom domains, automatic HTTPS certificates, reverse proxies, health checks and container networks.
• Operations: manage multiple servers, read deployment and runtime logs, open terminals into containers and monitor resource status.
• Protection: database and storage backups, scheduled tasks, environment variables, secrets and notifications.
• Integrations: manage resources through the dashboard, an API, a CLI, MCP and team-based access controls.

Getting started

The documentation's short version: a server with 2 CPU cores, 2 GB of RAM and 10 GB of free disk can run Coolify, installed with one command as root or a sudo-capable user:

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

According to the docs, the script installs required packages (curl, wget, git, jq, openssl), installs Docker Engine where the distribution supports it, configures Docker logging and daemon settings, creates the directories under /data/coolify, sets up SSH keys for server management and starts Coolify. The script's source is linked from the README so it can be reviewed before running it.

When the installer finishes it prints the dashboard address, which is http://<server-ip>:8000. Two steps matter immediately afterwards. First, create the admin account right away: the docs warn that anyone who reaches the registration page first can become the instance admin and gain root access to the server. Second, back up /data/coolify/source/.env, which holds installation secrets such as APP_KEY used to encrypt values in Coolify's database and is required to restore from a backup.

A manual installation path exists for non-root users, existing Docker hosts and custom networks; it requires curl and Docker Engine 24 or newer. On the firewall side, the Coolify server needs 22 for SSH, 80 and 443 for proxied traffic, and 8000, 6001 and 6002 for the dashboard, real-time updates and web terminal when accessed by IP. Once the dashboard is served through a domain, the docs say the last three can be closed to the public.

Use cases

• Replacing per-app PaaS bills: run several web apps, APIs and their databases on one or two VPS instances with Git-push deployments and automatic certificates.
• Preview environments: spin up pull-request previews for a frontend or full-stack app without a hosted preview service.
• Self-hosting supporting tools: deploy analytics, monitoring, CMS or automation tools from the one-click service catalogue next to your own apps.
• Agency and client hosting: separate clients into projects and environments on servers you control, with team access to the dashboard.
• Homelab and Raspberry Pi setups: Coolify supports 64-bit Raspberry Pi OS on ARM64 hardware.

How it compares

Coolify explicitly compares itself to Heroku, Netlify and Vercel. The trade is the usual one for self-hosting: you avoid platform pricing and vendor lock-in, and your workloads keep running if you uninstall Coolify, but you take on server maintenance. Compared with writing Docker Compose files and Traefik or Caddy labels by hand, Coolify adds a dashboard, Git integration, previews, backups and a service catalogue on top of the same building blocks. Compared with Kubernetes-based platforms, it targets a simpler model of individual servers managed over SSH rather than a cluster scheduler. For teams that do not want to run the control plane, Coolify Cloud manages the Coolify instance while your apps still run on your own servers.

Things to know before adopting

• Server security is on you: the concepts page states plainly that Coolify does not manage your server's security or updates.
• Lock down registration: create the admin account immediately after installing, since the first registrant gets admin and effectively root on the server.
• Back up the .env file: without /data/coolify/source/.env an instance backup cannot be restored. An instance backup covers Coolify's own database, not the applications, databases or volumes you deploy.
• Linux only: supported bases include Debian/Ubuntu, Red Hat family, SUSE, Arch, Alpine and 64-bit Raspberry Pi OS. Non-LTS Ubuntu releases should use the manual install, and Docker installed via snap should be replaced.
• Size for builds: building images on the same server as Coolify can make a small server unresponsive; the docs recommend monitoring usage or building externally.
• Teams feature: the docs say multi-user teams are not yet fully polished for production use.
• Fresh server recommended: the installer changes Docker settings and directories, so the docs advise a clean machine.
• Uninstalling is manual: the uninstall guide walks through removing Coolify's containers, volumes, network and /data/coolify; deployed apps keep running, but removing the Coolify proxy stops its domain and TLS routing.

For example, the first uninstall step removes only Coolify's own control-plane containers:

docker rm -f coolify coolify-db coolify-redis coolify-sentinel

Project activity

As of October 2026 the coollabsio/coolify repository has about 63,900 stars. It was created in January 2021, is written mainly in PHP and is licensed under Apache-2.0. The latest release is v4.5.0, published on October 23, 2026, and the repository shows commits within the past day. The README lists a long roster of sponsors that fund development. Source is at github.com/coollabsio/coolify, the website at coolify.io and the documentation at coolify.io/docs.