The Real Need for a PaaS Deployer on a VPS
A bare VPS gives you root access to a virtual machine: you must manage Docker, updates, the reverse proxy, TLS certificates, environment variables, backups and rollbacks yourself. A self-hosted PaaS takes over that operational layer. It exposes a workflow similar to Render or Railway — you link a Git repository, deployment runs automatically, certificates arrive on their own — but on your own infrastructure. The question is not whether you need a PaaS, but which one to choose based on your VPS size and your profile.
Selection Criteria for a Self-Hosted PaaS
- Idle RAM — memory consumed by the platform when no deployment is running, critical on a 1–2 GB VPS
- UI and onboarding — interface quality, clarity of the onboarding flow, learning curve for a first deployment
- Multi-server — ability to manage multiple VPS instances from a single platform instance
- Preview deployments — automatic environment creation per pull request for real-condition review before merging
- Rollback — ease of reverting to a previous version after a regression
- Built-in observability — real-time logs, metrics and alerts without an external plugin
- Licence and open-source model — Apache 2.0, MIT or BSL, and what that means for commercial use
- Maturity and community — project age, release frequency, production feedback volume
Coolify: Full Feature Coverage, Significant Memory Footprint
Coolify is the most starred self-hosted PaaS on GitHub. Its main strength is feature coverage: it handles Dockerfile apps, Nixpacks and Buildpacks builders, databases (PostgreSQL, MySQL, Redis, MongoDB), one-click services (Plausible, Umami, Gitea, n8n), cron jobs and pull-request preview deployments. The interface is polished, with guided onboarding and thorough documentation. The trade-off is RAM: the Coolify instance, with its internal dependencies (Redis, Soketi for real-time WebSockets, internal PostgreSQL), consumes between 600 MB and 1 GB at startup — sometimes more. On a 2 GB VPS that leaves between 1 and 1.4 GB for your applications. The official recommendation is 2 GB minimum, 4 GB for comfortable operation. Multi-server management is available since v4 via remote agents, and the licence is Apache 2.0 for self-hosting.
Coolify by the Numbers
- Idle RAM: 600 MB – 1 GB (instance alone, excluding applications)
- Minimum requirements: 2 GB RAM, 2 vCPU, 30 GB storage
- Licence: Apache 2.0
- Multi-server: yes, via remote agents (since v4)
- Preview deployments: yes, native
- Rollback: yes, with deployment history
Dokploy: Lightweight Footprint, Fast Onboarding
Dokploy explicitly positions itself as a lightweight alternative to Coolify and cloud PaaS platforms. It targets developers who find Coolify too heavy for an entry-level VPS. The interface is clean, built with Next.js, and the first deployment is fast — a single command installs everything. Idle RAM is its main argument: between 150 MB and 300 MB depending on configuration, with no mandatory internal Redis or database. On a 1 GB VPS, Dokploy leaves room for your applications where Coolify would be cramped. Dokploy supports Dockerfiles, Compose files, Docker Hub images, managed databases and TLS certificates via Traefik as its internal reverse proxy. Its current limitations: preview deployments are less complete than Coolify's, the one-click service library is smaller, and the project is younger and therefore less battle-tested under heavy load. Dokploy is MIT-licensed.
Dokploy by the Numbers
- Idle RAM: 150 – 300 MB
- Minimum requirements: 1 GB RAM, 1 vCPU (2 GB recommended)
- Licence: MIT
- Multi-server: yes (multi-node management)
- Preview deployments: partial
- Rollback: yes
CapRover: Maturity, Lightness and Docker Swarm Cluster
CapRover has existed since 2018 and was, until Coolify emerged, the reference self-hosted open-source PaaS. It stands out for its maturity, low footprint and a very complete CLI. The web interface is functional but more austere than its modern competitors; it remains perfectly readable for DevOps profiles familiar with Docker. Idle RAM is remarkably low: between 100 MB and 200 MB, with a Docker Swarm-based architecture enabling horizontal scalability in a cluster. CapRover handles Dockerfiles, Docker Hub images and Captain Definition files, along with a library of over 100 one-click deployable applications. Preview deployments are not native: they must be implemented via the CLI and scripts. Multi-node clustering via Docker Swarm is native and battle-tested. CapRover is Apache 2.0 licensed. Its main limitation: automatic PR preview deployments require additional scripts, and the interface is less modern than its two competitors.
CapRover by the Numbers
- Idle RAM: 100 – 200 MB (Docker Swarm + CapRover)
- Minimum requirements: 1 GB RAM, 1 vCPU
- Licence: Apache 2.0
- Multi-server: yes, native via Docker Swarm
- Preview deployments: not native (CLI scripts)
- Rollback: yes, via image versions
Coolify vs Dokploy vs CapRover: Comparison Table
| Criterion | Coolify | Dokploy | CapRover |
|---|---|---|---|
| Idle RAM | 600 MB – 1 GB | 150 – 300 MB | 100 – 200 MB |
| Interface | Modern, polished | Clean, fast | Functional, austere |
| Multi-server | Yes (remote agents) | Yes (multi-node) | Yes (native Docker Swarm) |
| Preview deployments | Native | Partial | Not native (CLI scripts) |
| Rollback | Deployment history | Yes | Via image versions |
| Built-in observability | Logs, metrics, alerts | Real-time logs | Basic logs and metrics |
| Learning curve | Moderate | Low | Moderate to high |
| Licence | Apache 2.0 | MIT | Apache 2.0 |
Recommendation by Profile
The choice of a self-hosted PaaS depends less on features than on your concrete situation: available VPS size, team size, CI/CD automation needs.
Which Tool for Which Profile
- Solo developer or starter — Dokploy on a 1–2 GB VPS: the low memory footprint leaves most resources to your applications, and onboarding is immediate
- Agency or team of 3–10 people — Coolify on a 4 GB VPS minimum: the feature coverage, native preview deployments and one-click service library justify the larger memory footprint
- Experienced DevOps, multi-server infrastructure — CapRover if you know Docker Swarm and want a proven, lightweight solution; Coolify v4 if you prefer a modern interface with remote agents
- Severe RAM constraint (1 GB VPS) — Dokploy or CapRover only: Coolify cannot run in these conditions
- CI/CD pipeline with PR review — Coolify for native preview deployments, or Dokploy if partial support is sufficient
The Trap Common to All Self-Hosted PaaS Platforms
All three platforms rely on Docker and an internal Docker network to connect the reverse proxy to application containers. If your application is not attached to the internal proxy network — and is instead directly exposed on the host — the proxy cannot reach it: classic symptom, an application shown as 'deployed' in the dashboard but returning 502 from outside. A second shared trap: wildcard DNS. Configuring *.your-domain.com → VPS IP lets all three platforms automatically assign a subdomain to each app and issue the TLS certificate without intervention. Without that wildcard, you must create a DNS record manually before each deployment.
Your VPS as the Foundation of Your PaaS
All three platforms run on any Linux VPS with Docker installed. The RAM available after installing the platform is the decisive variable: Dokploy and CapRover work from 1 GB, Coolify requires 2 GB minimum and runs comfortably on 4 GB. In all cases, SSD storage with at least 20 GB is recommended to hold Docker images and data volumes. The platform choice does not determine the service level — it defines the margin you leave for your applications.
