Coolify: A Self-Hosted Heroku That Actually Delivers

Deploying a side project should not require a PhD in Kubernetes. You have a Git repository, you want it running on your server with HTTPS, and you do not want to manually SSH in, pull code, rebuild containers, and restart services every time you push a commit.

Coolify is a self-hosted platform-as-a-service (PaaS) that gives you the deployment experience of Heroku or Vercel — push code, get a running app — on your own infrastructure. It handles Git integration, Docker builds, SSL certificates, databases, and one-click app deployments through a clean web UI.

What Coolify Does

• Git-based deployments: Push to GitHub/GitLab/Gitea and Coolify builds and deploys automatically
• One-click services: Deploy databases (Postgres, MySQL, Redis, MongoDB), apps (WordPress, Ghost, Plausible), and tools with a single click
• Automatic HTTPS: Let's Encrypt certificates provisioned and renewed automatically
• Docker and Docker Compose support: Deploy any Dockerized application
• Nixpacks builds: Auto-detect your app's language and build it without a Dockerfile
• Multi-server: Deploy to remote servers from a single Coolify instance
• Previews: Deploy pull request preview environments automatically
• Monitoring: Basic resource monitoring for deployed services

Coolify vs. Dokku vs. CapRover

When to choose Coolify

• You want a modern UI for managing deployments
• You need multi-server support from a single control panel
• You want built-in database management with backup and restore
• You deploy Docker Compose applications
• You want PR preview environments

When to choose Dokku

• You prefer CLI-based workflows and hate GUIs
• You want the most battle-tested, stable option
• You're comfortable with a Heroku-like git push workflow
• You want minimal resource overhead
• You value simplicity over features

When to choose CapRover

• You want a web UI but Coolify feels too new
• You need a one-click app store for common services
• You don't need Docker Compose support
• You want something that has been stable for years

Dokku is the veteran. CapRover is the reliable middle ground. Coolify is the modern upstart with the most features and the most active development.

Installation

Coolify has a one-line installer. On a fresh server (Ubuntu 22.04/24.04, Debian 12, or Fedora recommended):

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

This installs Docker if needed, pulls the Coolify containers, and starts everything. The installer creates a docker-compose.yml at /data/coolify/docker-compose.yml.

What it deploys

