What Bunnyshell and Okteto Actually Charge for 'Namespace Per PR' — And What It Costs to Build Once

Bunnyshell's own pricing page runs a sample calculation right on the homepage: three active preview environments, 480 minutes each, comes to $10.08. It's a cute number precisely because it's small — nobody bounces off a $10 line item. Scale that same meter to what a real engineering team burns through in a month of pull requests, though, and the number stops being cute. For a 25-engineer team shipping a steady 200 PRs a month, that identical $0.007-per-minute meter adds up to roughly $1,344 — a platform fee sitting on top of cloud compute the team is already paying for separately, for the exact same pods it would need either way.

That's the number this post exists to show: a full, line-by-line monthly bill for running "every PR gets a live namespace, torn down on merge" through Bunnyshell and Okteto, set against what the identical workflow costs built once on a self-hosted Cluster API fleet's own reconciliation loop.

What Bunnyshell and Okteto actually charge​

The ephemeral-environment SaaS market gets described as a monolith — "these vendors charge a platform fee on top of your cloud bill" — but the two most-cited names in that category don't actually price the same way, and it's worth being precise about which does what before running any numbers.

Bunnyshell is not seat-gated. Its Startup plan is a flat $0.007 per minute per active environment, and the pricing page says so explicitly: "no per-seat pricing, no cluster limits." An environment that's asleep costs $0. It's a Bring-Your-Own-Cloud (BYOC) product — Bunnyshell orchestrates the namespace lifecycle, but the underlying Kubernetes cluster and its compute bill belong to the customer's own cloud account. Scaleup, the next tier up, requires a minimum of 20 users and moves to custom quoted pricing, which is where seat count starts to matter — but at the entry tier that most PR-preview workloads actually run on, there's no per-seat tax to compute.

Okteto is the vendor that's genuinely seat-gated. The Starter plan is free for up to five seats. Beyond that, the next published tier — Developer Pro — has historically listed at $19 per user per month; Okteto's current live pricing page, though, has moved Scale and Enterprise behind a "contact us" wall with no public per-environment or per-seat number to check against. That opacity is itself a data point: unlike Bunnyshell, which puts its meter rate on the homepage, a team evaluating Okteto beyond five developers can't actually model the bill without a sales call.

Both models share the structural trait the original framing was reaching for, even if the mechanism differs: each is a second layer of margin stacked on top of infrastructure the team is already paying for once. Bunnyshell's layer is metered by the minute; Okteto's is metered by the developer.

The worked example: a 25-engineer team, 200 PRs a month​

Here's the scenario, with every assumption stated so the arithmetic is checkable rather than asserted.

• Team size: 25 engineers.
• PR volume: 200 pull requests a month (about 9 per business day across 22 business days — a normal cadence for a team that size, not an outlier).
• Environment lifecycle: each PR's preview environment lives for an average of 2 business days from open to merge or close.
• Active-vs-asleep: both platforms support auto-sleep outside working hours, so each environment is realistically "active" for 8 hours a day across its 2-day life — 16 active hours, or 960 minutes, per environment.

Bunnyshell's bill: 200 environments × 960 active minutes × $0.007/minute = $1,344/month. That's the platform fee alone — separate from, and on top of, whatever the team's cloud account charges for the pods those environments actually ran on.

Okteto's bill: a 25-person engineering org needing preview access for more than the free five seats has to license Developer Pro (or negotiate Scale) for the rest. At the historical $19/seat/month Pro rate, licensing 20 additional seats runs ≈$380/month — though because current Okteto pricing beyond the free tier is quote-only, this is a documented historical reference point, not a number the team could actually verify today without a sales call.

The compute underneath, either way: at any given moment with 200 PRs/month and a 2-day lifecycle, roughly 12 preview environments are concurrently live. A typical PR preview — a couple of small services plus dependencies — fits comfortably in about 0.5 vCPU and 1GB RAM. Bin-packed, that's roughly 6 vCPU and 12GB across the fleet: four Hetzner CX22 nodes (2 vCPU / 4GB / 40GB NVMe each, ≈€4.35/month per node in 2026) cover it with room to spare, for ≈€17.40/month (≈$19/month) in raw compute.

