Coolify: The Open-Source Self-Hosted PaaS That Replaces Vercel, Heroku, and Netlify

You deploy to Vercel. It works. Then the bill arrives. Or you hit a limit. Or you need a database that isn't on their approved list. Or you just want to run something on a $5 VPS you already own.

Most developers know the managed PaaS names. Fewer know there's a 63k-star open-source alternative that gives you the same push-to-deploy experience on your own servers — with 360+ one-click services, automatic HTTPS, preview deployments, and zero vendor lock-in.

That alternative is Coolify.

---

What Coolify Actually Is

Coolify is an open-source, self-hostable Platform-as-a-Service. You install it on a server (VPS, bare metal, Raspberry Pi, anything with SSH), and it becomes your personal Vercel/Heroku/Netlify.

But the architecture is fundamentally different from managed platforms:

Managed PaaS (Vercel/Heroku)	Coolify (Self-Hosted)
Control plane + runtime + infrastructure bundled	Control plane only — you provide the servers
You deploy to their cloud	You deploy through Coolify to your servers
Vendor lock-in: configs, data, routing all live with them	Your configs stay on your servers. Stop using Coolify? Your apps keep running.
Pricing scales with usage	Free (Apache 2.0). You pay only for your VPS.

The key insight: Coolify separates the control plane from the workload runtime. The Coolify instance stores configuration and coordinates actions via SSH. Docker on each connected server runs your actual applications, databases, and services.

Your application traffic never passes through the Coolify server. Requests hit the reverse proxy (Traefik or Caddy) on the resource server directly.

---

The Architecture: Control Path vs. Traffic Path

This is the part most developers misunderstand.

Control Path (Coolify → Your Server)

• You click "Deploy" in the dashboard (or push to Git)
• Coolify reads config from its PostgreSQL database
• Queues the job via Laravel Horizon + Redis
• SSHes into the target server
• Runs Docker commands: build, pull, start containers, configure networks

Traffic Path (User → Your App)

• DNS points your domain to the resource server (not the Coolify server)
• coolify-proxy container (Traefik/Caddy) terminates TLS
• Routes request over Docker network to your app container
• Coolify control plane is not in the request path

This means:

• If the Coolify dashboard goes down, your running apps stay up
• If you lose SSH to a server, existing containers keep serving traffic
• You can run Coolify on one $5 VPS and deploy to ten other servers

---

What You Can Deploy

Applications (from Git):

• Static sites (Next.js, Astro, Vite, Hugo, etc.)
• Node.js, Python, Go, Rust, PHP, Ruby, Java, .NET, Bun, Deno
• Dockerfile, Docker Compose, Nixpacks, Railpack, or prebuilt images
• Automatic framework detection via Nixpacks/Railpack

Databases (one-click, managed):

• PostgreSQL, MySQL, MariaDB, MongoDB, Redis, KeyDB, Dragonfly, ClickHouse
• Persistent volumes, automated S3-compatible backups, optional public access

360+ One-Click Services:

• Analytics: Plausible, Umami, PostHog
• Auth: Logto, PocketBase, Authentik
• Databases: Supabase, NocoDB, Baserow
• AI: Ollama, Open WebUI, AnythingLLM
• Dev tools: GitLab, Gitea, Drone, Woodpecker
• Productivity: Nextcloud, Outline, Cal.com, N8n
• Monitoring: Uptime Kuma, Grafana, Prometheus
• And hundreds more — each with generated credentials, persistent storage, and health checks

---

Build Methods: How Your Code Becomes a Container

Coolify doesn't force one build system. Pick per project:

Method	Use When
Nixpacks	Zero-config builds for most frameworks (auto-detects Node, Python, Go, etc.)
Railpack	Faster, Rust-based alternative to Nixpacks (beta)
Dockerfile	Full control — you write the Dockerfile
Docker Compose	Multi-container apps (app + db + redis + worker)
Static	Pre-built static sites (output folder → nginx)
Docker Image	Pull ghcr.io/user/app:v1.2.3 — no build step

Smart caching: For Git sources using Nixpacks/Railpack/Dockerfile, Coolify tags images with the commit SHA. If the commit and build config haven't changed, it skips the build entirely and reuses the existing image.

Build servers: Offload builds to a dedicated server (saves resources on small VPS). The build server pushes the image to a registry; deployment servers pull it.

