One-Click Everything: Deploying Self-Hosted Apps with Coolify

My Heroku bill was £41 a month for three toy projects that between them served maybe two hundred requests a day. None of them made money; all of them existed because I couldn’t be bothered to run a server. That is the exact psychology the managed platforms are built on: you connect a Git repository, push a commit, and moments later your application is live with a valid HTTPS certificate, a database attached, and a URL to share. Heroku pioneered the feeling, Vercel and Netlify polished it, and a generation of us grew used to never touching a server. The catch is the meter — billed by the seat, the build minute, and the gigabyte — and the numbers add up faster than the value does.

Coolify offers the same workflow on a server you own, for the price of the server itself. I moved those three projects onto a single £6-a-month VPS eighteen months ago and haven’t looked back. This guide explains what it actually does, walks through deploying a real application from a Git repository, and — because I’ve hit most of them — the potholes you’ll want to steer around.

The self-hosted PaaS idea, and why it’s not just “cheaper Heroku”

A platform-as-a-service sits between raw infrastructure and your code. You do not configure web servers, wrangle reverse proxies, or hand-write TLS certificate renewals; the platform handles all of that and asks only for your application. The trade has always been control and cost: you rent the platform, and you accept whatever it does behind the curtain — including the day the vendor decides your free tier is now a paid one.

A self-hosted PaaS flips that bargain. You run the platform yourself on a plain virtual machine, and it grants you the same push-to-deploy convenience while leaving the keys in your hands. No per-seat pricing, no build-minute accounting, no renewal surprise. You pay for a server, and everything the server can hold is yours to deploy. The reason this matters beyond cost is data gravity: once a project lives on your box, you can put a database, a background worker, an object store and a cron job next to it without each one becoming a separate line item. That’s the same instinct behind self-hosting your own personal finance or running your own photo library — the app is only half the value; owning the surrounding plumbing is the other half.

What Coolify actually does

Coolify is an open-source, self-hostable platform that brings the Heroku experience to your own hardware. Its headline features cover the things that make managed platforms feel effortless.

It deploys applications directly from Git: connect GitHub, GitLab, Bitbucket, Gitea or any plain repository, and a push triggers a build and release. It manages automatic SSL by provisioning and renewing Let’s Encrypt certificates for your domains, so every app gets HTTPS without you ever touching certbot by hand — though if you want to understand the machinery underneath, my write-up on certificates that actually renew covers the same ACME dance. It offers a catalogue of over 280 one-click services: databases like PostgreSQL and MySQL, caches like Redis, and dozens of ready-made applications, each deployable from a menu. Underneath, it orchestrates Docker containers and a reverse proxy (Traefik or Caddy, your choice), but the point is that you rarely need to think about that layer. You describe what you want; Coolify makes it real.

Installing Coolify

Coolify installs on a fresh Linux server with a single script. The automatic installer officially supports Ubuntu LTS (20.04/22.04/24.04) and Debian 11+, and it expects to run as root — non-root is only partially supported. Give it at least 2 CPU cores and 2 GB of RAM, though 4 GB is where things stop feeling cramped once you’re running a couple of databases. SSH in and run the official installer:

1

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

The script installs Docker if it’s missing, pulls the Coolify containers, and configures everything. When it finishes it prints the URL of your new dashboard, usually http://192.168.1.50:8000. Open that in a browser, and the first account you create becomes the administrator. Create it immediately, before a bot scanning the internet for open port 8000 finds it first. That is not paranoia; an exposed unclaimed Coolify instance is a full remote-code-execution box waiting for an owner.

Your very first job inside the dashboard should be to point a domain at Coolify itself and let it secure its own interface with SSL, so you are not administering your platform over plain HTTP.

Connecting a server

Coolify separates the platform from the machines it deploys to. The server you just installed on is automatically registered as the localhost target, which is perfectly fine for a single-box setup. To deploy onto additional machines, you add them as remote servers and Coolify manages them over SSH.

1. In the dashboard, open Servers and choose Add a New Server.
2. Provide the server’s IP address and an SSH user with the right privileges.
3. Generate a key and add the public half to the target’s ~/.ssh/authorized_keys. Use a modern key — ssh-keygen -t ed25519 — not an ancient RSA one.
4. Coolify validates the connection and installs the Docker components it needs.

From there the remote machine appears as a deployment destination alongside your local one, and you choose where each application lands.

Deploying a database and an app

