How to Install Coolify on Ubuntu 24.04 — A Self-Hosted PaaS for Git Deploys, Databases, and One-Click Apps

Coolify turns a plain Ubuntu VPS into a full-featured platform-as-a-service. In roughly 25 minutes you can have an environment that deploys applications from a git push, spins up managed PostgreSQL or MySQL instances, provisions WordPress or Ghost with one click, and terminates TLS through Traefik with zero manual certificate handling. This tutorial walks through the entire installation on Ubuntu 24.04 LTS, from the first SSH connection to a production workflow that rivals Vercel, Netlify, and Heroku -- without the per-seat pricing or vendor lock-in.

Want a one-line deploy? Launch a Professional VPS and follow this guide end to end. The Professional plan gives Coolify enough headroom to host several applications and databases simultaneously.

Table of Contents

What is Coolify?

Coolify is an open-source, self-hosted platform-as-a-service built on top of Docker and Traefik. It gives you a polished web UI that deploys applications directly from a Git repository, manages databases and message queues as first-class resources, and offers a curated catalog of one-click open-source services. The entire control plane runs inside Docker containers on a single VPS, and every deployed workload is just another container that Coolify orchestrates, routes, and monitors on your behalf.

Under the hood, Coolify uses Nixpacks and buildpacks to detect application frameworks, Traefik for reverse proxying and TLS termination, and a PostgreSQL-backed coordinator for state. It supports Node.js, PHP, Python, Ruby, Go, Rust, Elixir, static sites, and arbitrary Dockerfiles -- effectively anything that can be containerized. It also manages databases natively: PostgreSQL, MySQL, MariaDB, MongoDB, Redis, KeyDB, Dragonfly, and ClickHouse can all be provisioned from the UI with encrypted credentials and optional S3 backups.

The typical users who benefit from Coolify are SaaS founders running 3-15 applications across a small VPS fleet, agencies hosting client sites and staging environments, internal tools teams who want GitOps-style deploys without adopting Kubernetes, and indie developers who have outgrown a single docker compose up workflow but do not want to pay Vercel-tier margins on every preview branch. If you have ever wished for a "Heroku I can run on my own box," that is precisely the problem Coolify was designed to solve.

Why Self-Host a PaaS Instead of Vercel, Netlify, or Heroku?

Managed PaaS platforms are fantastic for getting started, but the economics and constraints shift quickly as a project grows. Running a self-hosted PaaS like Coolify on a dedicated VPS offers a different trade-off profile:

• Flat, predictable cost -- A Professional VPS hosts unlimited applications, databases, and preview environments for a fixed monthly fee. There are no per-seat charges, no per-build-minute overage fees, and no egress bandwidth surprises.
• No bandwidth metering -- Vercel's Pro plan includes 1 TB of bandwidth; Netlify starts throttling after 100 GB. A typical VPS includes 32 TB or unmetered transfer at the same price point, which matters for image-heavy sites, API-heavy SaaS, and video content.
• True code and data ownership -- Your source code, secrets, and databases live on infrastructure you control. There is no vendor API to rate-limit you, no sudden pricing change, and no acquisition risk that forces a migration on someone else's timeline.
• Unrestricted long-running processes -- Vercel Functions have a 10-second default (60-second max) execution window. Netlify Functions cap at 10 seconds on the free tier. On Coolify you can run background workers, cron jobs, WebSocket servers, and multi-minute API calls without engineering around arbitrary limits.
• GDPR and data residency control -- When you choose an EU-region VPS, every byte of customer data stays in the EU. Data Processing Agreements become straightforward because there is only one processor -- the VPS provider -- not a chain of managed SaaS vendors.
• No cold starts -- Containers stay warm by default. First-request latency on an idle application is measured in milliseconds, not seconds.
• Freedom of runtime -- Deploy any language, any version, any native dependency. Need PHP 5.6 for a legacy app next to a Bun runtime for a new one? Both run side by side with no platform restrictions.

Cost Comparison: Self-Hosted Coolify vs. Managed PaaS

Prerequisites

Before you begin, make sure you have:

