I've been watching Coolify from the sidelines for a while — interesting idea, rough edges, perpetually in beta. That changed in April 2026 when v4.0.0 finally shipped stable, followed almost immediately by v4.1.0 in May with Railpack builds, audit logging, and an MCP server that integrates with Claude Code. At that point it stopped being a "promising project" and started being something I actually wanted to run in production on my home lab.

If you've been paying cloud bills to Heroku, Render, or Railway to deploy side projects and internal tools, this post is for you. Coolify gives you the same Git-push workflow, automatic SSL, and one-click database provisioning — running on hardware you already own. Here's how to get it running on Proxmox and what to expect in day-to-day use.

Why Coolify, Why Now

The self-hosted PaaS space has a few competitors — CapRover, Dokku, Dokploy — but Coolify has pulled ahead on polish and feature velocity. As of May 2026 it's sitting at over 55,000 GitHub stars and the v4 release cadence has been aggressive.

What actually matters for a home lab engineer:

The thing Coolify still lacks compared to Render or Railway is autoscaling and integrated distributed tracing. For a home lab or small team serving predictable traffic, that's not a dealbreaker.

Hardware & Prerequisites

For this setup I'm running Coolify on a dedicated LXC container on a Beelink GTi13 Ultra — the i9-13900HK variant that I've been using as my primary home lab node. Any machine running Proxmox VE 8+ works.

Minimum specs for the LXC:

If you're starting fresh and shopping for a home lab machine, the Minisforum MS-01 is the current value king for this workload — dual 2.5GbE, PCIe 5.0 NVMe, and it handles Proxmox + several LXC containers without breaking a sweat. The CWWK N100 is a lower-cost option if you just want a dedicated Coolify node and nothing else.

For storage inside the LXC, back it with a fast NVMe. The Samsung 990 Pro 2TB is what I'm running, but even the WD SN770 1TB will be fast enough for build caches.

Creating the Proxmox LXC Container

Coolify publishes a community script for Proxmox that handles the LXC creation and initial install in one shot. From your Proxmox shell:

bash -c "$(wget -qLO - https://github.com/community-scripts/ProxmoxVE/raw/main/ct/coolify.sh)"

The script prompts you for container ID, hostname, disk size, CPU, and RAM, then pulls a Debian 12 template and runs the Coolify installer inside it. Total time: about 5 minutes on a decent connection.

If you prefer to do it manually (which I recommend if you want control over network config and storage):

# Create LXC from Proxmox shell
pct create 200 local:vztmpl/debian-12-standard_12.7-1_amd64.tar.zst \
  --hostname coolify \
  --cores 4 \
  --memory 8192 \
  --swap 2048 \
  --rootfs local-lvm:40 \
  --net0 name=eth0,bridge=vmbr0,ip=dhcp \
  --unprivileged 1 \
  --features nesting=1
pct start 200
pct enter 200

Inside the container, the nesting=1 feature flag is required — Coolify runs Docker, and Docker inside LXC needs nesting enabled or it won't start. Without it you'll get obscure cgroup errors that aren't obvious to debug.

# Inside the LXC
apt update && apt install -y curl ca-certificates
Run the official Coolify installer
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

The installer pulls Docker, sets up the Coolify service files, and starts everything. Watch for the final output — it will print your instance URL and the initial admin credentials.

Initial Configuration

Once the installer completes, Coolify is reachable at http://[container-ip]:8000. First boot takes about 30 seconds as the containers pull and start.

The setup wizard is straightforward: 1. Create your admin account 2. Configure the instance URL (set this to the public domain or Tailscale address you'll use — Coolify uses this for Let's Encrypt and webhook callbacks) 3. Select server type: localhost for apps running on the same machine as Coolify, or remote to SSH into a separate deployment target

For a home lab, localhost makes sense initially. If you have a separate application server or a VPS you deploy to, add it as a remote server and paste your SSH key. Coolify handles the rest.

Setting Up a Custom Domain with Cloudflare Tunnels

I expose Coolify itself and the apps it deploys via Cloudflare Tunnels rather than opening ports. The flow:

1. Cloudflare Tunnel → coolify.yourdomain.com → container IP port 8000 (the Coolify dashboard) 2. Coolify manages its own Traefik instance for routing deployed apps 3. Each app gets a subdomain routed through the same tunnel

In Coolify's settings, set Traefik as the proxy (default), and configure your wildcard domain. Coolify will automatically provision Let's Encrypt certs for each app you deploy.

Deploying Your First App

Coolify's project model is: Project → Environment → Service/Application. Create a project, add an environment (production, staging, etc.), then add a resource.

For a Git-based app:

Resources → Add New Resource → Application
→ Select: GitHub (or Gitea/Forgejo if self-hosted)
→ Paste repo URL
→ Select build pack: Nixpacks, Railpack, or Dockerfile
→ Configure environment variables
→ Set domain
→ Deploy

