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

There is a particular magic to the modern hosting platforms. You connect a Git repository, push a commit, and moments later your application is live on the internet with a valid HTTPS certificate, a database attached, and a URL to share. Heroku pioneered it, Vercel and Netlify polished it, and a generation of developers grew used to never touching a server. The catch is the meter: those conveniences are billed by the seat, the build minute, and the gigabyte, and the numbers add up. Coolify offers the same workflow on a server you own, for the price of the server itself. This guide explains what it does and walks you through deploying a real application from a Git repository.

1 The Self-Hosted PaaS Idea

A platform-as-a-service, or PaaS, 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.

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. There is no per-seat pricing, no build-minute accounting, and no vendor deciding to triple their rates at renewal. You pay for a server, and everything the server can hold is yours to deploy.

2 What Coolify 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, or any 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 touching certbot. It offers a catalogue of 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, but the point is that you rarely need to think about that layer. You describe what you want; Coolify makes it real.

3 Installing Coolify

Coolify installs on a fresh Linux server, typically Ubuntu or Debian, with a single script. You want a machine with at least 2GB of RAM, though 4GB gives you comfortable headroom once you start running databases and a few apps. SSH into your server and run the official installer as root:

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

The script installs Docker if it is missing, pulls the Coolify containers, and configures everything. When it finishes it prints the URL of your new dashboard, usually http://your-server-ip:8000. Open that in a browser, and the first account you create becomes the administrator. Create it immediately, before anyone else finds the open port.

Your very first task 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.

4 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. If you want 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 appropriate privileges.
3. Paste or generate an SSH key, and add the public half to the target server’s ~/.ssh/authorized_keys.
4. Coolify validates the connection and installs the Docker components it needs.

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

5 Deploying a Database and an App

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

1. Create or open a Project, which is simply a logical grouping for related resources.
2. Inside it, 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 shows 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 to deploy, for example main.
2. Coolify inspects the project. If it finds a Dockerfile it uses that; otherwise it can fall back to Nixpacks or buildpacks 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.

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

7 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 can schedule automated dumps on a cron expression and ship them to an S3-compatible object store. Configure that for anything holding data you would miss, and point it at off-site storage so a failure of the host does not take your only copy with it.

Beyond the databases, Coolify’s own configuration and the contents of your persistent volumes deserve protection too. The platform stores its state under a known data directory on the host, so a regular filesystem-level snapshot of the server, or an archive of Coolify’s data directory and your named Docker volumes, completes the picture. As ever, a backup that lives only on the machine it is meant to rescue is not really a backup.

8 Honest Limits

Coolify is genuinely impressive, but it is not magic, and pretending otherwise leads to disappointment. It is a relatively young and fast-moving project, so expect the occasional rough edge and read release notes before upgrading. It runs on infrastructure you must maintain: the operating system updates, the disk that fills, and the security patches are now your responsibility, not a vendor’s. A single-server setup is a single point of failure, so genuinely critical workloads want redundancy that you will have to design yourself. And while the one-click catalogue is broad, an application with unusual build requirements may still need you to roll up your sleeves and write a Dockerfile by hand. Coolify removes most of the toil; it does not abolish the discipline of running servers.

9 Conclusion

Coolify delivers the deploy-from-Git, automatic-HTTPS, one-click-database experience that made managed platforms beloved, and it does so on hardware you own and pay for once. Install it with a single command, connect your server, provision a database, point it at a repository, and you have a personal platform-as-a-service humming away without a monthly invoice. Mind the honest limits, keep your backups off-site, and you gain the convenience of the big platforms while keeping the control, and the savings, entirely to yourself.