A typical application needs two things: somewhere to keep state, and the application itself. Start with the database so it’s ready when the app comes up.

1. Create or open a Project — a logical grouping for related resources.
2. Add a new Resource and pick a database, say PostgreSQL, from the one-click list.
3. Choose the target server, set a name, and deploy. Coolify spins up the container and hands you the connection string, host, port, username and password, ready to copy.

Now the application. Add another resource, this time a Public or Private Git repository, and authorise Coolify against your Git provider so it can clone and receive webhooks.

1. Paste the repository URL and select the branch, for example main.
2. Coolify inspects the project. If it finds a Dockerfile it uses that; otherwise it falls back to Nixpacks to auto-detect the language and assemble an image.
3. Set the port your application listens on so the reverse proxy knows where to send traffic.
4. Assign a domain, and Coolify automatically requests a Let’s Encrypt certificate for it.
5. Press Deploy and watch the build log stream in real time.

When the build finishes, your application is live at the domain you chose, over HTTPS, talking to the database you provisioned a moment earlier.

Environment variables and webhooks

Real applications are configured through environment variables, and Coolify gives every resource a dedicated Environment Variables panel. This is where the database connection string belongs, along with API keys, secrets and feature flags. Critically, secrets entered here are not baked into the image, so they stay out of your Git history. Mark sensitive values accordingly and Coolify masks them in the interface.

For continuous deployment, Coolify generates a webhook URL for each application. Register that URL in your Git provider’s repository settings, and every push to the watched branch fires the hook, triggering an automatic rebuild and redeploy:

1
2

Git provider  →  POST https://coolify.mylab.local/api/v1/deploy?uuid=abc123
Coolify       →  clone repo → build image → swap container → renew cert if due

Commit, push, and within a minute or two the change is live. That is the entire loop managed platforms charge a premium for, running on your own server. You can also gate deployments to specific branches, so feature work in progress does not accidentally ship to production.

Backing up

Owning the platform means owning the backups, and Coolify makes the important case — your databases — refreshingly easy. Each database resource has a Backups section where you schedule automated dumps on a cron expression and ship them to an S3-compatible object store, with one-click restore. Configure that for anything holding data you’d miss, and point it at off-site storage so a failure of the host does not take your only copy with it. The same off-site discipline I bang on about in Borg vs restic applies here: a backup that lives only on the machine it’s meant to rescue is not a backup.

Beyond the databases, Coolify’s own configuration and your persistent volumes deserve protection too. It stores its state under a known data directory on the host, so a regular filesystem snapshot of the server, or an archive of Coolify’s data directory plus your named Docker volumes, completes the picture.

Troubleshooting the usual snags

A few things reliably bite people, myself included.

Deploy hangs at “building”. Nine times out of ten this is the box running out of RAM mid-build — a Node app pulling its dependency tree will happily eat 2 GB. docker stats during a deploy tells you fast. Either size up the VPS or add swap.

Certificate won’t issue. Let’s Encrypt has to reach your server over port 80 to validate the domain. If the cert stays stuck, check that the domain’s DNS actually points at the server and that no upstream firewall is blocking 80/443. Coolify’s proxy logs (under the server view) show the ACME challenge failing.

“Port already allocated”. You’ve told two resources to bind the same host port. Let Coolify manage ports and only expose through the proxy/domain rather than pinning host ports by hand.

Upgrades break things. Coolify is young and fast-moving. Read the release notes before upgrading, and snapshot the VPS first. I’ve had a minor version quietly change proxy behaviour; the snapshot turned a bad evening into a five-minute rollback.

Is it worth it, and who is this for?

Coolify delivers the deploy-from-Git, automatic-HTTPS, one-click-database experience that made managed platforms beloved, on hardware you own and pay for once. For a developer with a handful of side projects, a freelancer hosting client apps, or a homelabber who wants a proper deploy pipeline instead of hand-edited compose files, it’s an easy yes — it paid for itself against my Heroku bill in the first month.

It is not for someone who wants zero operational responsibility. The OS updates, the disk that fills, the security patches are now yours, not a vendor’s, and a single-server setup is a single point of failure you’d have to design redundancy around yourself. An app with genuinely unusual build requirements may still need a hand-written Dockerfile. Coolify removes most of the toil; it does not abolish the discipline of running servers. Mind the honest limits, keep your backups off-site, and you get the convenience of the big platforms while keeping the control — and the savings — entirely to yourself.