Kool.dev's $49 BYOC vs. Owning the Whole Stack: A Cost-and-Control Teardown

About fifteen dollars a month is what a small team pays to run three services, a Postgres, a Redis, and 60 GB of data on a commodity VPS with a zero-fee open-source stack. Kool.dev will run the same workload for about $67 on its Managed Cloud — or $49 plus your VPS bill on its BYOC plan, where your apps live on your servers but its control plane does the driving. The interesting question is not which total is smaller. It is what the middle column buys you, what it quietly reintroduces, and whether "zero YAML" is worth it for a team that set out to self-host specifically to avoid depending on a vendor.

This post prices all three columns to a monthly total, then walks the trust boundary BYOC actually draws: your infrastructure, their orchestration layer, and a $5 managed database sitting exactly where your data lives.

Your servers, their control plane​

The workload everything below is priced against is deliberately boring: three small web services in production, one Postgres, one Redis, 60 GB of persistent data, plus a staging environment and per-PR preview apps. That is a typical seed-stage backend or a serious side project that outgrew a single VPS with Docker Compose.

Kool.dev's pitch is that you should not have to learn Kubernetes to run that on Kubernetes. You point it at a VPS — DigitalOcean, Hetzner, AWS, Vultr, or anything with SSH — and it installs k0s, Mirantis's single-binary, zero-dependency Kubernetes distribution, with automated security hardening. From there you get git-push deploys with auto-builds, preview environments per pull request, zero-downtime rollouts, one-click Prometheus and Grafana, automatic HTTPS, and a kool cloud deploy flow that lifts an existing Docker Compose setup into the cluster. k0s itself is a sound choice for this: it tracks upstream Kubernetes closely, needs about 1 GB of RAM to run, and earned CNCF Certified Kubernetes AI Conformance in July 2026 alongside Mirantis's fleet manager k0rdent.

The product comes in two shapes. Managed Cloud hosts everything: containers from $5/mo (0.125 CPU / 256 MB) to $80/mo (2 CPU / 4 GB), managed databases at $5/mo each, persistent storage at $0.45/GB/mo, with builds and data transfer free "today" and future fees to be determined. BYOC puts the cluster on your infrastructure: Free for 1 node / 1 environment / 1 app (credit card required after a 7-day trial), Pro at $49/mo for up to 5 nodes with unlimited environments and apps, Enterprise from $199/mo for unlimited everything. All prices are USD before tax and, by Kool's own note, subject to change while in beta. Full detail is on the pricing reference.

What Kool.dev gets right​

Credit where it is due: the BYOC middle ground solves a real problem. A team that wants data sovereignty — data on its own servers, in its own region, on its own cloud credits — but has no interest in operating Kubernetes gets a genuine PaaS surface: push, preview, promote. The Free tier is honest about being a trial (one app, one environment), and Pro's flat $49 for up to five nodes with unlimited apps and environments is simple to reason about. No per-seat meter, no per-deploy meter.

The Docker Compose import deserves a specific nod. Most teams arriving at a PaaS decision already have a docker-compose.yml that defines their world; meeting them there instead of demanding Kubernetes manifests on day one is the correct onboarding order. Per-PR preview environments generated from the CLI close the loop that makes small teams fast. And building on standard k0s rather than a proprietary runtime means the "no vendor lock-in" claim has a technical leg to stand on: your workloads are ordinary Kubernetes workloads, and Kool promises config export if you leave.

None of that is in dispute. What follows is the part the pricing page does not total up for you.

The three-column teardown​

Here is the typical workload — 3 services, Postgres, Redis, 60 GB of data — summed to a monthly total in each column. Managed Cloud sizes each service at Small ($10/mo, 0.25 CPU / 512 MB), which matches a modest API or web app. BYOC Pro assumes one commodity VPS node in the $12–24/mo range (a 4 vCPU / 8 GB Hetzner-class box; check current list prices, which move). The fully-owned column is the same VPS running a zero-platform-fee open-source stack.

Two observations before the sensitivity analysis. First, at this workload size the two Kool columns cost almost the same — the $49 platform fee and the per-container metering converge around $65. Second, storage is already 40% of the Managed Cloud bill. That ratio only gets worse, which is where the sensitivity rows come in.

Storage is the driving variable on Managed Cloud. At 500 GB — a Postgres that has been alive for a year or two, plus uploads — the storage line alone is $225/mo, and the Managed total passes $265/mo. On BYOC or a fully-owned stack, that data sits on NVMe already included in the VPS price. Any workload whose data grows faster than its compute should price the storage curve first; it crosses the entire platform fee within the first hundred gigabytes.

Node count has a cliff on BYOC. Pro covers up to five nodes. The sixth node means Enterprise, starting at $199/mo — a 4× jump in the platform fee for one more machine. If your fleet plan tops out at three to five nodes, Pro is fairly priced per node ($10–16 each). If growth takes you to six, re-price the whole column before you get there.

