Self-hosting Coolify on your own server

Introduction

Coolify is an open source, self-hosted alternative to platforms like Vercel, Netlify or Heroku. You point it at a server, it installs Docker and a reverse proxy for you, and from then on you get a dashboard to deploy apps, databases and services with SSL certificates out of the box.

It runs on pretty much any Linux server: Debian, Ubuntu, Fedora, Arch, even a Raspberry Pi. If what you have is a Windows or macOS machine you can also get it running to try it out, through WSL 2 on Windows and Docker Desktop on macOS, but for a real deployment you'll want a Linux box with a public IP.

In this article I will guide you through installing it on your own server, putting it behind your own domain and deploying a first app. I'll be using a fresh Debian server as the example, but the steps are the same on any Linux distribution; only the package manager commands change. This very blog is deployed with it.

For this guide, I'll be assuming you have a VPS with a supported Linux distribution installed, SSH access to it as root and a domain whose DNS records you can edit.

What you need

• A server running a supported Linux distribution (Debian, Ubuntu, Fedora, RHEL, Arch, Alpine or Raspberry Pi OS) with at least 2 CPU cores, 2 GB of RAM and 30 GB of disk. That's Coolify's minimum, you'll want more if you plan to run databases next to your apps.
• Root access over SSH.
• A domain, or a subdomain, pointed at the server.

Preparing the server

Connect to the server and bring the system up to date. Minimal images often don't ship curl, which the installer needs, so install it too. On Debian (and Ubuntu) that looks like this:

ssh root@YOUR_SERVER_IP

apt update && apt upgrade -y
apt install -y curl

Opening the firewall

Debian doesn't enable a firewall by default, and many VPS images don't either. If you want one (and you should), open SSH, HTTP, HTTPS and the three ports Coolify uses for its dashboard, websockets and terminal. On Debian and Ubuntu the simplest tool is ufw:

apt install -y ufw
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8000/tcp
ufw allow 6001/tcp
ufw allow 6002/tcp
ufw enable

Installing Coolify

The whole installation is a single script:

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

It takes a few minutes. Along the way it installs Docker if it's missing, creates /data/coolify for its configuration and volumes, generates an SSH key and adds it to root's authorized_keys, and finally starts the Coolify containers. When it's done it prints the URL of your new dashboard.

Creating the admin account

Open http://YOUR_SERVER_IP:8000 in your browser. The first account you register becomes the administrator, and registration is closed automatically after that, so do this right after the installer finishes.

Once you're in, the onboarding wizard asks where you want to deploy. Choose localhost, which is the server Coolify itself is running on. It creates a project with a production environment for you; you can skip creating a resource for now, we'll get there in a moment.

Pointing a domain at your instance

Right now the dashboard is served over plain HTTP on port 8000. Let's put it behind a proper domain with HTTPS. Start by creating two DNS records at your registrar: one for the dashboard and a wildcard for the apps you'll deploy later.

coolify.yourdomain.com    A    YOUR_SERVER_IP
*.apps.yourdomain.com     A    YOUR_SERVER_IP

Then, in Coolify, go to Settings and set Instance's Domain to https://coolify.yourdomain.com. Save, wait a few seconds and open that URL: the built-in proxy (Traefik) requests a Let's Encrypt certificate and the dashboard is now on HTTPS.

Now head to Servers -> localhost and set Wildcard Domain to https://apps.yourdomain.com. Every new resource you create will get a subdomain there automatically, so you don't have to touch DNS again for each app.

Since the dashboard has a domain now, the three setup ports can be closed:

ufw delete allow 8000/tcp
ufw delete allow 6001/tcp
ufw delete allow 6002/tcp

Deploying your first app

Go to Projects, open the project the wizard created, pick the Production environment and click + New. You'll see a long list of resources: applications, databases and one-click services. For an app, choose Public Repository and paste the URL of a Git repo.

• Pick the branch to deploy.
• Choose a build pack. Nixpacks figures out most projects on its own; if the repo has a Dockerfile, choose Dockerfile instead.
• Set the port your app listens on (3000 for a typical Next.js app).
• Set the domain, for example https://blog.apps.yourdomain.com, or leave the generated one.

Hit Deploy and follow the logs. The first build takes a while because it has to download everything; once it's done, open the domain and you should see your app over HTTPS.

For private repositories and automatic deployments on every push, go to Sources and connect a GitHub App instead of using a public URL. Coolify walks you through creating it in your GitHub account, and from then on new resources can pick any of your repos.

Keeping it healthy

A few settings worth enabling right away:

• Automatic updates: in Settings you can let Coolify update itself. If you'd rather do it by hand, running the install script again updates an existing instance.
• Backups: also in Settings, schedule a backup of Coolify's own database to an S3-compatible bucket. Losing it means re-configuring every resource.
• Notifications: connect Telegram, Discord or email so you hear about failed deployments before your users do.

That's it! You now have your own little PaaS running on a single server. From here you can add more servers to the same dashboard, spin up databases with one click or set up preview deployments for pull requests.