Self-Host Coolify on a VPS

Vercel's free tier is generous until your build minutes run out or your serverless functions start costing real money. Heroku killed its free tier in 2022. Netlify gates anything interesting behind paid plans. Coolify is the self-hosted answer — same Git-push-to-deploy flow, same auto-SSL, same built-in databases, running on your own VPS for whatever your VPS costs.

This guide installs Coolify with the official one-line installer, walks through deploying your first app from a GitHub repo, sets up a production-grade Postgres database, configures backups, and covers the gotchas the docs gloss over (DNS, firewall, S3 backups). By the end you'll have a self-hosted PaaS that handles 90% of what you'd reach for Vercel or Heroku to do.

1. Prepare the VPS

Coolify needs 4 GB RAM minimum to run smoothly. The Coolify dashboard itself eats ~1 GB, and you need headroom for your apps. SSH in as root, update everything, install Docker (Coolify uses it for every deployed app), and create a non-root user:

apt update && apt upgrade -y
apt install -y curl ca-certificates gnupg ufw

# Allow standard ports
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8000/tcp   # Coolify dashboard (we'll lock this down later)
ufw allow 6001/tcp   # Coolify realtime (Pusher)
ufw allow 6002/tcp   # Coolify terminal
ufw --force enable

Coolify's installer creates its own non-root execution model, so we don't need a separate user. Just make sure your VPS is freshly updated.

2. Install Coolify (the one-liner)

The official installer handles Docker, Docker Compose, the Coolify control plane, the realtime server, and database — all in one go.

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

Watch the output. It pulls about 1.2 GB of Docker images, sets up an isolated PostgreSQL for Coolify's own data, generates SSL keys, and starts the dashboard. Total time on a Pro plan VPS: 4–6 minutes.

When it finishes, the installer prints a URL like:

Coolify is now running at http://YOUR_VPS_IP:8000

Initial admin email: admin@example.com  (will be set on first visit)

Open that URL. You'll get a setup wizard — create your admin account first. Pick a strong password; this account has root-equivalent access to every app you deploy.

3. DNS and domain config

Coolify needs DNS to issue Let's Encrypt certs for your apps. The cleanest setup uses a wildcard A record:

*.apps.example.com    A    YOUR_VPS_IP
apps.example.com      A    YOUR_VPS_IP

Now every app you deploy can use app1.apps.example.com, blog.apps.example.com, etc., without touching DNS again. If your registrar doesn't support wildcards, fall back to creating A records per-app — annoying but functional.

Inside Coolify: Servers → your localhost server → Configuration → set the Wildcard Domain to apps.example.com. Coolify will use this as the default suffix for every app you deploy that doesn't specify its own domain.

While here, also set your own Coolify dashboard domain: coolify.example.com with an A record pointing at the VPS. Then Coolify can request its own Let's Encrypt cert and you stop visiting it by IP.

4. Deploy your first app

Time to ship something. Inside Coolify, click + New Resource → Public Repository. Paste a public GitHub URL — for testing, try https://github.com/coollabsio/sentinel or any Next.js / Astro / static site.

Coolify auto-detects the framework via Nixpacks (the build engine behind Railway and now Coolify). It picks the right buildpack, sets up the start command, and exposes the right port. Click Deploy and watch the build logs stream in real time.

For private repos, you'll need to set up a GitHub App or SSH deploy key first. Coolify walks you through the GitHub App flow: Sources → Add Source → GitHub App. Five clicks and you're authenticated.

Once deployed, the app gets a URL like https://your-app-abc123.apps.example.com automatically. Custom domain? Add it under the app's Domains tab — Coolify provisions an SSL cert within 30 seconds.

5. Add a Postgres database

Real apps need real databases. Coolify treats databases as first-class resources — provision in 30 seconds with backups, monitoring, and connection-string injection.

Inside your project: + New Resource → Database → PostgreSQL. Pick a version (16 is current), choose a password (or let it generate), and click create. Coolify pulls the official Postgres image, starts it on a private Docker network, and surfaces the connection details.

To connect your app to the database, go to your app's Environment Variables tab and add:

DATABASE_URL=postgresql://postgres:PASSWORD@HOSTNAME:5432/postgres

Coolify exposes a helper macro: {{postgres_url}} auto-resolves to the correct connection string. No copy-pasting passwords around.

For production: enable the Backups toggle in the database settings, set a schedule (daily 3 AM is standard), and configure either local backups or S3-compatible remote storage. Backups happen inside a separate container so they don't lock the live DB.