• A VPS running Ubuntu 24.04 LTS with root or sudo access. Debian 12 also works, but this guide targets Ubuntu.
• SSH access (built-in terminal on macOS/Linux, PuTTY or Windows Terminal on Windows).
• At least 4 GB of RAM (8 GB+ recommended once you start adding databases and one-click services).
• At least 40 GB of disk space -- Docker images, the Coolify database, and application volumes add up quickly.
• A registered domain name with DNS that you can edit. You will add an A record (and ideally a wildcard *) pointing to the VPS IP address. This is required for automatic TLS.
• Ports 22, 80, 443, and 8000 reachable from the internet on first setup.

Recommended Plan: Professional

For Coolify hosting a handful of production applications, a few databases, and staging environments, we recommend the Professional VPS plan:

- 6 vCPU cores

- 12 GB RAM

- 200 GB NVMe SSD

- 32 TB bandwidth

- EUR 19.99/month

This gives you comfortable headroom for 8-15 containerized services plus databases. Scale up to a larger plan later -- Coolify can also manage additional remote servers from the same control plane.

Connect to your server via SSH to get started:

ssh root@your-server-ip

Step 1: Update System Packages

Begin with a clean, patched system. This prevents the installer from pulling in mismatched Docker dependencies.

sudo apt update && sudo apt upgrade -y

Expected output (abbreviated):

Hit:1 http://archive.ubuntu.com/ubuntu noble InRelease
Reading package lists... Done
Building dependency tree... Done
Calculating upgrade... Done
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

If the kernel was updated, reboot and reconnect:

sudo reboot

Install a few baseline tools that the installer and later troubleshooting steps rely on:

sudo apt install -y curl wget git ca-certificates

Step 2: Run the Coolify Installer

Coolify ships an official one-line installer that bootstraps Docker Engine, creates the required directories under /data/coolify, writes the systemd units, and starts the control plane containers (Coolify itself, a PostgreSQL database, a Redis instance, SoketI for realtime, and a Traefik proxy).

Run the installer:

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

Expected output (abbreviated):

-------------
Welcome to Coolify Installer!
This script will install everything for you.
-------------
OK: Docker Engine is already installed, skipping...
OK: Docker Compose plugin is installed.
Creating directories...
Generating secrets...
Downloading required files from CDN...
Starting Coolify...
[+] Running 5/5
 Container coolify           Healthy
 Container coolify-db        Healthy
 Container coolify-redis     Healthy
 Container coolify-proxy     Started
 Container coolify-realtime  Healthy
Your instance is ready to use!
You can access Coolify through your Public IP: http://SERVER_IP:8000

The installer performs the following:

When the script finishes, note the public URL it prints. You will open this in a browser next.

Step 3: First Login and Registration

Open the URL from the previous step in your browser:

http://YOUR_SERVER_IP:8000

The first visit shows a Register form. This form creates the root administrator account. Whoever registers first owns the entire instance, so make sure this is you.

Fill in:

• Name -- your full name or team name
• Email -- will be used for login and (optionally) notifications
• Password -- at least 8 characters; use a password manager

• Projects -- groupings of related resources (for example, "acme-corp-production")
• Servers -- the VPS nodes Coolify can deploy to (initially just localhost)
• Sources -- Git providers (GitHub, GitLab, Bitbucket, Gitea)
• Destinations -- Docker networks/contexts where resources run
• Databases -- standalone database resources
• Services -- one-click open-source applications
• S3 Storages -- backup targets
• Notifications -- Discord, Slack, Telegram, email webhooks
• Keys & Tokens -- SSH keys and API tokens

Step 4: Configure Your Server

Coolify always includes a localhost entry under Servers that represents the machine it was installed on. Open it and walk through the checklist:

DNS Setup for the Wildcard Domain

In your DNS provider (Cloudflare, Route53, your registrar) add:

• A record: apps.example.com -> YOUR_SERVER_IP
• A record: *.apps.example.com -> YOUR_SERVER_IP

Verify propagation:

dig +short test.apps.example.com

Expected output:

YOUR_SERVER_IP

Secure the Coolify UI with a Domain

While you are editing DNS, also point a record like coolify.example.com -> YOUR_SERVER_IP. Then, inside Coolify, go to Settings -> Instance Settings and set the Instance FQDN to https://coolify.example.com. Coolify will automatically issue a Let's Encrypt certificate for the control panel and stop exposing the admin UI on port 8000.

