Dora NodaA typical three-service stack with Postgres and Redis costs about $6 a month on a self-run panel, $18 a month with a managed control plane, and $38 a month fully hosted — and the cheapest option quietly bills you in pager duty instead of dollars.
That is the short version of Deploynix's June 2026 self-hosted-PaaS showdown, which reframed the whole Coolify-versus-Dokploy-versus-CapRover debate as a single question: do you want to run the control plane yourself, or pay someone a flat fee to run it while your workloads stay on a server you own? The showdown's verdict — Coolify the safest all-purpose pick, Dokploy the lean Swarm-native choice, CapRover the stability pick, Deploynix the managed answer for Laravel teams — is less interesting than the accounting it invites. Below is that accounting, worked out for one concrete stack across all three models, with the failure modes priced in.
| Model | Example | Cash/month (3 svc + Postgres + Redis) | Ops time/month |
|---|---|---|---|
| Self-run panel | Coolify / Dokploy / CapRover + Hetzner CX23 | ~$6 (box only, panel free) | 1–3 hrs your time |
| Managed panel | Deploynix Starter $12 + same box | ~$18 | Near zero on the panel |
| Fully hosted | Render Starter per service + managed data | ~$38 | Zero, meters instead |
The rest of this post shows the receipts behind each row, how the math moves at one service versus five, and where the middle ground inherits both sides' failure modes instead of neither.
The real question isn't which panel
Deploynix's showdown, published June 21, 2026 by Sameh Elhawary, landed in the middle of a genuine boom. Cloud repatriation interest hit record highs in 2024–2026 — 86% of CIOs in Barclays' late-2024 survey planned to pull at least some workloads back in-house — and 37signals' widely cited $2 million-a-year saving after leaving AWS became the movement's rallying cry. Three open-source projects now lead the "Heroku experience on infrastructure you control" charge: Coolify with roughly 57,000 GitHub stars, Dokploy with roughly 35,000, and CapRover with roughly 15,000, all counted in June 2026.
The showdown's verdict table is worth quoting in full, because it doubles as the decision tree for this post:
| Tool | Model | Best for | Watch out for |
|---|---|---|---|
| Coolify | OSS self-hosted panel | Feature-rich, polyglot, production all-rounder | You maintain the panel and the server |
| Dokploy | OSS self-hosted panel | Lightweight, modern, Swarm-native clustering | Still pre-1.0 (v0.29.x); younger ecosystem |
| CapRover | OSS self-hosted panel | Simplicity and long-term stability | Dated UI, slower cadence, limited Compose |
| Deploynix | Managed SaaS, your VPS | Laravel/PHP teams wanting zero-maintenance hosting | Subscription cost; PHP/Laravel focus |
The key line: all three open-source panels are free to self-host under Apache-2.0 — you pay only for the server underneath. Deploynix inverts that: the control plane is a paid product with a free tier and a $12-a-month Starter plan, while the servers it manages live in your own Hetzner, DigitalOcean, Vultr, Linode, or AWS account and are billed to you directly. Same box, different answer to who babysits the machinery around it.
Self-run: a $0 license and your pager
The self-run math starts with the box. Hetzner's CX23 (2 vCPU, 4 GB RAM) is the natural home for a small stack — a Laravel or Node web process, a queue worker, a small sidecar, plus Postgres and Redis in containers — and it currently lists at €5.49 a month (about $6.40) after Hetzner's June 15, 2026 price adjustment, with 20 TB of outbound traffic included. The panel itself costs nothing: Coolify v4.x ships 280-plus one-click services, Docker Compose support, and native multi-server management; Dokploy offers a leaner TypeScript UI over Docker Swarm and Traefik; CapRover, stable since 2017, trades features for a simplicity record no competitor can match. Cash total: roughly $6 a month.
The second line item is hours, and this is where honest accounting matters. "Babysitting the panel" concretely means: applying panel updates (Coolify's v4 releases have moved fast through 2026), keeping the Traefik reverse proxy and its Let's Encrypt certificates healthy, verifying container-database backups actually restore, and debugging the Docker layer when a deploy wedges. For a quiet month that is perhaps an hour; a month with a major panel upgrade or a wedged deploy can eat an afternoon. Call it 1–3 hours a month for a stack this size.
What those hours are worth depends on who you are. A solo founder hacking at midnight prices them at zero and the self-run total stays $6. A team paying a loaded cost of $75 an hour should read the row as $6 in cash plus $75–$225 in expected ops time — which is exactly why the same $6 box looks free to one team and expensive to another. Keep that range in mind; the sensitivity table below makes it explicit.
Two caveats belong here. First, Dokploy is still pre-1.0 (v0.29.x as of May 2026), so its upgrade path carries more churn risk than Coolify's stable v4 line or CapRover's nine-year record. Second, both Dokploy clustering and CapRover's engine sit on Docker Swarm, which has been in maintenance mode for years — fine for a single box or a handful of nodes, but not a substrate to plan a ten-node future on.
Managed panel: a flat subscription and no babysitting
Deploynix's Starter plan at $12 a month plus the same €5.49 Hetzner box puts the managed middle ground at roughly $18 a month in cash for our reference stack. (There is a free tier for smaller setups, and higher tiers run to $39 a month; Coolify Cloud is the polyglot-flavored equivalent at $5 a month for two servers plus $3 per extra server, which would land the same stack near $11.) Either way, the subscription replaces the 1–3 hours of panel maintenance with someone else's on-call rotation: managed deploys, SSL, database backups, monitoring, and alerts, without SSHing into anything.
Deploynix is also opinionated in a way the generic panels are not. Where Coolify, Dokploy, and CapRover all deploy Docker containers, Deploynix provisions native, non-Docker servers — Nginx and PHP-FPM, Horizon under Supervisor, atomic symlink deploys with one-click rollback, MySQL with automated backups — in the Laravel Forge tradition. For a Laravel or PHP team that is a feature: no Dockerfiles to write, no container-image pipeline to maintain, no translating every Forge tutorial into Compose-ese. For a polyglot team shipping Go, Rust, or arbitrary images, it is a disqualifier, and the showdown says so plainly: those teams belong on Coolify or Dokploy (or Coolify Cloud if they want the managed-panel shape without the PHP focus).
The honest middle-ground caveat is scope. The vendor manages the control plane and the server configuration — but the VPS account is yours, the provider bill is yours, and if Hetzner has a bad day, the underlying outage is still an outage on your box. That split ownership is the whole story of the failure-modes section below.
Fully hosted: zero ops and per-service meters
Render's Starter tier lists at $7 a month per always-on service. Our reference stack — three services — is $21 before data. Managed Postgres on the Basic tier starts around $6 a month in compute with storage billed separately at about $0.30 per GB-month (call it $3 for 10 GB), and managed Redis-equivalent key-value storage starts near $10. Total: roughly $38–$40 a month, and every additional service is another $7 line item whether it is busy or idle.
Step up to Standard at $25 per service and the same stack crosses $90 before data.
Railway prices by usage rather than by service: a $5 Hobby entry point, a $20 Pro workspace minimum, then about $20 per vCPU-month and $10 per GB-month of RAM metered per second. A small stack idling near half a vCPU and a gigabyte lands in the mid-$20s; a busier one climbs past Render's Starter math. The exact number moves with utilization, which is the point — hosted meters track load, while a flat-rate box does not care.
Now the sensitivity table the whole post has been building toward. Same stack shape, varying service count, with Hetzner post-hike pricing and ops time valued two ways:
| Services (+ Postgres + Redis) | Self-run cash | Self-run loaded (1.5 hrs × $75) | Managed (Deploynix $12 + box) | Render Starter + data |
|---|---|---|---|---|
| 1 service | ~$6 | ~$119 | ~$18 | ~$24 |
| 3 services | ~$6 | ~$119 | ~$18 | ~$38 |
| 5 services | ~$6–$12 (may need a bigger box) | ~$119–$125 | ~$18–$24 | ~$52 |
Three things stand out:
- Flat versus metered. The self-run and managed rows barely move with service count — the box absorbs more containers until it does not — while the hosted row climbs $7 a service. The gap between middle ground and hosted roughly doubles from one service to five.
- The self-run paradox. At agency billing rates, one unremarkable maintenance afternoon erases a year of cash savings over the managed tier. The "loaded" column is the real price for teams that pay for ops time.
- The Hetzner hike is tier-specific. CX23 moved from €3.99 to €5.49 (a 1.38x bump) — painful but small in absolute dollars. The eye-watering 2.69x jump (CCX13 from €15.99 to €42.99) hits dedicated-CPU buyers, not a starter box. Price your own tier, not the headline.
Failure modes: the middle ground inherits both sides
Cost is only half the ledger. Each model fails differently, and the managed panel's failure signature is genuinely two-sided:
| Failure | Self-run panel | Managed panel | Fully hosted |
|---|---|---|---|
| Panel/control-plane outage | Your pager: panel update breaks, you roll it back | Vendor's pager, your blindness: deploys and dashboards freeze while running apps keep serving | Provider's pager, your status page |
| Box/host outage | Your restore: backups you configured, provider ticket you file | Still yours: the VPS is your account, though the vendor helps reprovision | Not your problem: no box exists to fix |
| Deploy pipeline wedges | You read Traefik and container logs | Vendor debugs its pipeline; you wait with a support channel | Provider debugs; you wait with a status page |
| Data loss | Your backup drill — tested, right? | Managed backups with alerts, on your disk | Managed backups, provider's disk |
Read the middle column carefully: a Deploynix (or Coolify Cloud) outage blinds you exactly when you most want visibility — no deploys, no dashboard, no fresh graphs — while a Hetzner outage leaves you holding a provider ticket for a box only you own. That is not an argument against the middle ground; both halves are individually better than the self-run equivalents (someone else's panel pager, assisted reprovisioning). It is an argument against imagining the subscription buys you the hosted column. It buys you half of it.
Teams that internalize that split — monitor the vendor's status page like a dependency, keep provider-console access warm — get the good deal. Teams that assume "managed" means "someone else's outage" get surprised exactly once.
The self-run column deserves one symmetrical credit: when everything is yours, nothing can blind you except your own box dying. There is no third-party dashboard between you and the logs. For teams that value that directness — and actually test their restores — it remains a real, non-financial reason to keep the pager.
Who should pick which
The showdown's verdict survives contact with the spreadsheet, with one refinement — price your hours before you price the box:
- Laravel/PHP team that never wants to SSH anywhere: Deploynix Starter at $12 plus a small Hetzner box. The native-server opinions match your stack, and the subscription is cheaper than one maintenance afternoon a year at billing rates.
- Polyglot team or tinkerer who likes owning the stack: self-hosted Coolify on the same box. Six dollars of cash, the widest service catalog, and a pager you have already accepted.
- Lean Docker-native setup, Swarm clustering: Dokploy, with eyes open about pre-1.0 churn and Swarm's maintenance-mode ceiling.
- Stability over features, single box, click-through UI: CapRover, nine years boring in the best sense.
- Zero ops appetite, variable load: Render or Railway. You will pay two to six times the middle ground in cash at this stack size, and that is the correct trade when nobody on the team wants the pager at any price.
Zoom out one level and the pattern is familiar: infrastructure decisions keep resolving to who holds the pager, not which logo sits on the dashboard. The managed-control-plane tier just finally gave that question a concrete price tag — about $12 a month over the box — instead of an argument about panels.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.