6. Environment variables and secrets

Every app has an Environment Variables tab. Two modes:

• Build-time variables — available during the build step (e.g. NEXT_PUBLIC_* for Next.js)
• Runtime variables — available to the running process

Mark a variable as Secret and Coolify obscures it in the UI and logs. Mark it Shared and it's available to every app in the project (good for shared API keys).

Bulk-import .env files with the Developer view — paste the whole file and Coolify parses it.

7. Backups and disaster recovery

The hardest lesson in self-hosting: untested backups aren't backups. Coolify has three backup layers; use all three.

1. Database backups (per-DB). Configured per database. Goes to local storage by default. Add S3 destination for offsite:

# In your database's Backup configuration
S3 Bucket: my-coolify-backups
S3 Region: us-east-1
S3 Endpoint: https://s3.amazonaws.com  (or any S3-compatible provider)
S3 Access Key: AKIA...
S3 Secret Key: ...

2. Volume backups. For apps with file storage (image uploads, user content), Coolify can snapshot Docker volumes. Configure per-app under Storage.

3. Coolify itself. The Coolify control plane stores its own database. Run a manual export occasionally:

cd /data/coolify
docker compose exec postgres pg_dump -U coolify coolify > coolify-backup-$(date +%F).sql
# Then rsync this off the VPS

For larger setups, our Vaultwarden backup pattern (sqlite + rclone + cron) translates directly.

8. Monitoring and logs

Each app's Logs tab streams stdout/stderr in real time. Switch to Build Logs for past build output. The Metrics tab shows CPU, RAM, and network per container.

For deeper observability, pair Coolify with our monitoring stack — Grafana + Prometheus running on the same VPS (Premium plan recommended; needs the RAM headroom). Coolify exposes container metrics in Prometheus format on :9090 if you enable it.

9. Reference: architecture and limits

The technical bits, gathered in one place so you don't have to dig through docs later.

Component overview

Coolify is a Laravel app (PHP) backed by PostgreSQL, with a separate Pusher-compatible realtime server for live UI updates and a "Coolify Terminal" service for in-browser SSH. All of these run as Docker containers themselves — Coolify is, ironically, deployed via Docker.

Service	Container	Default Port	Purpose
Dashboard	coolify	8000	Web UI + API (Laravel)
Database	coolify-db	5432	Coolify's own Postgres
Realtime	coolify-realtime	6001	Pusher-compatible WebSocket
Terminal	coolify-terminal	6002	In-browser SSH terminal
Proxy	coolify-proxy (Traefik)	80, 443	HTTPS termination for all apps

Build engine: Nixpacks vs Dockerfile

Coolify uses Nixpacks by default — the same auto-detection engine Railway popularized. It reads your repo, identifies the language/framework, picks the right base image, and builds. Works flawlessly for: Next.js, Astro, SvelteKit, Nuxt, Express, Fastify, Django, Rails, Flask, Go (most), Rust (most), Elixir, Laravel.

Drop in a Dockerfile at the repo root and Coolify uses that instead — full control when you need it. docker-compose.yml stacks also work (for multi-service apps).

Resource limits

Set per-app CPU and RAM caps under the app's Resources tab. Useful for preventing one runaway app from starving the rest. Coolify uses Docker's cgroup limits — same mechanism dedicated server hosts use.

Realistic app counts per plan

Plan	Idle Coolify	Small apps	Workloads
Starter ($7.99, 4 GB)	~1.2 GB	5–7	Static sites, small APIs
Pro ($15.99, 8 GB)	~1.2 GB	15–20	Full-stack apps + 2–3 databases
Premium ($35.99, 16 GB)	~1.2 GB	40–60	Production deployments with monitoring

Upgrading Coolify

Coolify auto-checks for updates. Inside the dashboard: Settings → Update → click. It pulls the new images, runs migrations, restarts services. Total downtime: 30–60 seconds. Your apps keep running through the upgrade (they're on a different Docker network).

FAQ

Related posts

Tutorial

Install Docker on Ubuntu 22.04

The Docker setup Coolify uses under the hood — useful for debugging or running custom containers.

Tutorial

Nginx + Let's Encrypt SSL

Coolify uses Traefik instead — but the SSL concepts translate. Good background reading.

Tutorial

Install & Secure PostgreSQL

When Coolify's built-in Postgres isn't enough — running a standalone production DB.