
You don’t need a full Kubernetes cluster for “push to deploy” workflows. If your apps run cleanly in containers and you want predictable monthly spend, the sweet spot is to deploy CapRover on a VPS. You get a small, Heroku-like platform on infrastructure you control.
This is an open-source spotlight. We’ll cover what CapRover is, who it fits, and how it compares to hosted PaaS options.
We’ll also walk through running it safely on a real VPS with HTTPS, backups, and upgrades. You’ll see where Docker Compose helps, plus the sizing and failure modes that show up in production.
CapRover in one paragraph (and who it’s for)
CapRover is an open-source, self-hosted PaaS built on Docker. It provides a web UI, one-command deploys, app templates, built-in Let’s Encrypt, and subdomain routing to your containers. It’s designed for teams that want a “platform” feel without operating a cluster.
It’s a good fit if you:
- Run small-to-medium web apps (Node.js, Python, PHP, Go) and want repeatable deploys.
- Need multiple apps on one server with clean subdomain routing (app1.example.com, api.example.com).
- Prefer containers over managing language runtimes on the host.
- Can live with a single-node platform (scale vertically and use external databases).
License note: CapRover is an open-source project (widely distributed under the Apache 2.0 license). Confirm your exact version’s licensing and any bundled third-party components before you ship it inside a commercial product.
What CapRover replaces (and where it’s different)
The closest comparison is Heroku and similar hosted PaaS products (Render, Fly.io, Railway). Those services offload most operational work.
In return, you inherit their pricing model, networking constraints, and platform limits.
CapRover sits between “a raw VPS” and “a managed PaaS”:
- Cost and predictability: one VPS can host many apps. Your bill stays steady unless you resize.
- Control: you decide where data lives, how TLS is issued, and which images run.
- Operations: you still own patching, disk growth, monitoring, backups, and incident response.
If you want maximum convenience, a hosted PaaS wins. If you want to ship quickly without giving up infrastructure control, CapRover is a practical middle ground.
Resource sizing for a CapRover VPS (2026-friendly)
CapRover itself is lightweight. Most resource usage comes from your apps, build steps, databases, and how much you keep on the node.
- Starter (2–5 small apps): 2 vCPU, 4 GB RAM, 60–80 GB NVMe. Good for a couple of stateless APIs plus a lightweight frontend.
- Comfortable (5–15 apps): 4 vCPU, 8 GB RAM, 100–160 GB NVMe. This is a common landing zone for small teams.
- Build-heavy workloads: add CPU and RAM if you build Docker images on-server (CI-like builds can spike hard).
Two sizing traps show up early:
- Disk pressure: Docker images and old layers grow quietly. Plan headroom and prune on purpose.
- Swap is not a strategy: swap can prevent a crash, but sustained swapping makes deploys feel “stuck.”
If you want a clean starting point for a CapRover node, a HostMyCode VPS with NVMe storage gives you a solid balance of cost and performance.
If you don’t want to own patching and baseline hardening, use managed VPS hosting. That keeps your time focused on apps and deploy pipelines.
How CapRover is structured on the server (what you’re really running)
CapRover runs as a set of Docker containers plus a persistent data volume for its configuration. It also manages an Nginx-based routing layer in front of your apps.
In practice, you’re responsible for four moving parts:
- Docker Engine on the host
- CapRover containers (installed via the official installer)
- DNS for your base domain and wildcard (or explicit subdomains)
- Backups for CapRover config plus any app volumes/databases
Deploy CapRover on a VPS: the practical path (Docker + DNS first)
Think of setup as three decisions: your OS baseline, networking, and DNS.
Most “mystery” production issues come from cutting corners on one of these.
Pick a boring OS baseline
CapRover runs fine on mainstream Linux. In 2026, Ubuntu LTS or Debian Stable are the least surprising choices for most teams.
Keep the host lean. Install Docker, lock down SSH, and don’t stack unrelated services on the same node.
Install Docker, then run the CapRover installer
CapRover’s recommended path is its installer. It brings up the required containers and configuration.
If your team already uses Docker Compose elsewhere, that’s fine. Run CapRover normally, and use Compose for app stacks where it makes sense.
The key is to avoid fighting Docker networking.
Before you start, confirm:
- Ports 80 and 443 are reachable from the internet (TLS issuance depends on it).
- You have a domain or subdomain reserved for the CapRover dashboard (for example,
captain.example.com). - Your firewall allows inbound HTTP/HTTPS and SSH, and blocks everything else by default.
DNS: plan for wildcard routing from day one
CapRover works best when every app gets a subdomain. The clean way to do that is wildcard DNS.
Wildcard DNS avoids creating a new record for every deploy.
- A record:
captain.example.com→ your server IP - Wildcard A record:
*.example.com→ your server IP (or*.apps.example.comif you prefer an app subdomain zone)
If you want a straightforward way to manage records, HostMyCode’s domains and DNS service keeps everything in one place. You can still delegate DNS to another provider if you prefer.
If you’re using Cloudflare DNS, check proxy/orange-cloud settings during Let’s Encrypt validation.
Reverse proxy and HTTPS: two common patterns
CapRover can issue and renew Let’s Encrypt certificates for both the dashboard and app subdomains. For many setups, that’s enough.
In practice, teams tend to land on one of two patterns:
- Pattern A (simpler): let CapRover manage HTTPS and routing end-to-end.
- Pattern B (layered): run an external reverse proxy (Nginx or Caddy) in front, then forward to CapRover. This is useful for global security headers, IP allowlists for the dashboard, or sharing the server with other stacks.
If you already standardize on Nginx, the moving parts are the usual ones: server blocks, headers, and certificate handling.
This HostMyCode tutorial on reverse proxy setup with Nginx and SSL covers the same mechanics (even though the backend app is different).
A minimal Nginx front-proxy example (dashboard only)
A practical compromise is to front only the CapRover dashboard with Nginx. Leave app TLS inside CapRover.
This lets you tighten admin access without risking a routing break for every app.
Example snippet (adjust hostnames and upstream IP/port to your environment):
# /etc/nginx/sites-available/captain.example.com
server {
listen 80;
server_name captain.example.com;
location / {
return 301 https://$host$request_uri;
}
}
server {
listen 443 ssl http2;
server_name captain.example.com;
ssl_certificate /etc/letsencrypt/live/captain.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/captain.example.com/privkey.pem;
# Optional: IP allowlist for the admin UI
# allow 203.0.113.10;
# deny all;
location / {
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
Note: the CapRover dashboard port can differ depending on install choices. Use the snippet as a pattern, not a “copy/paste and hope.”
Confirm ports with docker ps and ss -tulpn.
Backups: what you must capture (and what you can ignore)
CapRover makes deployments easy. It also makes it easy to forget you now run “platform + data.”
Good backups turn a bad deploy day into an annoying hour instead of a lost weekend.
Back up three categories:
- CapRover configuration: platform settings, app definitions, certificates, and internal state.
- App data volumes: anything stored in Docker volumes (uploads, SQLite files, generated content).
- Databases: ideally on a separate service/VPS, but if they live on the same node you need consistent dumps.
CapRover config export
CapRover includes a backup/export option in the dashboard. Use it, schedule it, and store it offsite.
A nightly export to object storage or a second VPS is a solid baseline.
Encrypt exports if they include secrets. If you’re already running a password manager like Vaultwarden, HostMyCode’s guide on Vaultwarden behind Nginx proxy is a helpful reference for keeping admin surfaces behind TLS while you build better habits around secrets and recovery.
Volume backups (tar is fine, consistency is the point)
For simple volumes (uploads, static assets), a stop-the-world backup is often acceptable during a low-traffic window:
# Example pattern
# 1) stop app container
# 2) tar the volume mount path
# 3) start app container
If downtime isn’t acceptable, move stateful components (databases, queues, object storage) to managed services or dedicated nodes. Then keep the CapRover box mostly stateless.
Database backups: use real dumps, then test restores
If you’re running MySQL/MariaDB behind CapRover, don’t trust “volume snapshots” alone. Take logical dumps (or physical backups for larger datasets).
Then test restores on a schedule.
HostMyCode has a practical guide on automatic MySQL backups with tested restores that maps well to self-hosted app platforms.
Disk usage will sneak up on you
Frequent deploys create images. Images create layers. Layers fill disks.
Put Docker disk usage on your maintenance checklist, and watch log growth.
If the node starts screaming about free space, this HostMyCode tutorial walks through safe cleanup steps: Disk full on VPS: find large files and free space safely.
Updates: treat them like a change window, not a button click
CapRover updates are usually uneventful. When something goes wrong, the impact is immediate. You lose deploy capability right when you need it.
The fix isn’t heroics. It’s process.
A sane upgrade workflow looks like this:
- Before: export CapRover config, verify the offsite copy, and snapshot the VPS if your provider supports it.
- Change window: upgrade during low traffic. Don’t do it mid-deploy.
- After: confirm the dashboard loads, deploy a tiny test app, and renew/validate a certificate.
Keep the host current too: kernel security updates, Docker Engine updates, and firewall rules.
Self-hosting a PaaS doesn’t remove sysadmin work. It concentrates it into fewer, more important servers.
Operational guardrails that keep CapRover pleasant
CapRover stays enjoyable when you set boundaries early.
- Separate concerns: put databases on database hosting or a separate VPS if the data matters. Your app node should be disposable.
- Limit admin exposure: keep the dashboard on a dedicated subdomain and restrict access by IP or VPN where possible.
- Use consistent naming: pick a pattern like
appname.env.example.com. It pays off as the app list grows. - Watch logs and metrics: container restarts, memory pressure, disk usage, and TLS renewal errors are early smoke signals.
If you outgrow a single node (heavy build pipelines, large multi-tenant apps, strict uptime requirements), that’s your cue to resize.
It can also be a reason to move to a dedicated server for steadier CPU and disk performance.
How CapRover compares to other self-hosted PaaS options
CapRover isn’t your only option. The tradeoffs are mostly about how you prefer to operate day to day.
- Coolify: strong Git-based deploy workflows and multi-service apps, with a modern UI. If you’re evaluating it, HostMyCode’s Coolify on a VPS post shows what day-to-day usage feels like.
- Dokku: a minimalist Heroku-like experience that expects more comfort with CLI operations.
- CapRover: a solid middle ground if you want a stable UI, app templates, and Docker-first thinking.
If you want most actions handled from a dashboard, CapRover fits well. If you prefer Git-first workflows and a more explicit view of services, Coolify may feel more straightforward.
Summary: CapRover is “small platform” done the pragmatic way
If you want Heroku-style deployments but don’t want to hand your runtime and routing to a hosted provider, CapRover is a sensible answer. You get repeatable releases, clean HTTPS, and multi-app hosting on one server.
Treat it like production infrastructure. Size the VPS with image growth in mind. Keep DNS and TLS clean.
Back up config and data, and run updates like real changes. Do that, and CapRover stays boring in the best possible way.
For a reliable base to run it, start with a HostMyCode VPS, or choose managed VPS hosting if you want the OS layer handled while you focus on shipping apps.
If you’re setting up CapRover for client sites or internal apps, HostMyCode gives you a clean VPS foundation with predictable resources and fast NVMe storage. Choose a HostMyCode VPS if you want full control, or go with managed VPS hosting if you’d rather not spend your time on patching and baseline hardening.
FAQ
Do I need a wildcard DNS record for CapRover?
You can run without it, but wildcard DNS is what makes CapRover feel effortless. It lets you spin up new app subdomains without editing DNS for every deploy.
Can I run databases on the same CapRover server?
You can, but it increases your blast radius. For important data, put the database on a separate node or managed service, and back it up independently.
What’s the simplest HTTPS setup?
Let CapRover handle Let’s Encrypt for your app subdomains, keep ports 80/443 open, and make sure DNS points to the correct public IP.
How do I keep disk usage under control with frequent deploys?
Track Docker disk usage, prune unused images/layers during a maintenance window, and budget extra NVMe storage if you build images on-server.
Is CapRover a replacement for Kubernetes?
No. It’s a single-node, Docker-based platform for straightforward app hosting. If you need multi-node orchestration and advanced scheduling, Kubernetes is in a different category.