
“Simple” app platforms stay simple until you need private networking, predictable invoices, or a real shell for debugging. If you want Git-based deploys without moving your production stack into a managed PaaS, you can install Coolify on a VPS. You get a Heroku/Vercel-style deployment layer on infrastructure you control.
This is an open-source spotlight for operators. That includes people responsible for websites, APIs, background workers, and the servers underneath.
You’ll see what Coolify does well, what it replaces, and how to run it with sensible defaults. Expect HTTPS at the edge, backups you can restore, and upgrades that don’t become surprises.
What Coolify is (and who it’s for)
Coolify is a self-hosted platform-as-a-service (PaaS) that runs on your server. It turns “deploy this repo” into a repeatable workflow.
You connect a Git provider, select a repository, and Coolify builds and runs your app as containers on your own machine.
It’s a good fit if you:
- Deploy multiple small-to-mid apps (Node.js, Python, PHP, Go, static sites) and don’t want custom Docker work for every repo.
- Want something more structured than “SSH in and hope you remember the steps.”
- Run client projects and need consistent deploys without spinning up a separate panel stack per customer.
- Prefer to keep traffic, logs, and data under your policies (and your invoices).
Coolify is open-source software (license and terms can vary by component and edition; verify against the project’s repository before production use).
The operator reality is straightforward: you own the box, you own the patches, and you can move to a new VPS whenever you need to.
Why developers switch: Coolify vs hosted platforms
Hosted platforms work well when you truly want “no servers.” The trade-offs often show up later.
Common friction points include pricing tied to build minutes, sleep policies, bandwidth charges, restricted networking, and limited visibility during incidents. Coolify flips that model. You run it on your own CPU, RAM, disks, and network rules.
Here’s the comparison most teams actually care about:
- Cost model: Hosted PaaS often charges per app/runtime/build/bandwidth. With Coolify, you pay for your server. Budgets get simpler.
- Debugging: You can still drop to Docker logs, system metrics, kernel settings, and firewall rules.
- Networking: You control private networks, internal-only services, and database access patterns.
- Compliance & privacy: Data stays on your VPS, in your region, under your access model.
The downside is also clear: patching, backups, and basic security are your job.
If that feels like overhead, stick with managed platforms. If it feels like control, Coolify is a solid option.
Infrastructure planning before you deploy
Coolify isn’t heavy, but it’s not a “tiny sidecar” either. It runs its own services alongside your apps.
Plan headroom so builds and image pulls don’t steal resources from production traffic.
Practical VPS sizing (starting points)
- Small lab / 1–3 low-traffic apps: 2 vCPU, 4 GB RAM, 60+ GB NVMe.
- Serious dev/staging + a few production apps: 4 vCPU, 8 GB RAM, 120+ GB NVMe.
- Many apps + frequent builds: 6–8 vCPU, 16 GB RAM, 200+ GB NVMe (or move builds to a separate worker box).
Don’t underestimate disk. Container images and build caches grow quietly until a deploy fails at 2 a.m.
NVMe also helps. You get faster builds, faster pulls, and fewer “why is this so slow?” moments.
Choose the right HostMyCode plan
If you want full control over Docker, firewall rules, and reverse proxy config, start with a HostMyCode VPS.
If you’d rather handle deployments while someone else helps with OS updates and baseline hardening, use managed VPS hosting.
DNS and firewall basics
- Point
coolify.yourdomain.comto your VPS IP with an A/AAAA record. - Open inbound ports 80 and 443 for web access and ACME HTTP validation.
- Keep SSH restricted (ideally keys-only, and limit to your office/VPN IPs if possible).
If you want a simple baseline against obvious abuse, this HostMyCode walkthrough is a good starting point: Set Up Fail2ban for Nginx on Ubuntu VPS.
Deploy Coolify with Docker Compose on Ubuntu
Coolify typically runs on Docker. For operators, that’s the point. You get fewer OS-level dependencies, and upgrades are often “pull new image, restart.”
Use Ubuntu Server LTS unless your environment standardizes on Debian/AlmaLinux.
1) Install Docker and Docker Compose plugin
On Ubuntu, Docker’s repository packages are the usual choice. On a fresh box:
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker $USER
Log out and back in so your user picks up the Docker group membership. Then verify:
docker --version
docker compose version
2) Create a clean directory layout
Put platform services in one predictable location. This makes backups, audits, and “where did we install this?” conversations easier.
sudo mkdir -p /opt/coolify
sudo chown -R $USER:$USER /opt/coolify
cd /opt/coolify
3) Use the upstream installation method (recommended)
Coolify maintains an installer and reference Compose files. Those change over time, so avoid copying old snippets from random gists.
Pull the official method from the project’s docs. Then pin it in your runbook so you can repeat it later.
During install, check these items as you go:
- Where persistent data lives (volumes and bind mounts).
- Which ports are exposed (and whether you can keep the UI behind a reverse proxy).
- Admin access: set a strong password and enable MFA immediately if available.
If you don’t want the Coolify UI directly exposed to the internet, put it behind a reverse proxy with TLS (next section).
On a VPS that also runs production apps, that posture is usually the right call.
Reverse proxy with HTTPS (Caddy example)
You can terminate TLS with Nginx, Caddy, Traefik, or a dedicated edge. Caddy works well on single-server setups because it automates Let’s Encrypt and keeps configuration readable.
HostMyCode has a detailed walkthrough you can reuse here: Set Up Let’s Encrypt With Caddy for a VPS Site. If you need wildcard certificates for lots of app subdomains, see: Add Let’s Encrypt Wildcard SSL With Caddy and DNS.
A minimal Caddyfile for Coolify
Assuming Coolify listens on a local port (example: localhost:3000). Adjust this to match your deployment.
coolify.yourdomain.com {
encode zstd gzip
header {
Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
X-Content-Type-Options "nosniff"
X-Frame-Options "SAMEORIGIN"
Referrer-Policy "strict-origin-when-cross-origin"
}
reverse_proxy 127.0.0.1:3000
}
If you can, keep Coolify bound to localhost. Let the reverse proxy be the only internet-facing entrypoint.
Firewall rules stay simpler, and accidental exposure is less likely.
Quick diagnostic: TLS and headers
- Check certificate:
curl -I https://coolify.yourdomain.com - Confirm HSTS is present and correct.
- Confirm the app does not respond on the public IP/port directly.
Git-based deploys that won’t bite you later
Coolify works best when you treat deploys as an operation you can repeat under pressure. A few habits up front save you time later.
Use runtime secrets, not repo secrets
Store secrets in Coolify’s environment/secret management rather than committing .env files.
Rotate keys when staff changes. Keep separate values per environment (staging vs production).
Pick a predictable build strategy
- Buildpacks are quick to start and cover common stacks well.
- Dockerfile gives you full control and is easier to reproduce outside Coolify.
If you already have Dockerfiles, use them. Portability matters when you migrate servers or need to reproduce a failing build fast.
Logs and monitoring: don’t wait for the first incident
At minimum, centralize “is it up” checks. With multiple apps behind Coolify, a dead worker queue can look fine until customers complain.
Two practical next steps:
- Uptime checks for endpoints and background jobs.
- Dashboards for CPU, memory, disk, and container restarts.
If you want dashboards without turning observability into a project, this guide pairs well with a Coolify setup: Deploy Grafana on a VPS With Docker, TLS, and Backups.
Backups that actually restore
Protecting Coolify is only part of the job. The bigger risk is losing app databases, uploaded files, or platform state after a disk failure or a bad update.
What to back up
- Coolify configuration and persistent volumes (whatever the installer places under
/optor Docker volumes). - Application data volumes (uploads, user-generated content, queues, object storage gateways).
- Databases (PostgreSQL, MySQL/MariaDB) using logical dumps or volume snapshots.
- Reverse proxy config (
/etc/caddy/Caddyfileor/etc/nginx/sites-available/).
A workable pattern: nightly dumps + encrypted offsite
Even if you take disk snapshots, keep database dumps. They’re portable, easy to test, and straightforward to restore into a scratch container.
If your apps use MySQL/MariaDB, adopt this approach: Set Up Automatic MySQL Backups With Tested Restores. The “tested restores” part matters; untested backups are just files.
Example: backup script skeleton (volumes + dumps)
This is deliberately generic. Update container names and paths to match your setup.
#!/usr/bin/env bash
set -euo pipefail
BACKUP_DIR="/var/backups/coolify"
TS="$(date -u +%Y%m%dT%H%M%SZ)"
mkdir -p "$BACKUP_DIR/$TS"
# 1) Export a Compose snapshot (good for rebuilds)
cd /opt/coolify
cp -a docker-compose.yml "$BACKUP_DIR/$TS/" 2>/dev/null || true
# 2) Backup Caddy config
cp -a /etc/caddy "$BACKUP_DIR/$TS/" 2>/dev/null || true
# 3) Example Postgres dump (if you run one)
# docker exec -t your-postgres pg_dump -U postgres -d yourdb | gzip > "$BACKUP_DIR/$TS/yourdb.sql.gz"
# 4) Archive persistent data directories if you use bind mounts
# tar -C /opt -czf "$BACKUP_DIR/$TS/coolify-data.tgz" coolify
# 5) Rotate local backups (keep 14 days)
find "$BACKUP_DIR" -mindepth 1 -maxdepth 1 -type d -mtime +14 -print -exec rm -rf {} \;
Send backups offsite. A second VPS, object storage, or a backup server all work.
Encrypt before upload if you don’t fully trust the destination.
How to update Coolify safely
Platform upgrades usually fail in two places: container image changes and database/state migrations. The way through is routine and boring.
Pre-update checklist
- Take a fresh backup (and confirm it exists offsite).
- Snapshot the VPS if your provider supports it (fast rollback).
- Check free disk space:
df -handdocker system df. - Plan a short maintenance window if you deploy production apps from this host.
Update workflow (typical Docker pattern)
Exact commands depend on the upstream install method, but most Dockerized upgrades follow this pattern:
cd /opt/coolify
docker compose pull
docker compose up -d
docker image prune -f
After the restart, watch logs for a bit:
docker compose logs -f --tail=200
If a migration stalls, don’t hammer restart and hope. Capture logs, confirm disk space, and check whether the release expects a one-time upgrade command.
Common pitfalls on a single VPS
Coolify makes deployments feel easy. That can hide sharp edges until you hit scale, or until something breaks at the wrong time.
- Out-of-disk incidents: Build caches and old images pile up. Schedule periodic pruning, and alert on disk usage.
- RAM pressure during builds: Compiling dependencies spikes memory. Add swap on small instances, or choose a bigger VPS.
- Too many public services: Keep internal services on private networks and expose only what must be exposed.
- Single point of failure: One VPS is one failure domain. If revenue depends on it, plan a second node or a standby restore plan.
Where Coolify fits in a HostMyCode stack
Coolify makes sense when you want app-platform ergonomics on infrastructure you can inspect and control.
Pick the hosting model that matches how you work:
- One server, many apps: A HostMyCode VPS with NVMe is the simplest starting point.
- Team wants the platform, not OS chores: managed VPS hosting keeps patching and baseline hardening from becoming a weekly distraction.
- High traffic or heavy builds: Move to dedicated servers when CPU and disk contention start affecting deploy time or latency.
Summary: treat it like a platform, not a side project
If you want Git-driven deploys but you’re done paying for managed platform limits, Coolify hits a useful middle ground.
You keep a good developer workflow, avoid lock-in, and run the deployment surface on your own VPS.
The line between a weekend experiment and a production platform is discipline. Put TLS at the edge, back up what matters (and test restores), and upgrade with a rollback plan.
Do that early and the system stays boring—in a good way.
When you’re ready to run it on infrastructure that plays nicely with Docker workloads, start with a HostMyCode VPS, or choose managed VPS hosting if you want HostMyCode handling the server plumbing while you focus on shipping.
If Coolify is your route away from managed platforms, size your VPS for builds, image caches, and real production traffic. HostMyCode offers VPS hosting when you want full control, and managed VPS hosting when you want help with OS maintenance without giving up the flexibility of a VPS.
FAQ
Do I need a separate VPS for Coolify?
Not always. For a few low-traffic apps, a single VPS is fine.
If you run revenue-critical services or build frequently, separating the platform from production workloads reduces both risk and resource contention.
Can I run Coolify behind Nginx instead of Caddy?
Yes. Any reverse proxy that supports HTTPS and WebSockets can work.
If your standard is Nginx, use it. Bind Coolify to localhost and expose only the proxy.
What’s the minimum backup I should have?
At minimum: (1) an offsite copy of Coolify’s persistent data/config, (2) database dumps for each app database, and (3) a written restore procedure you’ve tested once.
How do I roll back after a bad update?
The fastest rollback is a VPS snapshot taken just before upgrading.
Without snapshots, you’ll need to revert container images and restore volumes from backup, which takes longer and leaves more room for mistakes.
Is Coolify a replacement for cPanel or Plesk?
Not really. cPanel/Plesk are hosting control panels built around shared-hosting workflows (mailboxes, FTP, PHP versions, DNS helpers).
Coolify is an app deployment platform built around Git-based deploys and containers.