Step 5: Deploy Applications from GitHub or GitLab

This is the core workflow. Once configured, every git push to a tracked branch triggers a rebuild and zero-downtime redeploy.

Connect a Git Source

Create a Project and Add an Application

What Happens Under the Hood

• Coolify clones the repository into /data/coolify/applications/<uuid>.
• Nixpacks inspects the code, chooses a base image, installs dependencies, and produces a deterministic image.
• The image is tagged and started as a container on the Docker bridge network.
• Traefik is reconfigured with a router that matches the app's FQDN and terminates TLS.
• A healthcheck waits for the container to become ready, then old containers are stopped (zero-downtime rolling restart).

Language-Specific Notes

Node.js (Next.js, Remix, Nest, Express) -- Nixpacks reads package.json, runs npm ci (or pnpm install / yarn install), executes the build script if present, then npm start. Override via the Build Command and Start Command fields.

PHP (Laravel, Symfony) -- Set the document root to public/ in application settings. Coolify provisions PHP-FPM with Nginx. Add an artisan migrate post-deploy command if needed.

Python (Django, FastAPI, Flask) -- Nixpacks detects requirements.txt or pyproject.toml. For Django, set the start command to gunicorn myproject.wsgi:application --bind 0.0.0.0:8000. For FastAPI, use uvicorn app.main:app --host 0.0.0.0 --port 8000.

Static sites (Astro, Hugo, Eleventy, Vite) -- Choose Static build pack. Set Publish Directory to dist, public, or _site depending on your framework.

Docker / Dockerfile -- Give Coolify the Dockerfile path. Useful for polyglot stacks or compiled binaries (Go, Rust, Elixir releases).

Docker Compose -- Paste or reference a docker-compose.yml. Coolify translates ports into Traefik routes and volumes into Docker volumes.

Environment Variables, Secrets, and Preview Deployments

Each application has an Environment Variables tab where you set runtime configuration. Variables marked Build Time are injected during docker build; variables marked Runtime are injected at container start. Secrets are encrypted at rest in Coolify's database.

Toggle Preview Deployments to have Coolify build a separate environment for every pull request. Previews get their own subdomain (pr-42-app.apps.example.com) and can share or override environment variables.

Step 6: Provision Databases

Databases in Coolify are first-class resources -- separate from applications, independently backed up, and connected via Docker network names rather than public endpoints.

Create a Database

Connect an Application to the Database

Copy the internal connection string from the database page. It looks like:

postgres://postgres:PASSWORD@postgresql-abc123:5432/postgres

Paste it into your application's environment variables as DATABASE_URL. Because both containers share the same Docker network, the hostname resolves without exposing the database to the public internet.

External Access (Optional)

If you need to connect from a local tool like TablePlus or DBeaver, toggle Public Port on the database page. Coolify maps a high random port (for example, 54321) to the container. Firewall it to your IP address for safety:

sudo ufw allow from YOUR_HOME_IP to any port 54321

Step 7: Deploy One-Click Services

The Services catalog is Coolify's answer to the Heroku addons market. Instead of paying a monthly fee for a managed service, you self-host the open-source original in one click. The catalog includes 80+ applications -- here are the most popular picks.

Content & Marketing

• WordPress -- deploys WordPress + MariaDB + persistent uploads volume. Finish the famous five-minute install in the browser. Swap the default theme for your own via the standard wp-admin workflow.
• Ghost -- the modern publishing platform. Ships with MariaDB and SMTP configuration via env vars.
• Strapi -- open-source headless CMS for API-driven frontends.
• Directus -- instant REST and GraphQL APIs on top of any SQL database.

Analytics & Monitoring

• Umami -- privacy-friendly, cookieless analytics. Lighter than Google Analytics and GDPR-compliant out of the box.
• Plausible -- a slightly heavier alternative to Umami with funnels and goal tracking.
• Uptime Kuma -- uptime monitoring with notifications (Discord, Slack, Telegram, email).
• Grafana + Prometheus -- metrics and dashboards.

Productivity & Internal Tools

• NocoDB -- Airtable-style UI on top of PostgreSQL or MySQL.
• AppSmith and Tooljet -- low-code internal tool builders.
• n8n -- workflow automation, the self-hosted Zapier alternative.
• Outline -- Notion-style team wiki.
• Vaultwarden -- Bitwarden-compatible password manager for your team.

