Deploying Coolify with Docker for Self-Hosted Projects

Sarthak Varshney
18h
239
0
2

Article

If you’ve ever wished for your own self-hosted platform that feels like Vercel or Netlify but runs right from your home lab, then Coolify is exactly what you’re looking for. It’s an open-source, all-in-one platform that lets you deploy and manage applications without needing to memorize long Docker commands or YAML configurations.

In this article, we’ll walk through everything you need to know to deploy Coolify as a Docker container on your own home lab setup. Whether you’re using a Proxmox-based cluster, a single Ubuntu server, or even an old machine repurposed for experimentation, you’ll be able to get it up and running easily.

What is Coolify?

Think of Coolify as a self-hosted PaaS (Platform as a Service) . It lets you:

Deploy web apps, databases, and services using a simple interface
Manage multiple projects in one dashboard
Support Docker, static sites, and even backend frameworks
Handle SSL certificates automatically
And it’s completely open-source

The best part? You can self-host it and own everything — no vendor lock-in, no subscription fees, and full control over your environment.

When I first discovered Coolify, I was looking for something to deploy small projects without spinning up complex Kubernetes clusters. I wanted simplicity — something that’s beginner-friendly but still powerful. Coolify checked all those boxes.

Why Use Docker to Deploy Coolify?

Coolify itself runs inside Docker containers, and deploying it with Docker offers a few clear advantages:

Easy Setup – You don’t need to install tons of dependencies.
Isolation – It won’t interfere with other applications in your system.
Portability – You can move it between machines or servers easily.
Consistency – “It works on my machine” becomes true for everyone.

If you’re already using Docker for other services on your home lab (like Portainer, N8N, or Nextcloud), Coolify will fit right in.

Prerequisites

Before we dive in, make sure you’ve got a few basics ready:

An Ubuntu or Debian-based server (can be a virtual machine in your home lab)
Docker and Docker Compose are installed
At least 2 GB RAM and 10 GB disk space (recommended for smooth operation)
A static IP or a domain name if you want to access it externally

If you don’t have Docker yet, install it quickly with these commands:

sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Check your installation:

docker --version
docker compose version

Step 1. Create a Directory for Coolify

Let’s keep things organized. Create a directory where Coolify will live:

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

This script will automatically:

Download the required Docker images
Set up the Docker Compose configuration
Create persistent volumes for data and configurations
Start Coolify

Once it’s done, open your browser and visit:

http://<your-server-ip>:8000

You’ll see the Coolify onboarding page, where you can create your admin account.

Tip: The first launch might take a few minutes as it downloads all the containers.

Step 2. Configure Your Coolify Instance

Once inside the dashboard, you’ll feel like you’re using a clean and modern developer tool. The UI is simple and intuitive.

Here’s what you can do next:

Add a Server Connection – You can deploy apps directly on the same machine or add remote servers.
Set up a Git Repository – Coolify can connect with GitHub or GitLab to pull your code automatically.
Deploy Your First App – Choose from templates like Node.js, Python, Laravel, or static sites.
Enable SSL (Optional) – If you’re exposing Coolify to the internet, enable SSL certificates with Let’s Encrypt directly from the UI.

You don’t need to touch Docker commands for any of this — Coolify handles container orchestration behind the scenes.

Step 3. Running Coolify Behind a Reverse Proxy (Optional)

If you’re using your home domain (like coolify.sarthakvarshney.in)You might want to access Coolify securely through HTTPS.

You can set up a simple reverse proxy using NGINX Proxy Manager or Traefik. Here’s an example using NGINX:

  server {
    listen 80;
    server_name coolify.yourdomain.com;

    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Then you can generate an SSL certificate for free using Certbot or NGINX Proxy Manager’s built-in feature.

Step 4. Managing Coolify as a Docker Container

Coolify runs using Docker Compose, so you can easily manage it with standard commands:

Check running containers:
```
docker ps       
```
Restart Coolify:
```
docker compose restart   
```
Stop Coolify:
```
docker compose down   
```

Update Coolify:

docker compose pull
docker compose up -d

All your data and settings remain safe in Docker volumes, so updates won’t break your setup.

Step 5. Deploying an App with Coolify

Let’s take an example: deploying a simple Node.js app.

Go to Applications > New Application.
Connect your GitHub repository containing the app.
Choose the Node.js template.
Set environment variables (if required).
Click Deploy.

That’s it — within seconds, Coolify will pull your code, build the Docker image, and host your app.

For beginners, this is a huge time-saver. No docker build or docker run commands. Everything is visual, straightforward, and automated.

My Experience with Coolify in a Home Lab

When I first deployed Coolify in my home lab (which runs on Proxmox with a few Ubuntu VMs), I was honestly surprised by how polished it felt. The dashboard gives you full control without making things complicated.

I started small — deploying a static site and an API. Within minutes, I had both running with SSL enabled. Later, I connected a PostgreSQL database and a Redis container — all directly from the Coolify UI.

It’s one of those tools that makes you feel like you’re managing your own mini cloud environment, right inside your home lab.

Common Issues and Quick Fixes

Here are a few common hiccups and how to solve them:

Port 8000 already in use: Stop any other service using it or modify the Coolify port in the Docker Compose file.
Cannot access Coolify: Ensure your firewall allows inbound traffic on port 8000.
SSL not working: Make sure your domain points correctly to your public IP and ports 80/443 are open.

Step 6. Backing Up Coolify

Before you start deploying serious apps, set up backups. Coolify stores data in Docker volumes, typically under /var/lib/docker/volumes . You can use tar or rsync to back up your entire /opt/coolify folder.

Example:

tar -czvf coolify-backup.tar.gz /opt/coolify

Restoring is just as simple: extract the backup and re-run docker compose up -d .

Final Thoughts

Deploying Coolify as a Docker container on your home lab is one of the easiest ways to experience a self-hosted, developer-friendly PaaS. It’s lightweight, fast, and ideal for both learning and personal projects.

Once you get the hang of it, you can scale your setup — add remote servers, connect CI/CD pipelines, and host multiple web apps effortlessly.

If you’re a home lab enthusiast or a developer exploring self-hosted DevOps tools, give Coolify a try. It bridges the gap between convenience and control — and that’s exactly what makes it so cool.