Railpack is the newer option and worth trying first for Node/Python/Go apps — it produces smaller images and caches layers more aggressively. On my setup, a Node.js app that took 3m20s to build with Nixpacks dropped to 1m45s with Railpack after the first cached build.

For a pure Dockerfile deploy, Coolify respects your existing Dockerfile without modification. If you already have containers running locally, migration is mostly just wiring up env vars and pointing at your registry.

One-Click Services Worth Running

The services catalog is where Coolify earns its keep. A few that are immediately useful:

Postgres + pgAdmin — one click, automatic backups to S3-compatible storage (point it at your local MinIO instance if you have one). The backup scheduler is built in, something you'd otherwise cobble together with cron and pg_dump.

Uptime Kuma — if you're not running this already, it's the cleanest status monitor in the self-hosting ecosystem. Two-minute setup through Coolify.

n8n — if you're already running n8n manually (I have it on a separate LXC), Coolify can manage the lifecycle for you. Not worth migrating mid-workflow, but a clean start is easier here than manual Docker Compose.

Ollama — spin up an Ollama instance with GPU passthrough if your LXC host exposes one. For LXC GPU passthrough on Proxmox, you'll need to configure the container with the appropriate device nodes:

# In /etc/pve/lxc/200.conf, add:
lxc.cgroup2.devices.allow: c 195:* rwm
lxc.cgroup2.devices.allow: c 511:* rwm
lxc.mount.entry: /dev/nvidia0 dev/nvidia0 none bind,optional,create=file
lxc.mount.entry: /dev/nvidiactl dev/nvidiactl none bind,optional,create=file
lxc.mount.entry: /dev/nvidia-uvm dev/nvidia-uvm none bind,optional,create=file

The NVIDIA RTX 4060 Ti or AMD Radeon RX 7600 are popular home lab GPU choices that handle Ollama well without the power draw of the high-end cards.

The MCP Server Integration

Coolify v4.1 ships a built-in MCP server, which is the feature that pushed me to actually write this post. From a Claude Code session (or any MCP-compatible client), you can:

# Add to your claude_desktop_config.json or .claude/settings.json
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": ["coolify-mcp"],
      "env": {
        "COOLIFY_BASE_URL": "https://coolify.yourdomain.com",
        "COOLIFY_API_TOKEN": "your-api-token"
      }
    }
  }
}

From there, Claude Code can list your services, trigger deployments, read logs, and check resource status — all without leaving your coding environment. It's early days for the integration but the primitives are solid.

Generate your API token from Coolify → Security → API Tokens. The token has the same permissions as your user, so create a dedicated service account if you're sharing the Coolify instance.

Gotchas and Real Talk

Docker socket access in unprivileged LXC: The nesting=1 flag handles most of it, but occasionally Docker operations fail with permission errors after a Proxmox host reboot. If you see permission denied on Docker socket calls, restart the LXC rather than just the service — it usually clears the issue.

Build disk usage: Coolify doesn't aggressively prune old build images. After a few weeks of active deployments you can accumulate several GB of stale layers. Add a cron job inside the LXC:

# /etc/cron.weekly/docker-prune
#!/bin/bash
docker image prune -f --filter "until=168h"
docker builder prune -f --filter "until=168h"

Coolify auto-updates itself: By default it checks for updates and applies them automatically. This is usually fine, but if you want to pin to a specific version for stability, disable auto-updates in Settings → General and update manually.

Traefik conflicts: If you're already running Traefik or Nginx Proxy Manager on the same machine, you'll have port 80/443 conflicts. Either run Coolify on a dedicated LXC with its own IP, or configure Coolify to use a custom port range and put your existing proxy in front.

No native Gitea/Forgejo webhook for LAN: If you're self-hosting your Git (like on Forgejo), Coolify's webhook needs to reach your Git server. On a LAN-only setup with private addressing, you may need to configure the webhook URL manually and ensure DNS resolves between containers.

Is It Worth Switching?

For home lab use: yes, without much hesitation. The ops overhead of managing individual Docker Compose stacks across multiple projects adds up, and Coolify handles the lifecycle management cleanly. The one-click service catalog alone saves hours compared to maintaining your own compose files.

For replacing a cloud PaaS for real workloads: it depends on your traffic patterns and uptime requirements. Coolify doesn't solve hardware failures — your apps go down when your server goes down. If you need multi-region failover or SLA-backed uptime, you still need a cloud provider or a more complex setup. For internal tools, staging environments, and side projects? It's excellent.

The Railpack + MCP combination makes v4.1 specifically worth the upgrade from any older Coolify version. If you tried it in 2024 and bounced off the rough edges, give it another look — the 2026 release is a meaningfully different product.

---

Hardware mentioned in this post:

Disclosure: This post contains affiliate links. If you purchase through these links, I may earn a small commission at no extra cost to you.