Coolify UI + API        → Port 8000 (HTTP)
Coolify Proxy (Traefik) → Ports 80, 443
PostgreSQL              → Internal (Coolify's database)
Redis                   → Internal (job queue)

After installation, visit http://your-server-ip:8000 to create your admin account.

Manual Docker Compose setup

If you prefer not to run the one-line installer, the Compose file is available at the Coolify GitHub repository. The core structure:

services:
  coolify:
    image: ghcr.io/coollabs/coolify:latest
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - /data/coolify/ssh:/data/coolify/ssh
      - /data/coolify/applications:/data/coolify/applications
      - /data/coolify/databases:/data/coolify/databases
      - /data/coolify/backups:/data/coolify/backups
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - APP_URL=https://coolify.yourdomain.com
      - DB_PASSWORD=${DB_PASSWORD}
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    volumes:
      - coolify_db:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: coolify

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - coolify_redis:/data

volumes:
  coolify_db:
  coolify_redis:

Note that Coolify needs access to the Docker socket because it manages containers on your behalf. This is a security consideration — Coolify effectively has root access to your server.

Deploying Your First Application

From a GitHub repository

1. Go to Projects → Add New Resource → Public Repository (or connect your GitHub account for private repos)
2. Enter the repository URL
3. Coolify auto-detects the build method:
   • Nixpacks: For Node.js, Python, Go, Rust, PHP, Ruby, and more — no Dockerfile needed
   • Dockerfile: Uses your existing Dockerfile
   • Docker Compose: Uses your docker-compose.yml
4. Set the domain (e.g., myapp.yourdomain.com)
5. Click Deploy

Coolify builds the app, starts the container, configures the reverse proxy, and provisions an SSL certificate. Your app is live.

Automatic deployments

Connect your GitHub account and enable webhooks:

1. Settings → Sources → Add GitHub App
2. Follow the OAuth flow to install the Coolify GitHub App
3. For each project, enable Auto Deploy — every push to the configured branch triggers a build

PR preview environments

Enable Preview Deployments on a project. Every pull request gets its own deployment at a unique URL (e.g., pr-42-myapp.yourdomain.com). The preview is automatically deleted when the PR is merged or closed.

This is genuinely useful for teams reviewing changes.

One-Click Services

Coolify's service catalog includes databases and popular applications:

Databases

• PostgreSQL, MySQL/MariaDB, MongoDB, Redis
• ClickHouse, CockroachDB, EdgeDB, SurrealDB

Applications

• WordPress, Ghost, Plausible Analytics
• Gitea, Minio, Uptime Kuma
• Grafana, n8n, Appwrite
• And dozens more

Each one-click service is deployed with sensible defaults. You get environment variable management, persistent volumes, and backup configuration through the UI.

Database management

This is one of Coolify's strong points. For each database:

• Connection strings are displayed in the UI
• Scheduled backups can be configured (daily, weekly)
• Backup to S3 is supported (or any S3-compatible storage)
• One-click restore from backups

Domain and SSL Management

Coolify uses Traefik as its reverse proxy. For each deployed service:

1. Set the domain in the service settings
2. Coolify automatically configures Traefik routing
3. Let's Encrypt certificates are provisioned on first request
4. Renewal happens automatically

You need your DNS pointing to your Coolify server. For multiple services:

• myapp.yourdomain.com → Your app
• db.yourdomain.com → Database admin (if exposed)
• coolify.yourdomain.com → Coolify's own UI

A wildcard DNS record (*.yourdomain.com → your-server-ip) simplifies this.

Multi-Server Deployments

Coolify can manage deployments across multiple servers:

1. Servers → Add Server
2. Provide the server's IP and SSH key
3. Coolify installs Docker on the remote server
4. Deploy projects to any connected server

This is useful for:

• Separating production from staging
• Running databases on a dedicated server
• Distributing load across machines

The control plane (Coolify UI) runs on one server and orchestrates deployments to others via SSH.

Resource Requirements

Coolify itself

Server sizing

The total resources needed depend on what you deploy:

• Small homelab (2-3 apps): 2 GB RAM, 2 cores, 20 GB disk
• Medium (5-10 apps + databases): 4-8 GB RAM, 4 cores, 50 GB disk
• Heavy (10+ apps, CI builds): 8-16 GB RAM, 4-8 cores, 100+ GB disk

Docker image builds are the most resource-intensive operation. If builds are slow, more CPU and RAM help the most.

Environment Variables and Secrets

Coolify provides a UI for managing environment variables per service:

• Build-time variables: Available during the build step
• Runtime variables: Available when the container runs
• Shared variables: Reusable across multiple projects

Variables are stored encrypted in Coolify's database. You can bulk-edit them or paste a .env file directly.

Monitoring and Logs

Coolify provides basic monitoring:

• Container logs: View stdout/stderr in real-time from the UI
• Resource usage: CPU, memory, and disk usage per container
• Deployment history: See all past deployments with build logs and status

For production monitoring, you will still want a dedicated solution (Grafana, Uptime Kuma, etc.), but Coolify's built-in tools are sufficient for debugging and casual oversight.

Honest Limitations

• Docker socket access: Coolify needs /var/run/docker.sock mounted, which effectively gives it root access. Don't run Coolify on a server with sensitive workloads you don't want it to touch.
• Active development, occasional instability: Coolify moves fast. Updates can occasionally introduce bugs. Pin to a specific version in production rather than using latest.
• Traefik conflicts: If you already run Traefik on the server, Coolify's built-in Traefik will conflict on ports 80/443. You can disable it and use your own, but configuration is more involved.
• No Kubernetes: Coolify is Docker-only. If you need Kubernetes, look elsewhere.
• Build cache can grow: Docker build cache and old images accumulate. Set up periodic docker system prune or Coolify's built-in cleanup.
• Single point of failure: If the Coolify server goes down, you cannot deploy. Your running services continue working (they are just Docker containers), but management and deployments stop.

Backup Strategy

1. Coolify's database: Back up /data/coolify/ — this contains all configuration, project settings, and secrets
2. Application data: Coolify stores persistent volumes under /data/coolify/. Back up this entire directory.
3. Database backups: Use Coolify's built-in S3 backup for managed databases
4. Git repos are your source of truth: Application code lives in Git. The worst case is re-deploying from scratch, which Coolify makes easy.

The Bottom Line

Coolify is the most complete self-hosted PaaS available today. It gives you a genuine Heroku/Vercel-like experience — push code, get a deployed app — without sending your code to a third party or paying per-dyno pricing.

The trade-off is that it is younger software with a faster release cycle, which means occasionally rough edges. But the fundamentals are solid: Git-based deployments work, databases are well-managed, SSL is automatic, and the UI is genuinely pleasant to use.

If you're self-hosting side projects and tired of manually managing Docker containers via SSH, Coolify is worth the 10-minute setup.

Resources

• Coolify documentation
• Coolify GitHub
• One-click services list
• Coolify Cloud — hosted version if you want to try before self-hosting
• Community Discord — active community for support