How to Run Coolify on Hetzner for $6/Month

by David Park
How to Run Coolify on Hetzner for $6/Month

What You'll End Up With

By the end of this guide you'll have Coolify — an open-source, self-hosted PaaS — running on a Hetzner CAX11 ARM VPS (€3.79/month, ~$6 with tax depending on region). Coolify gives you one-click deployments for Node, Python, PHP, and static apps, plus managed PostgreSQL, MySQL, Redis, and automatic Let's Encrypt SSL. No Heroku, no Render, no Fly.io bills that creep up on you.

Prerequisites:

  • A Hetzner Cloud account (hetzner.com/cloud)
  • A domain or subdomain you control (e.g., coolify.yourdomain.com)
  • SSH key already added to your Hetzner project
  • Local machine with ssh and curl available
  • 10 minutes

1. Provision the Hetzner CAX11 Instance

The CAX11 is Hetzner's cheapest ARM64 instance: 2 vCPU, 4 GB RAM, 40 GB NVMe. Coolify's minimum is 2 GB RAM, so this fits with headroom.

1.1. Log in to Hetzner Cloud Console → New Project → Add Server.

1.2. Choose these options exactly:

  • Location: Falkenstein (FSN1) or Nuremberg (NBG1) — lowest latency to EU; pick Ashburn (ASH) for US East.
  • Image: Ubuntu 24.04 (ARM64)
  • Type: CAX11
  • SSH key: select your existing key
  • Hostname: coolify-01

1.3. After the server boots (≈20 seconds), note the public IPv4. Point your subdomain at it now so DNS propagates while you work:

coolify.yourdomain.com  A  <server-ipv4>

2. Harden the Server Before Installing Anything

Never run a fresh VPS without at least locking down SSH and enabling the firewall first.

2.1. SSH in as root:

ssh root@<server-ipv4>

2.2. Update packages:

apt update && apt upgrade -y

2.3. Create a non-root user and grant sudo:

useradd -m -s /bin/bash deploy
usermod -aG sudo deploy
mkdir -p /home/deploy/.ssh
cp /root/.ssh/authorized_keys /home/deploy/.ssh/authorized_keys
chown -R deploy:deploy /home/deploy/.ssh
chmod 700 /home/deploy/.ssh
chmod 600 /home/deploy/.ssh/authorized_keys

2.4. Disable root SSH login:

sed -i 's/^PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
systemctl restart ssh

2.5. Enable UFW and open only the ports Coolify needs:

ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8000/tcp
ufw --force enable

Port 8000 is Coolify's management UI before you put it behind a reverse proxy (optional; covered in Step 5).

2.6. Open a second terminal and verify you can log in as deploy before closing the root session:

ssh deploy@<server-ipv4>

3. Install Coolify

Coolify ships a single install script that pulls Docker, sets up systemd units, and starts all services. Run it as root (the script requires it).

3.1. Switch back to your root session (or sudo -i from deploy):

sudo -i

3.2. Run the official Coolify installer:

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

Expected tail output (versions will differ):

[INFO] Coolify 4.x.x installed successfully.
[INFO] Please visit http://<server-ipv4>:8000 to complete setup.

The script installs Docker CE, pulls the ghcr.io/coollabs/coolify image stack, writes a docker-compose.yml to /data/coolify/source/, and registers a coolify systemd service. Installation takes 2–4 minutes on CAX11.

3.3. Confirm the containers are up:

docker ps --format 'table {{.Names}}\t{{.Status}}'

Expected output:

NAMES                    STATUS
coolify                  Up 2 minutes
coolify-db               Up 2 minutes
coolify-redis            Up 2 minutes
coolify-realtime         Up 2 minutes
coolify-proxy            Up 2 minutes

4. Complete the Web Onboarding

4.1. Open http://<server-ipv4>:8000 in your browser.

4.2. Create your admin account (email + password). This is stored locally — no external auth service involved.

4.3. On the "Server" screen, Coolify asks you to register a server. Choose Localhost — this registers the VPS itself as the deployment target over the Docker socket. Click Validate Server; you should see a green "Reachable" badge within 10 seconds.

4.4. Skip the "Add a Team" step for now. You can add collaborators later under Settings → Teams.


5. Point Your Domain at the Coolify Dashboard (Optional but Recommended)

