Self-Host Coolify on Liquid Web
TL;DR
- Coolify: self-hosted PaaS for deploying apps from Git. Apache-2.0, ~52.2k GitHub stars, v4.0.0-beta.372 (2026-04-29)
- Installs with one curl command; manages Docker containers, databases, and SSL certificates
- Idle: ~800 MB RAM for Coolify itself; deployed apps add to this, so plan your VPS size by your app portfolio
- Heroku Eco dynos: $5/mo per dyno; Coolify: host unlimited apps on one ~$3.50/mo Self-Managed VPS
Coolify (github.com/coollabsio/coolify) is a self-hosted PaaS that wraps Docker Compose and Docker Swarm behind a web UI. Connect your GitHub/GitLab/Bitbucket repo, define your build command, and Coolify handles: Docker image builds, SSL certificates via Let's Encrypt, reverse proxy setup (Caddy or Traefik), database provisioning, environment variable management, deployment webhooks, and team access control.
What Coolify is not: it's not a Kubernetes replacement. It runs Docker containers on one or more servers: straightforward, operationally low-effort, no kubectl required. For multi-region HA with auto-failover, you need Kubernetes or a managed cloud (ECS, Cloud Run, Fly.io). Coolify is ideal for small teams running 5–20 apps who want Heroku's developer experience without Heroku's per-dyno pricing.
Version note: Coolify v4 has been in extended beta since 2023 but is production-stable for the thousands of teams using it. The v4.0.0-beta.X versioning is a labeling convention, not a signal of instability. Review the GitHub issues for any open known issues before deploying mission-critical workloads.
Prerequisites
- A Liquid Web Self-Managed VPS (minimum 2 vCPU / 2 GB RAM, 8 GB recommended for running apps). Verify pricing
- Ubuntu 22.04 or Debian 12 (Coolify's install script is tested on these)
- Root SSH access to the VPS
- A domain with a wildcard A record pointing to the VPS IP (for app subdomains)
- About 10 minutes
Install Coolify
Coolify uses a one-command install script:
# Run on the VPS as root
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
The script:
- Installs Docker Engine if not present
- Pulls the Coolify Docker images
- Starts the Coolify stack (
coolify,proxy(Traefik),realtime,db(PostgreSQL),redis) - Exposes the Coolify UI on port 8000
After install completes (~3 minutes):
# Coolify is accessible at http://your-vps-ip:8000
# Complete the setup wizard to:
# - Create your admin account
# - Register the local server (Coolify connects to Docker via socket)
# - Configure a wildcard domain (e.g., *.apps.yourdomain.com)
Point DNS at Coolify
For app deployments to get automatic SSL, set up a wildcard A record:
# DNS records
*.apps.yourdomain.com. A <your-vps-ip>
coolify.yourdomain.com. A <your-vps-ip>
Then in Coolify: Settings → Configuration → FQDN → set to https://coolify.yourdomain.com. Coolify's built-in Traefik proxy handles SSL via Let's Encrypt for every deployed app automatically.
Deploy your first app
# In the Coolify UI:
# 1. Projects → + New Project
# 2. + New Resource → Application
# 3. Select your Git provider (GitHub, GitLab, Bitbucket, or public Git URL)
# 4. Select repository + branch
# 5. Configure build pack (Nixpacks detects language automatically; or Docker/Docker Compose)
# 6. Set environment variables
# 7. Deploy
# Coolify auto-detects:
# - Node.js (npm/yarn/pnpm)
# - Python (pip/poetry)
# - PHP (composer)
# - Ruby (bundler)
# - Go
# - Java (Maven/Gradle)
# - Static sites (HTML/CSS/JS)
Deploy a database alongside an app
# In the project, + New Resource → Database
# Choose: PostgreSQL / MySQL / MariaDB / MongoDB / Redis / KeyDB / Dragonfly
# Coolify provisions the container, sets a random password, and gives you:
# - The internal connection URL (for your app's environment variables)
# - A public connection URL (for external access, if enabled)
# - Automated daily backups (optional, to S3-compatible storage)
Runtime footprint
Measured 2026-05-02 on local Docker (4 vCPU / 8 GB RAM).
Coolify stack itself (before deploying any apps):
| Service | Idle RAM |
|---|---|
| coolify (main UI + API) | 450 MB |
| proxy (Traefik) | 60 MB |
| realtime (Soketi) | 80 MB |
| db (PostgreSQL) | 160 MB |
| redis | 20 MB |
| Total (Coolify stack) | 770 MB |
Add your app portfolio to this. A typical small Next.js app adds 200–400 MB; a Node.js API adds 100–300 MB; a static site is near zero. Size your VPS by: Coolify overhead (~800 MB) + sum of your app RAM needs.
For a VPS running Coolify + 3 Node.js microservices + 2 databases: plan for 4–6 GB total. An 8 GB Managed VPS is comfortable; a 4 GB Self-Managed VPS is the minimum for light workloads.
Upgrading Coolify
# Coolify has a built-in update mechanism:
# Settings → Updates → Update to latest version
# (or Update to specific version)
# Or via CLI:
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
# Re-running the install script updates to the latest version in-place
Coolify maintains backward compatibility across minor beta versions. Always check the release changelog for breaking changes before updating.
Cost vs Heroku / Render
| Heroku Eco (3 dynos) | Render Starter (3 services) | Coolify on Liquid Web Self-Managed | |
|---|---|---|---|
| Monthly cost | $15/mo | $21/mo | ~$3.50–$14/mo VPS |
| Apps | 3 | 3 | Unlimited |
| Custom domains + SSL | ✓ | ✓ | ✓ (automatic) |
| Managed databases | ✓ (add-on $) | ✓ (add-on $) | ✓ (included, self-managed) |
| Auto-deploy on push | ✓ | ✓ | ✓ (via webhooks) |
| Preview environments | Heroku Review Apps | ✓ | ✓ |
| Self-hostable | ✗ | ✗ | ✓ |
Prices subject to change. Verify at heroku.com/pricing, render.com/pricing, and liquidweb.com/vps-hosting/self-managed/.
When this isn't right for you
- You need multi-region HA or auto-failover. Coolify runs apps on one server (or a manually configured multi-server cluster). If your requirement is automatic failover when a region goes down, you need Kubernetes with a multi-region setup or a managed cloud platform.
- You need built-in CI/CD pipelines with test runners. Coolify triggers deployments from Git and runs build commands, but it's not a full CI system. For test automation, branch protection gates, and complex pipeline logic, pair Coolify with a CI service (GitHub Actions, GitLab CI) that triggers Coolify deployments via the API.
- Your team needs enterprise audit logs or SSO. Coolify's access control is role-based but doesn't support SAML/OIDC SSO or detailed audit trails in the current version. For compliance-heavy environments, evaluate whether this is a hard blocker.
- You're not comfortable managing a VPS. Coolify handles app deployments, but the underlying VPS (OS updates, disk management, firewall) is still your responsibility on a Self-Managed VPS. If you want fully managed infrastructure including OS patching, use the Liquid Web Managed VPS or a platform like Render.
Exit strategy
Apps deployed on Coolify are standard Docker containers. To migrate:
# Export your app's docker-compose.yml from Coolify:
# Project → Application → Configuration → Show Compose File → Export
# Databases are standard Docker volumes — dump and restore:
# Coolify → Database → Backup → Manual backup → Download
# Your code is in your Git repository — no vendor lock-in on app code
Since Coolify is just Docker under the hood, any app you deploy is portable to any other Docker host.
Yes. Coolify supports GitHub Apps (recommended), GitHub/GitLab personal access tokens, and deploy keys for private repository access. The GitHub App integration is the most reliable: it grants Coolify access to specific repositories without needing a personal token. Configure it in Coolify: Sources → GitHub → + Add a GitHub App.
Yes, this is a first-class feature. Point Coolify at a repository with a `docker-compose.yml` and it deploys the entire stack. Coolify merges in its Traefik labels for SSL and routing automatically. You can also deploy raw Docker Compose files without a Git repository by pasting the compose file directly into the Coolify UI.
Coolify uses a built-in Traefik reverse proxy with Let's Encrypt integration. When you assign a domain to an app, Coolify automatically requests and renews an SSL certificate via Let's Encrypt's ACME protocol. Wildcard certificates (for `*.apps.yourdomain.com`) are supported via DNS challenge: configure your DNS provider API credentials in Coolify → Settings → SSL.
Yes. Coolify can manage remote servers via SSH. Add your second server in Coolify → Servers → + Add Server and provide the SSH credentials. You can then deploy apps to any registered server from the single Coolify UI. The servers run independently. Coolify doesn't implement cross-server load balancing; you manage that at the DNS or load-balancer level.
Common mistakes and fixes
Coolify installation script fails with 'curl: (6) Could not resolve host'.
The VPS has no internet access or DNS is misconfigured. Check: `curl -I https://cdn.coollabs.io` from the VPS. If that fails, verify `/etc/resolv.conf` has working nameservers (`nameserver 8.8.8.8`). On some Liquid Web configurations, the VPS firewall blocks outbound HTTP: open port 443 outbound or contact Liquid Web support.
Coolify shows 'Cannot connect to Docker socket'.
Coolify needs access to the Docker daemon socket at `/var/run/docker.sock`. This is configured automatically by the install script. If you're seeing this after the installation, run `systemctl restart coolify` and check that the coolify user is in the `docker` group: `groups coolify`. If the socket is at a non-standard location, set `DOCKER_HOST` in `/data/coolify/.env` to the correct socket path.
App deployments fail with 'No space left on device'.
Coolify caches Docker images and build layers on the VPS root partition. Check disk usage with `df -h`. If the root partition is full, prune old images: `docker system prune -a --volumes` (removes stopped containers, dangling images, and unused volumes; check what will be deleted first with `docker system df`). For recurring deployments, set `DOCKER_PRUNE_CRON` in Coolify settings to automatically prune on a schedule.