Developer Infrastructure

• Gitea -- lightweight self-hosted Git server.
• Harbor -- private Docker registry with image scanning.
• MinIO -- S3-compatible object storage.
• MeiliSearch -- fast search engine with typo tolerance.

Deploying a Service

Step 8: Resources, Projects, and Environments

Coolify organizes everything into a three-level hierarchy:

• Team -> Project -> Resource

Each resource exposes a consistent set of tabs: Logs (live container stdout/stderr), Terminal (exec into the running container), Deployments (build history with rollback), Webhooks, Health, Environment Variables, Storage, and Advanced (resource limits, custom labels). This uniformity makes it fast to operate a fleet -- once you know how to read logs for one app, you know how to read logs for a database and a WordPress install.

Use tags to cut across the hierarchy. Tagging every staging resource env:staging lets you bulk-stop or bulk-restart a whole environment without touching production.

Step 9: Traefik, Wildcard Domains, and Automatic TLS

Traefik is the HTTP reverse proxy that sits in front of every Coolify-managed container. When you click Deploy, Coolify writes a Traefik configuration snippet via Docker labels, and Traefik hot-reloads its routing table -- no manual Nginx config and no certbot invocations.

For a deeper look at how Traefik works as a standalone reverse proxy, see our Traefik install guide.

Automatic TLS

Coolify requests Let's Encrypt certificates for every FQDN the first time an application receives a request. Certificates live in /data/coolify/proxy/acme.json and auto-renew 30 days before expiry. The process:

Custom Domains

By default, an app is reachable at a Coolify-generated subdomain under your wildcard. To add a production domain:

Wildcard Certificates with DNS-01

For internal subdomains that are not publicly reachable (or to avoid rate limits), configure Cloudflare DNS-01 in Settings -> Advanced -> Let's Encrypt Wildcard. Paste a Cloudflare API token with Zone:Read and DNS:Edit scopes, and Traefik will request a single wildcard certificate for *.apps.example.com instead of per-subdomain certificates.

Step 10: Configure Backups

Losing a database is the fastest way to discover backups are worth setting up early.

S3-Compatible Backup Target

Enable Database Backups

Open each database resource -> Backups tab -> Enable.

• Schedule -- cron expression (for example, 0 2 * for 2 AM daily)
• Retention -- how many snapshots to keep
• Storage -- the S3 target configured above
• Database(s) to back up -- all or a specific list

Application Volume Backups

For applications that write to persistent volumes (WordPress uploads, Ghost content, MinIO buckets), add a Scheduled Task that tars the volume and pushes it to S3:

tar -czf - /app/uploads | aws s3 cp - s3://my-bucket/uploads-$(date +%F).tar.gz

Paste it into Resource -> Scheduled Tasks with a cron expression, and Coolify runs it inside the container on schedule.

Backup Verification

Untested backups are not backups. Once a month, restore a database dump to a throwaway resource and confirm the data is intact. Coolify exposes a Restore button that does this against a fresh target -- use it.

Troubleshooting

Viewing Logs

Control plane logs:

sudo docker logs coolify -f

Traefik logs (routing, certificate issuance):

sudo docker logs coolify-proxy -f

Per-application logs are available directly in the UI under the Logs tab.

FAQ

How does Coolify compare to CapRover, Dokku, and Portainer?

Coolify, CapRover, and Dokku occupy the same niche -- self-hosted PaaS -- but differ in execution. Coolify is the most feature-complete: it bundles a first-class database manager, a services catalog, preview environments, S3 backups, and multi-server support out of the box. CapRover is simpler, uses Docker Swarm under the hood, and has a smaller but rock-solid feature set (great for 1-2 server setups). Dokku is the original "Heroku-in-a-box" and remains the lightest-weight option -- it is CLI-first, written in Bash, and has a large plugin ecosystem, but lacks a polished web UI. Portainer is different: it is a Docker/Kubernetes management UI, not a PaaS. Portainer shows you containers and lets you edit them; Coolify deploys applications from source. Many teams run Portainer alongside Coolify for lower-level visibility.

Can I use Coolify with multiple servers?