Running the dashboard on port 8000 is fine for testing, but putting it behind HTTPS on coolify.yourdomain.com removes the port and adds SSL. Coolify's built-in Traefik proxy handles this automatically.

5.1. In the Coolify UI, go to Settings → Instance Settings.

5.2. Set Instance's Domain to https://coolify.yourdomain.com.

5.3. Click Save. Coolify instructs its Traefik container to request a Let's Encrypt certificate for that domain. Wait 30–60 seconds.

5.4. Navigate to https://coolify.yourdomain.com. You should land on the login screen over HTTPS with a valid certificate. You can now close port 8000 in UFW:

ufw delete allow 8000/tcp

6. Deploy Your First App

This step deploys a real Node.js app from a public GitHub repo to confirm the whole pipeline works end-to-end.

6.1. In the Coolify dashboard, click Projects → New Project → name it test.

6.2. Click New Resource → Public Repository.

6.3. Enter the repo URL:

https://github.com/coollabsio/coolify-examples

Select the node-js example, branch main.

6.4. Set the domain to node-test.yourdomain.com (add an A record pointing to the same server IP). Leave build pack as Nixpacks — Coolify auto-detects Node.

6.5. Click Deploy. Watch the build log stream in real time. A successful build ends with:

Build completed successfully.
Container started.

6.6. Visit https://node-test.yourdomain.com. The example app returns a JSON response with Node version and hostname.


7. Verify It Works

Run these checks from your local machine and the server to confirm the full stack is healthy.

Check 1 — Coolify systemd service is running:

ssh deploy@<server-ipv4> "sudo systemctl is-active coolify"

Expected:

active

Check 2 — All Coolify containers are healthy:

ssh deploy@<server-ipv4> "docker ps --filter name=coolify --format '{{.Names}}: {{.Status}}'"

Every container should show Up X minutes with no (unhealthy) suffix.

Check 3 — SSL certificate is valid:

curl -sI https://coolify.yourdomain.com | grep -E 'HTTP|strict'

Expected:

HTTP/2 200
strict-transport-security: max-age=31536000

Check 4 — Disk headroom:

ssh deploy@<server-ipv4> "df -h /"

After a fresh Coolify install and one app build, expect ~8–10 GB used out of 40 GB. You have plenty of room for 5–10 small apps before you need to think about pruning Docker images.


Troubleshooting

Coolify UI not reachable on port 8000 Run docker ps — if coolify container is absent, run systemctl restart coolify and wait 30 seconds. Check logs with docker logs coolify --tail 50.

Let's Encrypt certificate not issuing DNS must resolve before Traefik can complete the ACME HTTP-01 challenge. Run dig +short coolify.yourdomain.com from your local machine and confirm it returns your server IP. If DNS hasn't propagated, wait and retry under Settings → Instance Settings → Save.

Build fails with "exec format error" on ARM64 The app's base Docker image doesn't have an ARM64 variant. Switch the base image to one tagged linux/arm64 or use Nixpacks instead of a custom Dockerfile — Nixpacks builds natively for the host architecture.

Coolify containers restart-looping Run docker logs coolify-db --tail 30. A common cause is the PostgreSQL data directory at /data/coolify/db having wrong ownership after a failed first boot. Fix: chown -R 999:999 /data/coolify/db && systemctl restart coolify.

UFW blocking internal Docker networking If apps can't reach each other or the database, run ufw allow in on docker0 and ufw allow in on br+. Coolify's Traefik and app containers communicate over Docker bridge networks that UFW can block.


Next Steps

You now have a Coolify self-hosted PaaS running on a $6/month Hetzner ARM instance with HTTPS and automatic deployments. A few directions from here:

  • Add a Hetzner Volume ($0.0476/GB/month) for persistent database storage: mount it at /data/coolify/db before your first deploy.
  • Enable S3-compatible backups using Hetzner Object Storage (compatible with the Coolify backup UI under Settings → Backups).
  • Add a second server — Coolify supports multi-server deployments; add a second CAX11 and distribute apps across nodes without changing your workflow.
  • Set up GitHub App integration under Sources → GitHub App for private repo deployments with automatic webhook triggers on push.

The total spend for this setup — one CAX11 plus a small Hetzner Volume — stays under $10/month, replacing what would cost $25–$50/month on managed PaaS platforms once you add databases and a couple of apps.