That compute bill is identical whether the namespace gets provisioned by Bunnyshell's controller, Okteto's, or a Cluster-API reconciliation loop a team wrote itself — the pods need the same CPU and RAM no matter who's watching the webhook. Which makes the comparison collapse to something simple:

For this team, Bunnyshell's meter is roughly 70x the underlying compute cost it's metering; Okteto's seat tax is roughly 20x. Neither number is a rounding error at 25-engineer scale, and both compound linearly with PR volume in Bunnyshell's case, and with headcount in Okteto's.

Where the SaaS meter actually wins​

None of this makes Bunnyshell or Okteto a bad deal in every case — the honest version of this argument has to show where the math flips, not just where it doesn't.

A small team running light preview volume — say, 5 PRs a month, mostly asleep outside a quick review window — burns maybe 5 environments × 240 active minutes × $0.007 = $8.40/month on Bunnyshell. At that volume, standing up a Cluster API reconciliation loop, a webhook listener, TTL-based namespace teardown, and per-PR DNS/TLS issuance is real engineering time that a $10/month bill comfortably outcompetes for months or years. Okteto's free five-seat tier covers plenty of small teams outright — $0 beats any DIY build cost for a team that never needs a sixth seat.

The crossover isn't at a single number, but the shape is clear from the arithmetic above: Bunnyshell's fee scales with environment-minutes (PR volume × lifecycle length), and Okteto's scales with headcount. A team somewhere in the low tens of PRs per month, or comfortably under six developers needing preview access, is squarely in "the SaaS meter is cheaper than an engineer's afternoon" territory. A team running the 200-PR/25-engineer volume above has already crossed into "the meter costs more than a mid-size EC2 instance's worth of node capacity, every single month, indefinitely" territory — and that gap only widens as the team and its PR volume grow, while the DIY route's marginal cost stays pinned to whatever the next Hetzner node costs.

What it actually takes to build namespace-per-PR yourself​

"Build it once" has two costs worth separating: the infra-dollar cost, which the table above already pins at essentially the compute bill alone, and the one-time engineering cost of the automation itself — real, and worth naming rather than waving off.

The wiring is a standard GitOps pattern, not a novel one:

1. Branch webhook — a GitHub/GitLab webhook on pull_request open/sync/close events triggers the platform's build step.
2. Namespace-per-PR — a Cluster-API-managed namespace gets created (or reused) keyed to the PR number, with the app's manifests applied into it.
3. DNS and TLS per PR — a wildcard or per-namespace subdomain (pr-1234.preview.example.com) gets an ingress rule and a cert-manager-issued certificate, torn down alongside the namespace.
4. TTL-based teardown — a controller watches for pull_request: closed (or a staleness TTL, for PRs abandoned without a formal close) and deletes the namespace, its DNS record, and its cert — the step that's easy to build and easier to forget, and the one that turns "unlimited preview environments" into an orphaned-resource bill if it doesn't fire reliably.

None of that is exotic if the underlying platform already runs everything else as reconciled Kubernetes objects — which is precisely the case bex.co makes for owning the whole path a git push takes, rather than renting a control plane that sits in front of infrastructure a team is already paying for. Bex.co is the open-source, AI-native Render alternative: push a git repo, get a running HTTPS service on machines you own, with no per-minute environment meter and no per-seat preview tax layered on top of the Hetzner bill that's already there. Building the four steps above once, on top of a Cluster-API fleet a platform already reconciles, is a bounded engineering cost — not a recurring one that scales with every PR a team opens for the life of the product.

The takeaway​

Preview-environment SaaS isn't charging teams for infrastructure they'd otherwise have to buy — the infrastructure costs roughly $19/month either way in the scenario above. It's charging for the reconciliation loop that turns a webhook into a namespace, a subdomain, and a teardown. That loop is genuinely worth paying $10-30/month for on a small team that will never build it themselves. But for a team already running the PR volume and headcount to notice a four-figure monthly line item, the honest move isn't switching meters — Bunnyshell's per-minute or Okteto's per-seat — it's building the loop once on infrastructure the team already owns, and never metering it again.

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.

Sources​

• Bunnyshell Pricing
• Bunnyshell vs Northflank
• Okteto Pricing
• Okteto Preview Environments
• Hetzner Cloud CX22 Pricing 2026
• Hetzner Cloud Review 2026.