Yes. The machine where Coolify is installed is the control plane. Additional Ubuntu/Debian servers can be added under Servers -> New Server -- Coolify installs a small agent over SSH and the new node becomes a deployment target. You pick which server each resource runs on when you create it. A common topology is one small control plane + two or three beefy application servers + a dedicated database server. All are managed from the same UI.

Is Coolify production-ready?

Coolify is used in production by thousands of companies, including those running mission-critical SaaS. It has been in active development since 2021, reached v4 stable in 2024, and has a paid cloud offering that eats its own dog food. That said, any self-hosted platform demands operational discipline -- you are responsible for OS patching, monitoring disk usage, and verifying backups. If you are a solo founder with no ops background, the managed Coolify Cloud offering may be a better fit than self-hosting.

Does Coolify support Kubernetes?

No -- Coolify uses plain Docker (and optionally Docker Swarm for multi-node). This is by design: Kubernetes is powerful but adds significant operational overhead that most small-to-medium teams do not need. If your scale truly requires Kubernetes, look at Rancher or a managed offering (EKS, GKE, DOKS). For most PaaS workloads -- a handful of web apps, databases, and workers -- Docker is simpler, cheaper, and faster to operate.

How do I migrate from Heroku or Vercel to Coolify?

The migration path is usually straightforward because both Heroku and Vercel deploy the same Git repositories you will point Coolify at. Steps: (1) install Coolify on a VPS; (2) connect your GitHub source; (3) import environment variables from the source platform (heroku config -s > .env or the Vercel dashboard export); (4) create a Coolify database, dump and restore Heroku Postgres into it (pg_dump / pg_restore); (5) deploy the app on Coolify and verify; (6) cut DNS over. Most teams complete a migration for a single app in under two hours, with zero downtime using DNS TTL reductions.

What resources does Coolify itself consume?

The control plane and its dependencies (PostgreSQL, Redis, Traefik, SoketI) idle at roughly 500 MB RAM and negligible CPU. Each deployed application adds its own footprint on top of that -- a typical Next.js app runs in 200-400 MB, a PostgreSQL instance at rest in 150-250 MB, WordPress + MariaDB in 400-600 MB combined. On a 12 GB RAM Professional VPS you can comfortably run 15-25 resources before memory becomes the bottleneck.

Can I still use raw Docker alongside Coolify?

Yes. Coolify manages containers via Docker labels but does not prevent you from running docker run manually or using plain docker compose for resources you prefer to manage outside the UI. Just be careful not to bind the same ports (80/443) as Traefik. For full control with an external reverse proxy (for example, you want HAProxy in front of Coolify), disable the Coolify proxy and point external traffic at the application container IPs directly -- advanced, but supported.

Next Steps

With Coolify running, here are the highest-leverage follow-ups:

• Read the official docs -- The Coolify documentation covers advanced topics this guide glosses over: SSO, RBAC, API tokens, custom buildpacks, and the Coolify API for infrastructure-as-code workflows.
• Enable notifications -- Under Notifications, add a Discord or Slack webhook. You will get pinged on deploy failures, healthcheck alarms, and backup errors instead of discovering them after customers complain.
• Set up the Coolify API -- Generate a token at Keys & Tokens and automate deploys, backups, and resource management from CI/CD pipelines or a Terraform provider.
• Benchmark your VPS -- Run docker stats during a deploy to see real memory usage. If you are pushing limits, upgrade to a larger VPS plan before the first OOM kill hits production.
• Plan your scaling path -- When the control plane VPS reaches 70% sustained CPU or 80% RAM, add a worker server rather than buying a bigger box. Multi-server Coolify scales horizontally and lets you isolate noisy workloads.

Prefer a fully managed experience?

Self-hosting is empowering, but it is also a time investment. If you want the same architecture -- Git deploys, databases, one-click apps, automatic TLS -- without touching a terminal, our team can run Coolify for you on a managed VPS. Patching, monitoring, backups, and scaling are included.

- Coolify installed, configured, and hardened

- Daily off-site backups to encrypted S3

- Traefik wildcard certificates pre-provisioned

- 24/7 monitoring with Discord/Slack alerts

- Migration assistance from Heroku, Vercel, or Netlify

Launch a Professional VPS -- from EUR 19.99/month.