Okteto vs Qovery: Choosing the Right Kubernetes Development Platform for Your Team

If you're comparing Qovery and Okteto, you want developers, reviewers, and coding agents to see a change running before it's merged. Both products create an environment for each pull request on Kubernetes, and both now speak to coding agents. The differences are in what each one is for, and in what an environment contains. Qovery is a platform to deploy your applications on your cloud, production included, and each preview is a clone of a whole environment. Okteto covers the development cycle: each developer, pull request, and agent gets an environment in your cluster, from a full copy of the application to only the services that change. This guide explains what that means for your team.
Understanding the Shared Goal
Modern applications are code plus configuration, runtime, network policies, data, and dependencies across many services. Neither a developer nor a coding agent can gain real confidence that a change works by running unit tests on its own, and neither can a shared staging environment that everyone queues for. Each change needs to run against an environment that behaves like production.
Okteto and Qovery agree on that. Where they differ is in what each environment holds. A Qovery preview is a copy of the application, with the services and databases you choose to include. Okteto doesn't tie an environment to that model: an environment can deploy only the services you change, a full copy of the application, or a mix, such as the services you change plus your own copy of the database, with everything else shared.
How Qovery Works
Qovery is a self-service platform between your team and your cloud account. It deploys your applications to Kubernetes on AWS, GCP, Azure, Scaleway, or your own cluster, from development to production.
In Qovery, an environment is a group of applications, databases, and services in one Kubernetes namespace. A preview environment for a pull request is a clone of a blueprint environment. You can leave services out of a preview, and include each database as a clone or share it with another environment. Qovery's docs describe no way to route a preview's requests to a shared copy of the services it leaves out. When a database is cloned, its data isn't: teams fill each preview database with test data from a Lifecycle Job.
By default, Qovery builds the images on its side, in a cluster dedicated to builds, and it can also build in your cluster or deploy an image your CI built. For development, the Qovery CLI forwards ports and opens shells into the containers of an environment. Tests run from your CI, against the URL of the preview.
The Qovery control plane runs in Qovery's infrastructure, and its engine can run in your cluster. The Enterprise plan adds a self-hosted control plane, air-gapped if needed. Qovery's plans include a number of users, clusters, and deployment minutes per month, from a free plan for 3 users to an Enterprise plan with custom pricing.
For coding agents, Qovery offers an MCP server, skills, and an AI Copilot that operates the platform. Agent Tasks can clone an entire environment and run an agent in the clone.
How Okteto Works
Okteto runs in your cluster, and each developer, each pull request, and each coding agent gets its own application environment, in a dedicated namespace. An Okteto Manifest in the repository defines how to build, deploy, develop, and test the application, on top of the Helm charts, Kubernetes manifests, or Docker Compose files you already have, and the same definition creates every environment.
An environment can be a full copy of the application. With Divert, it deploys in your namespace only the services you change, or those plus any others you want your own copy of, on top of a shared environment that runs the rest. Okteto builds the images in the cluster, synchronizes your code changes in seconds to the Development Container that runs your service, creates a Preview Environment for each pull request, and runs the tests in the cluster too. Production stays on the pipeline you already run.
Okteto also includes the infrastructure to run coding agents on your cluster. Each agent works in a light agent sandbox, under the access and policies the platform team defines, and gets its own application environment, the same one a developer gets. Agents that run elsewhere, such as Claude Code on a laptop, use the Okteto agent skills to work in the same environments.
The whole platform, control plane included, runs in your cluster: Self-Hosted on any Kubernetes cluster, air-gapped, or Bring Your Own Cloud (BYOC). Okteto is priced per user, with a free tier for up to 5 users.
Quick Comparison
| Okteto | Qovery | |
|---|---|---|
| Scope | The development cycle: development, pull requests, tests, and agents | Deploying applications on your cloud, production included |
| Environment | A dedicated namespace: only the services that change with Divert, a full copy, or a mix of both | A clone of a blueprint environment, with the services and databases you include |
| Routing to the services that change | HTTP and gRPC, by the W3C baggage header. Gateway API routes on your service mesh (Linkerd, Istio, and other GAMMA meshes), or Istio VirtualServices | No routing to services a preview leaves out |
| Data | Kubernetes Volume Snapshots clone the real data of any volume, or your own dump and restore scripts | Cloned databases without their data, filled by Lifecycle Jobs |
| Builds | In the cluster, with the Okteto Build Service, or any image you choose, such as one your CI built | On Qovery's build cluster by default, in your cluster, or an image your CI built |
| Development | Code changes synchronized in seconds to a container in the cluster | Port forwarding and shells into the containers |
| Tests | In the cluster, with Okteto Test, or natively in your CI pipelines, against the environment | From your CI, against the preview URL |
| Coding agents | Agents run anywhere, with Okteto's agent skills, or on your cluster. Each one gets its own application environment | MCP server, skills, and AI Copilot. Agent Tasks clone an environment per agent |
| Where it runs | Entirely in your cluster, control plane included: Self-Hosted, air-gapped, or BYOC | Control plane hosted by Qovery, or self-hosted on Enterprise |
| Pricing | Per user. Free tier for up to 5 users; Divert in Scale and Enterprise | Plans by users, clusters, and deployment minutes. Free plan for 3 users |
What Divert Covers
Divert is how Okteto deploys only the services you change, instead of a copy of the whole application. Each environment deploys them in its own namespace, on top of a shared environment, and Divert routes its requests to them with standard Kubernetes resources:
- Requests: Divert routes HTTP and gRPC requests by the divert header, the W3C
baggageheader that OpenTelemetry already propagates. See Header Propagation. - Service meshes: the default driver uses the Gateway API, and works with any mesh that implements GAMMA, such as Linkerd and Istio. Clusters that define their routing with Istio VirtualServices can use the VirtualServices driver. Only the Shared Namespace needs the mesh: Overlay Namespaces don't.
- Message queues: with Queue Splitting, when each subsystem owns its queues, deploying the subsystem in your namespace gives you your own broker and consumers, without changes to your producers or consumers. When services share a broker, consumers filter messages by the divert header.
- Databases: with Data Cloning, your namespace gets its own copy of the databases it writes to, restored from a Volume Snapshot of the shared data or with your own dump and restore scripts, or a tenant of its own in the shared database.
- Shared environment: the Shared Namespace can be a Preview Environment that your CI redeploys on every merge, or any namespace in the same cluster that Okteto doesn't manage, such as your existing staging.
Why a Dedicated Namespace Matters
A namespace is the unit Kubernetes already uses for isolation, access, and policies. Because every Okteto environment is one, Okteto can rely on what Kubernetes and its ecosystem provide, instead of reimplementing it in a layer of its own.
Real Data, Not Seed Jobs
An environment needs data that looks like production's. Okteto uses the native Volume Snapshots of Kubernetes, through the CSI driver of your cluster, to restore a volume of the environment from a snapshot of the shared one. Any data store that keeps its data in a volume gets a full, realistic copy of the data, in the time it takes to restore a disk, and its writes never reach anyone else. Developers and agents don't have to limit their tests to the data a seed job loads. If your team already has dump and restore scripts, the Okteto Manifest runs them as part of the deploy.
Only the Services That Change
Large applications don't fit in a copy per pull request, let alone one per coding agent. With Divert, an environment deploys only the services it changes, and the Gateway API routes its requests to them: Okteto creates an HTTPRoute for each service you change, and any service mesh that implements GAMMA, such as Linkerd or Istio, routes the requests that carry your header to it. Every other request reaches the shared environment, so a preview that leaves a service out still works end to end.
A Development Loop in the Cluster
A developer or an agent can't verify a change until it's built and deployed. Okteto builds the images in the cluster, with the Okteto Build Service, as part of the environment, and while you work, okteto up synchronizes your code changes in seconds to the container that runs your service, so you see the result without waiting for a new deployment. Okteto Test runs the tests in containers of the cluster, next to the services they test, or your CI pipelines run them natively, against the environment. For the services you don't change, an environment can reuse any image you choose, such as the one your CI already built.
The Same Access and Policies as Production
Each environment inherits the RBAC, network policies, and resource limits that Kubernetes applies per namespace. The platform team governs environments with the tools it already uses for the rest of the cluster, and a change that breaks because of a policy breaks during development, not after the merge.
Nothing Leaves Your Cluster
Okteto's control plane runs in your cluster, next to the environments, on every plan. Your code, your data, your test results, and the requests to your environments stay in your infrastructure, and Okteto Enterprise runs air-gapped. With Qovery, the control plane runs in Qovery's infrastructure, unless you self-host it on the Enterprise plan.
Where Coding Agents Fit
Both products give coding agents an environment to test their changes. With Qovery, agents use its MCP server and skills to operate the platform, and Agent Tasks clone a whole environment for each agent.
With Okteto, the agents run wherever you run them, using the Okteto agent skills, or on your cluster, under the policies the platform team defines. Either way, each one builds, deploys, and tests its change in its own application environment before it opens a pull request. With Divert, that environment holds only the services the agent changes, so a team can run many agents in parallel on a large application. The data each agent writes is its own, and the routing to its services is standard.
Choosing the Right Solution for Your Team
Qovery may fit if:
- You want one platform to deploy your applications on your cloud, production included
- Your team has little Kubernetes expertise, and you want the platform to manage the clusters
- Your application is small enough to clone for every pull request
Okteto fits best if:
- You want each developer, pull request, and coding agent to get a dedicated namespace in your cluster
- You want to deploy only the services that change on large applications, and share the rest
- You want one definition of the environment for development, pull requests, tests, and agents
- You want real data, a development loop in the cluster, and the choice to run tests in the cluster or in your CI pipelines
- You want to run coding agents on your cluster, under your policies
- You already have a pipeline for production, such as Argo CD, and need a platform that integrates with it
- You need the whole platform in your infrastructure, including air-gapped
Frequently Asked Questions
Does Okteto clone the whole application for every pull request, like Qovery?
It can, but it doesn't have to. With Divert, an Overlay Namespace runs only the services you change, and every other service is served by a Shared Namespace that runs the complete application. A namespace can also run a full copy of the application, or a mix: its own copy of some services, such as a database, and the shared version of the rest.
Does an Okteto environment get a copy of the data?
Yes. Okteto restores the volumes of an environment from Kubernetes Volume Snapshots of the shared data, so any data store that keeps its data in a volume gets a full copy. Your own dump and restore scripts work too, as part of the deploy.
Does Okteto Divert support the Kubernetes Gateway API?
Yes. The Gateway API is the default Divert driver: Okteto creates an HTTPRoute for each overlay service, and any service mesh that implements GAMMA, such as Linkerd or Istio, routes the requests. Clusters that define their routing with Istio VirtualServices can use the VirtualServices driver instead.
Does Okteto deploy to production, like Qovery?
No. Okteto covers the development cycle: development, pull requests, tests, and coding agents. Production stays on the pipeline you already run, such as Argo CD or Flux.
How are Okteto and Qovery priced?
Okteto is priced per user. The free tier covers up to 5 users, and the Scale and Enterprise plans, which include Divert, have unlimited environments. Qovery's plans include a number of users, clusters, and deployment minutes per month, from a free plan for 3 users to an Enterprise plan with custom pricing.
