Dora NodaYou do not pay Qovery to run your app. You pay Qovery to be allowed to run your app on infrastructure you already pay for. That distinction — control plane vs. compute — is the entire business model, and it is easy to miss until you add up both invoices.
In July 2026, Qovery completed a repositioning it had been telegraphing for months: from Internal Developer Platform to "Agentic Infrastructure Platform." The pitch landed cleanly — one governed API where humans and AI agents deploy, scale, and observe workloads on your own cloud, with MCP, CLI, Terraform provider, and an AI Skill as entry points. Pricing did not move with the rebrand: flat per-organization tiers that include users, managed clusters, and deployment minutes, running on top of whatever AWS, GCP, Azure, Scaleway, or Hetzner bill you already hold. The entry point starts at $299/month; the Business tier that most scaling teams land on is $2,099/month.
So what does that flat fee actually buy, what does it explicitly not buy, and when does "own the fleet" cost less than renting the control plane that manages it?
The two-invoice math, up front
Every Qovery customer gets two bills. Qovery's control-plane subscription is the first. Your cloud provider's bill for the EC2 instances, EKS control planes, volumes, and bandwidth underneath is the second. A self-hosted fleet collapses them into one: the hardware you own.
To make the comparison honest, hold the workload constant and sweep the variable that actually drives Qovery's price — team size. Take a typical small production setup: a 3-node cluster equivalent (enough for a web app, a Postgres, and a worker) plus staging and a handful of preview environments. Cloud compute underneath costs roughly the same either way; the question is what sits on top.
| Team size | Qovery fee (control plane only) | Cloud compute underneath* | Total with Qovery | Self-hosted fleet (Bex on owned Hetzner)† | Control plane as % of total |
|---|---|---|---|---|---|
| 2 users (Starter) | $299/mo | ~$105/mo (3× CX22-class + volumes) | ~$404/mo | ~$105/mo | 74% |
| 10 users (Team/Business floor) | ~$799–$899/mo | ~$105/mo | ~$904–$1,004/mo | ~$105/mo | 88–90% |
| 30 users (Business) | $2,099/mo | ~$105/mo | ~$2,204/mo | ~$105/mo | 95% |
* Cloud compute is illustrative for a 3-node CX22-class fleet (~€4.35–€5/node post-April-2026 Hike pricing plus volumes/backups) — the same nodes either way. If you run on AWS, the compute number is higher, which only widens the gap in absolute dollars.
† Self-hosted fleet = Hetzner hardware + Bex control plane you run yourself (Cluster API + CAPH + Bex operator). No second invoice; the control plane is the open-source product, not a metered add-on.
At two users, the rented control plane already costs 3× the servers it manages. At 30 users, it costs 20×. The servers did not get more expensive — the control plane did, because it prices by seat and environment, not by CPU.
That is the number the homepage never puts in the same table as the compute you already budget for. Once you do, the question stops being "is Qovery expensive?" and becomes "what does $299–$2,099 actually buy that the owned fleet doesn't already include?"
What the $299–$2,099 actually buys, line by line
Qovery's 2026 pricing is three tiers plus Enterprise, all BYOC (Bring Your Own Cloud). You connect your AWS, GCP, Azure, Scaleway, or on-prem account; your apps run there, not on Qovery's metal. The site currently bills as "usage based — see it in the platform or talk with us," but the tier structure is consistent across the pricing page, AWS Marketplace listing, and aggregator snapshots:
Starter — $299/month
- 2 users, 1 managed cluster, ~100 environments, ~1,000 deployment minutes
- Connect your own cloud, business-hours support via shared Slack
- The SKU that justifies the "$299" floor in the title — and the one most comparison tables skip
Team — ~$799–$899/month (annual vs. monthly)
- 10 users, up to 100 environments, 5,000 deployment minutes, RBAC + audit logs
- Up to 2 managed clusters (Qovery provisions VPC + EKS in ~30 minutes from zero)
- Business-hours support + onboarding with a solution engineer
Business — $2,099/month
- 30 users (some snapshots list 20; Qovery prices by organization contract, so expect negotiation), up to 250 environments, 10,000 deployment minutes
- 3 managed clusters, policy-as-code, SLA 99.9%, 30-day audit log retention
- The tier where Qovery's own case studies cluster — "scaling product teams" is the label on the card for a reason
Enterprise — custom
- Custom users, clusters, minutes, and environments
- Self-hosted control plane via Helm chart, fully air-gapped if needed — on-prem, GovCloud, anywhere auditors insist
- Custom support up to 24/7 with a dedicated CSM; annual/multi-year contracts
What every tier explicitly does not include: compute, storage, bandwidth, or managed databases. Those are your cloud bill. "What counts as an environment?" is namespace-scoped — production, staging, each PR preview, each AI agent workspace while it exists. "What counts as deployment minutes?" is build + deploy time across every service, non-rollover. Most Business teams burn ~6,000 minutes/month. Ephemeral preview environments count while alive, which matters when agents are spinning up verification workspaces at velocity.
The platform underneath is the same across tiers: Qovery Engine (open-source, Rust), Terraform + Helm on top of vanilla Kubernetes, a single control plane designed to manage thousands of clusters with metadata flowing back from the engine, no CRD extension of the K8s API. The higher tiers do not buy better provisioning — they buy more humans, more borders, and more governance.
What "agentic infrastructure" actually means in practice
Qovery's rebrand was not a rename. On July 15, 2026, the changelog entry read: "Qovery officially becomes an Agentic Infrastructure Platform — same platform teams already run production on, extended so agents can operate it just as well as humans do." The LinkedIn copy the same week was more candid: "Our customers pulled us here because the moment they put AI agents (Claude, Cursor...) to work, infrastructure was the first thing to break."
The break is structural. A modern stack is 5–8 systems with different interfaces — CI/CD, Kubernetes, Terraform, secrets, monitoring, CDN. Humans navigate them with dashboards, muscle memory, and a senior engineer who knows where the YAML lives. Agents cannot. GitOps, Terraform plans, and human-centric PR flows buckle under agentic velocity.
Agentic infrastructure, in Qovery's definition, is the fix: one governed API that unifies provisioning, deployment, scaling, secrets, and observation so agents can operate the stack, not just write code into it.
Concretely, this means:
- Unlimited agents, zero seats. AI agents — Claude Code, Cursor, Codex, or anything speaking MCP — authenticate with API tokens and do not consume user seats. There is no cap on how many you run. What they consume is deployment minutes and environments, billed like any other workload.
- Same RBAC and audit trail as humans. Agents inherit scoped permissions; every action is logged exactly like a human deploy. The control plane is a deterministic execution layer: same intent, same procedural code, every time — via Terraform provider, MCP server, CLI, or the AI Skill (
curl -fsSL https://skill.qovery.com/install.sh | bash). - Governance at the boundary, not after the fact. Qovery frames its value as "you set the rules, Qovery enforces them and logs every call" — environment isolation, budget controls, policy-as-code in Business and up. The Jira/Linear agent trigger (tag a ticket, get a governed environment where an agent performs the scoped action) is the clearest expression: the ticket is the entry point, the control plane is the guardrail.
- Not a sandbox. Qovery is explicit about this. A sandbox solves code execution — a safe place to run code. Agentic infrastructure solves orchestration: databases, networking, secrets, CI/CD, environments, and monitoring accessible through one governed API. Agents need the full stack, not just an isolated runtime.
None of this changes the two-invoice math. It explains why teams pay it: handing raw cloud credentials to agents is how you get a surprise bill or a security incident. The control plane is the brake pedal.
What "owning the fleet" actually costs instead
Bex is the opposite wager. It is an open-source, AI-native Render alternative — git push to a running HTTPS service on machines you own. No second invoice because there is no rented control plane. The control plane is the product, and you run it.
Architecture in one paragraph: bex is the control plane that reconciles App CRs into Deployments; bex-infra is how clusters exist (Cluster API with CAPD locally — kind management cluster whose machines are Docker containers — and CAPH on Hetzner in production, same CAPI shape: HetznerCluster + HCloudMachineTemplate + KubeadmControlPlane + MachineDeployment, with Cluster Autoscaler and Terraform around it). infra/ makes the cluster (day-0 from outside); deploy/ is what Argo reconciles into it (day-1+). Postgres is the source of truth; the operator is node-aware but provision-unaware; a NamespaceReconciler per workspace isolates tenants. The local substrate proves "compatible to Hetzner" without ever needing Hetzner until you do.
Cost-wise, that stack collapses to the hardware. The same 3-node CX22-class fleet that costs ~$105/month under Qovery costs ~$105/month under Bex. Deployment minutes are not metered; environments are namespaces you create. Agents are first-class operators via a Render-compatible API and an MCP server any agent can call today — no seat, no environment surcharge, no "deployment minutes" meter to watch between tool calls.
The honest cost the "free control plane" narrative omits is operational: you manage the Cluster API lifecycle, machine provisioning, autoscaling, and Postgres HA yourself. Qovery's Business SLA, policy-as-code, and Slack onboarding exist precisely because that work is not zero. Bex does not make it zero either; it makes it declarative and auditable in Git, with the same fleet-wide primitives Qovery uses (single control plane, many clusters) but on a surface you own. At ~$2,099/month of avoided control-plane fees, that operational cost has a concrete ceiling to beat — roughly half a platform engineer's week, every month, before owning the fleet stops being cheaper.
When renting the control plane still wins
A cost teardown should not pretend there is only one right answer. Renting wins clearly in at least three shapes:
You want zero fleet ops, right now. If the team has no appetite for managing Cluster API, EKS upgrades, or Postgres HA — and would otherwise be hiring a platform engineer to do it on a salary plus overhead — Qovery's $299–$799 floor can be cheaper than the human it replaces for a 2–6 person team. The honest comparison is not "Qovery vs. free" but "Qovery vs. the engineer you would have hired anyway."
You need multi-cloud or cloud-portable today, not eventually. Qovery's BYOC covers AWS, GCP, Azure, Scaleway, CoreWeave, bare metal, and on-prem in the same API. Bex is Cluster-API-shaped, which is portable by design, but CAPH (Hetzner) is the mature provider path today; other providers are integrations you own. If "one API, any cloud, this quarter" is the requirement, a rented control plane that already ships it has compounding value.
You value the onboarding and support surface. Shared Slack channel from day one, solution-engineer onboarding, business-hours support on every plan, and a dedicated CSM plus up to 24/7 on Enterprise are not free to replicate. For a team whose alternative is self-serve docs and community Discord, the support line item alone can justify the fee for a few months while you stand up the owned fleet in parallel.
The question that separates these cases from sunk-cost-by-default is one sentence: are you paying for the control plane, or for not hiring the person who would run it? If the answer is the person, rent until the math crosses. If the answer is the control plane, own it — because infrastructure a team already pays for should not be taxed twice for the privilege of deploying to it.
The one-line decision test
Qovery is a good product with a pricing model that is unusually easy to audit. That is a compliment: you can read the invoice before you commit, and the company does not hide the BYOC split. "Your account, your bill. Qovery sits above the infrastructure and never owns it" is honest copy on a page where honesty is rare.
The test that resolves it is equally simple: does your cloud bill already exist without the PaaS fee?
If yes — you run on AWS/GCP/Hetzner and chose Qovery for the interface — then the $299–$2,099 is a tax on an interface. Interfaces should be owned when they are the team's daily primitive. Agents make this more acute, not less: when agents initiate more infrastructure operations than humans, the cost of the governed API they call is the cost of the platform itself. A seat-free, minute-metered model is friendlier than per-agent billing, but minutes and environments still meter a surface that an owned fleet does not.
If no — you had no fleet and wanted one in 30 minutes with vendor-managed EKS, governed deploys, and a support channel — then Qovery's $299 buys a weekend you would have lost. Take it, ship, and revisit when the fleet is no longer hypothetical and the control-plane line item exceeds the hardware it manages several times over. At that point, the fleet you already paid for deserves a control plane it already owns.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Agents deploy through a Render-compatible API and an MCP server, not a second invoice. Star the repo on GitHub or deploy your first app today.