---

Deployment Strategies: Zero-Downtime by Default

For single-container apps, Coolify uses rolling updates:

1. Build/pull new image (current container keeps running)
2. Start new container on same Docker network
3. If health check configured → wait for healthy
4. Switch proxy routing to new container
5. Remove old container

Stop-then-start fallback when rolling isn't possible (host port mappings, fixed container names, preview deployments).

Docker Compose uses docker compose up reconciliation. Swarm uses docker stack deploy.

Instant rollback: Every successful deployment retains its image. One click → previous version running in seconds. (Does not restore database data — keep separate backups.)

---

Networking: Three Paths, Clear Boundaries

1. Public HTTP/HTTPS (via Coolify Proxy)

• Domain → DNS → Resource Server IP
• coolify-proxy (Traefik/Caddy) on port 80/443
• TLS via Let's Encrypt (automatic)
• Proxy forwards over Docker network to container port

2. Private Container Traffic

• Shared Docker network (coolify by default)
• Containers talk via service name + internal port
• No public exposure, no host ports
• Databases, internal APIs, worker queues

3. Direct Host Ports

• host_port:container_port mapping
• Bypasses proxy entirely
• For non-HTTP protocols (TCP/UDP, databases with external clients)
• Disables rolling updates for that resource

Your responsibility: DNS records, firewall/security groups (80, 443, SSH, any direct ports), making apps listen on the configured container port.

---

Data Persistence: What Survives a Redeploy

Layer	Location	Survives Redeploy?
Coolify config (projects, env vars, credentials)	Coolify instance (PostgreSQL)	Yes
Docker images, build artifacts, containers	Connected server	Images yes, containers replaced
Application data (uploads, SQLite, generated files)	Docker volumes / bind mounts	Yes — if configured
Database data	Docker volumes or external managed DB	Yes
Reverse proxy config + TLS certs	Resource server	Yes

Critical: Unmounted container filesystem data is lost on redeploy. Configure persistent volumes for anything that must survive.

---

The MCP Integration: AI Agents That Can Deploy

Coolify exposes an MCP (Model Context Protocol) server at https://your-coolify/mcp. Connect Claude, Cursor, or any MCP client — your AI agent can:

• List resources, servers, deployments
• Trigger deployments
• Read logs, restart services
• Troubleshoot failed deployments

All with the same API tokens and team permissions you already use. This is a genuinely useful AI integration — not a gimmick.

---

What You Actually Need to Run It

Minimum self-hosted setup:

• 1 server for Coolify (2 GB RAM, 2 vCPU, 30 GB disk)
• 1+ servers for deployed resources (scale as needed)
• Docker Engine 24+
• SSH access (key-based)
• Domain for the Coolify dashboard (for HTTPS)

Install:

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

That's it. The script sets up the three base containers (coolify, coolify-db, coolify-redis), the reverse proxy, and the coolify Docker network.

---

What Coolify Does NOT Give You (And That's Fine)

• Managed infrastructure — you provision, secure, and monitor your VPS
• Global edge network — your app runs where your server is (add Cloudflare CDN if needed)
• Automatic horizontal scaling — you add servers, Coolify deploys to them
• Built-in CI/CD beyond Git push — webhooks integrate with GitHub Actions/GitLab CI
• SLA or support contract — it's open source (Coolify Cloud exists if you want managed)

---

The Trade-offs, Honestly

Coolify Wins	Managed PaaS Wins
Zero vendor lock-in	Zero ops burden
Run anything Docker supports	Global edge by default
Predictable cost (VPS pricing)	Automatic scaling
Full data ownership	Managed databases with HA
360+ services one-click	Enterprise compliance certs
MCP for AI agents	Team SSO/SAML (Coolify has 2FA + OAuth)

---

Why This Matters for Developers

You've deployed to Vercel. You've paid for Heroku dynos. You've configured Netlify build plugins.

Coolify lets you own the platform layer without building it from scratch. It's not "Kubernetes the hard way" — it's a Laravel + Docker control plane that speaks SSH and gives you a dashboard, API, CLI, and now MCP.

For side projects, client work, internal tools, or production apps where you want control over infrastructure: Coolify is the middle ground between "manual Docker on a VPS" and "$500/month managed PaaS."

The repository: github.com/coollabsio/coolify (63.2k stars, 698 contributors, Apache 2.0)