Coolify and the self-hosted PaaS route

What Coolify actually is

Heroku's free tier died, and Vercel bills stack up fast past the hobby limits. Meanwhile a $5 VPS sits mostly idle with 2 CPUs and 4GB of RAM. Coolify is the project that closes that gap: an open-source Platform-as-a-Service you run on your own server.

Under the hood it manages Docker containers, handles reverse proxying with Traefik, provisions SSL through Let's Encrypt and wraps it all in a clean UI. You connect your GitHub or GitLab repos, push to main, and your app rebuilds and redeploys. Need PostgreSQL or Redis? One click. It occupies the same slot as Heroku, Vercel or Railway, except the compute is yours and the software is free.

What you need before you start

The prerequisite list is short, which is part of the appeal.

• A VPS with 2GB+ RAM: Hetzner's entry box at $3.97/month (2 vCPU, 4GB RAM), DigitalOcean Basic at $4/month, or a Vultr equivalent around $6.
• A fresh Ubuntu 22.04 or Debian 12 install.
• A domain name, pointed at the server for SSL.
• SSH access as root or a sudo user, and enough terminal comfort to run one command without panic. That is genuinely the skill bar.

Install to first deploy

Installation is a single script fetched from Coolify's CDN and piped to bash over SSH. It installs Docker, Docker Compose and Coolify itself in two to three minutes, then prints the URL of your new dashboard on port 8000, where you create the admin account.

Before deploying, point DNS at the box: one A record for the dashboard and a wildcard record so Coolify can auto-assign subdomains to apps. Then connect GitHub or GitLab via OAuth, create a resource from a repo, and Coolify auto-detects most frameworks, filling in build command, start command and port for you. Click deploy: it clones, builds, containerizes, wires Traefik routing and provisions SSL, with live build logs when something fails. Realistic time from bare VPS to first app in production: about half an hour, most of it DNS.

Databases, secrets and SSL

Databases are containers too: a PostgreSQL or Redis resource is one click, and Coolify hands you the connection string. The internal Docker network resolves containers by name, so your app reaches its database without anything being exposed publicly.

Environment variables get a proper UI, are encrypted at rest, and are injected into containers at runtime rather than baked into images, with a separate section for build-time secrets. SSL is fully automatic: add a domain to a resource and Coolify runs the ACME challenge, installs the certificate and renews it. No nginx configs, no certbot cron jobs. When provisioning fails, the cause is almost always unpropagated DNS or a closed port 80 or 443.

Backups and monitoring

Coolify backs up databases to any S3-compatible storage: point it at a bucket, choose a frequency, daily is the sane default, and a retention period, and backups run as scheduled jobs alongside manual triggers.

Built-in monitoring is honest but basic: container status, restart counts and logs. For production workloads, add external uptime monitoring, and deploy a log or metrics stack, Loki for searchable logs, Prometheus with Grafana for dashboards, through Coolify's own one-click service marketplace. The tooling is all there; the point is that assembling and watching it is your job.

The honest limits

Coolify is excellent at what it is, and it is important to be clear about what it is not.

• Single server: no built-in clustering. If the VPS dies, everything on it dies with it.
• Shared resources: all apps contend for one machine's CPU and RAM, and one greedy process can starve the rest.
• No auto-scaling: a traffic spike hits your server's ceiling, and the ceiling wins.
• You are the operator: updates, security patches and outages at any hour are yours, with nobody behind you.
• The redeeming feature: everything is standard Docker, so leaving means pointing CI/CD elsewhere. There is no proprietary trap in the exit.

Leaving Vercel: the wider field

Coolify is usually evaluated by teams leaving a managed PaaS, most often Vercel. Vercel is genuinely great, and the honest reason to leave is not quality: it is usage-based pricing that can jump an invoice from $0 to $150+ overnight when a project takes off, and platform features like edge middleware that quietly harden into lock-in. The alternatives each pick a different lane.

• Railway: the fastest managed setup, five minutes from signup to deployed. Hobby at $5/month with $5 of credit included, Pro at $20 per seat, then usage-based resource billing; a small always-on app lands around $10-15/month, $20-25 with a database. Single region, and the meter still deserves watching.
• Fly.io: the only real answer to Vercel's edge network. Containers across 30+ regions with anycast routing, a free tier of three small VMs, shared CPUs from about $2/month and 100GB of free bandwidth. The cost is complexity: volumes, machines and distributed state are yours to reason about.
• Render: boring in the best way. Flat pricing, $7/month starter services, $7/month entry PostgreSQL, free static hosting, so a small full-stack app runs $14/month, every month, no calculator. Single region by default and no edge functions.
• CapRover: the old reliable of self-hosted PaaS, around since 2017. Dated UI and slower development than Coolify, but it does Docker Swarm clustering across multiple VPSes, which Coolify does not. Same free-software-plus-VPS economics.

Which platform for which team

The decision compresses well once you name your constraint.

• Tight budget and comfortable with a terminal: Coolify. One $4-5 box runs multiple apps, and you pocket the convenience tax.
• Predictable invoices above all: Render. Flat tiers, no usage math, no surprise line items.
• Users on several continents and latency matters: Fly.io. Nothing else in this list actually distributes compute.
• Shipping this week: Railway. Connect, deploy, done, and revisit the bill later.
• Multiple servers without Kubernetes: CapRover and Docker Swarm.
• Deep on Vercel's edge features and the bill makes sense: staying on Vercel is a legitimate answer too.

Web apps are not autonomous agents

One boundary matters more than any platform choice on this page: everything above is built for request-driven web apps, processes that wake for a request, respond and go quiet. Autonomous agents are the opposite shape: long-running, stateful, memory-spiky processes that hold sessions for days, drive a browser and must recover with their state intact, not just get restarted clean.

A PaaS restart loop does not understand any of that. It will happily bounce a container while the agent inside loses its workspace, and it has no answer for an agent that is alive but silently stuck, or for packing many agents safely on shared capacity. That gap is what an agent-native platform covers: Molted runs OpenClaw and Hermes fleets with self-healing that catches crashes in under 60 seconds, versioned workspaces, and density that packs roughly 3x more agents per machine, in production since January 2026. Run your web apps on Coolify, and run your agents on infrastructure that knows what an agent is.