Preview and staging environments meter differently. On Managed Cloud every preview container bills while it runs; a busy week of pull requests shows up on the invoice. On BYOC and fully-owned stacks, previews are free at the margin — they consume spare capacity on nodes you already pay for. Unlimited environments is Pro's best line item, and it is worth the most to exactly the teams that deploy the most.

One honest ambiguity: Kool lists managed databases as a BYOC feature, but the $5/DB line item is published under Managed Cloud container pricing. If the add-on extends to BYOC, add $10 to that column; otherwise you operate Postgres and Redis on the cluster yourself — free in dollars, paid in ops attention. Either way, the database question deserves its own section, because it is where BYOC quietly hands back what self-hosting was supposed to take away.

The $5 database and the$0.45 gigabyte​

Five dollars for a managed Postgres sounds like the deal of the decade until you read the two lines next to it. The $5 covers the database service; the data it holds bills at $0.45/GB/mo. A 100 GB database — unremarkable for a production app with history — costs $5 for the service and $45 for the disk. The headline price is the rounding error; the storage meter is the product.

That is not a scam, it is just cloud economics relocated: the same metered-storage model that makes managed databases expensive on every hyperscaler, now attached to a platform whose pitch is escaping exactly that. Compare with the VPS the BYOC cluster runs on, where 80–160 GB of NVMe is simply included in the $12–24/mo node. The moment your data outgrows a toy, the managed add-on costs more than the machine it would have run on for free.

The deeper issue is operational, not financial. A managed database means the vendor provisions it, versions it, backs it up, and restores it. Those are precisely the decisions a team self-hosts to keep: which Postgres major version, when upgrades happen, where backups land, who can read them. Kool's BYOC story is "your data stays on your infrastructure," which is true of the bytes and incomplete as a description of control. Somebody else's automation still decides when your database restarts for a patch, and somebody else's backup pipeline holds the copy you will need most on your worst day.

This is the non-goal problem. Bex's published vision explicitly treats managed databases as a non-goal: the platform will not operate your data services, because operating your data is the dependency self-hosting exists to remove. You can disagree with that line — plenty of teams rationally buy managed Postgres — but you should notice when you cross it. Kool.dev's $5 add-on crosses it by default, inside a product you chose because you did not want to cross it. If you take BYOC, take it with self-run databases on your own cluster, and price the ops burden honestly instead of renting your way out of the decision that brought you there.

Who holds the control plane when it matters​

The open-source picture at Kool.dev is genuinely good and genuinely partial. The kool CLI is MIT-licensed, as are the Docker images, Helm charts, and companion tooling on the open-source page. What is not open source is the orchestration layer itself: the hosted service that SSHes into your VPS, installs and hardens k0s, runs your builds, serves the dashboard, and operates the managed databases. You register for it; you cannot fork it, audit it, or run it yourself.

That split defines the trust boundary. Your workloads are portable — standard Kubernetes, exportable configs, real exit. But the thing that turns "a VPS with SSH" into "a PaaS" is a SaaS control plane with standing SSH access to your infrastructure. Consider the three scenarios that matter:

Outage. If Kool's control plane goes down, your running apps presumably keep running on your nodes — k0s does not phone home to serve traffic. But deploys, previews, scaling actions, and database operations queue behind a dashboard that is not yours. Your uptime and your ability to change anything decouple on somebody else's incident.

Cancellation. Export your configs and leave — the promise is credible precisely because the substrate is vanilla Kubernetes. The cost is not re-platforming your apps; it is replacing the workflows (preview environments, build pipelines, DB operations) that lived in the control plane. Budget a week, not a quarter, but budget it before you need it.

Acquisition or shutdown. This is the scenario BYOC is supposed to defuse, and it half does: your data and workloads are on your metal, so there is no hostage data to ransom. What evaporates is the operator — the automation that installed, hardened, and maintained the cluster. A team that chose BYOC because it has no Kubernetes expertise inherits a Kubernetes fleet at the worst possible moment. The "no lock-in" claim covers your apps; it cannot cover the expertise gap the product was filling.

None of this is an argument that BYOC is fake self-hosting. It is an argument for pricing it as what it is: infrastructure you own plus an operator you rent. The $49 is not a software license; it is a retainer for an operator that never sleeps and that you cannot interview. For many teams that is a fine trade. It stops being fine the day the team forgets which half it owns.

Verdict: who should pick which​

The last two rows restate this post's opening question as a decision rule: if the reason you self-host is to avoid trusting a vendor's control plane with your data and deploys, a product whose control plane is a vendor service does not satisfy the requirement, however good its onboarding is. Kool.dev is an excellent answer to "Kubernetes without the YAML nightmares" and a partial answer to "infrastructure nobody else operates." Know which question you asked before you enter the credit card.

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.