Sovereign · managed or self-hosted
Identity and secrets, feature flags, an API gateway, incidents and on-call, and governed AI, in one platform of small Rust services. Run it as a managed service or on your own Kubernetes, on the cloud and in the region you choose. Broad enough to replace a shelf of SaaS subscriptions, small enough that one team can operate it. You write the business logic; OpsPlane covers everything around it.
The platform
Each service runs independently, with its own database and API. Run all of them, or only the ones you need. They share one identity model, one gateway and one audit trail.
A reverse proxy that already knows your platform identity, with routing, load balancing, rate limits and WASM plugins on both the request and the response path.
A vendor-neutral flag service that speaks OFREP, so any OpenFeature SDK works against it out of the box.
Governed AI for the whole team: a chat interface and an OpenAI-compatible API, with agents that use your runbooks and platform tools. A policy for where models may run, personal data redacted before any model sees it, budgets and a full audit trail.
Alerts from Grafana and PagerDuty, deduplicated, silenced during maintenance, checked for flapping and grouped into incidents, so people are woken up only when it matters. Escalations run as durable workflows.
Long-running work that survives restarts, retries and deploys. It runs on Temporal, with workflows compiled to WebAssembly, and powers on-call automation today.
Metrics, logs and traces from your services under one query surface, feeding the same objectives and alerts the incident side runs on.
Service objectives that decide what counts as a problem, and a reviewable incident record built from the alerts they raise.
Who someone is and what they can reach, in one place, with a single API in front of every secret store you already run.
Sovereign by default
Identity, secrets, incidents and prompts are the most sensitive data a company has. OpsPlane keeps them where you decide, and enforces it in code rather than in a contract.
Any conformant Kubernetes cluster: your own hardware, a hyperscaler or a regional cloud such as OVHcloud, Scaleway, IONOS, Hetzner or STACKIT. The managed service runs in the region you need, including the EU.
AI Hub knows where each model provider processes data, and agents use only the providers you configure. Run models on your own infrastructure, or keep AI inside the EU with one setting: Mistral and the European clouds’ model APIs work out of the box, as do self-hosted models.
Email addresses, phone numbers, IBANs, card numbers and IP addresses are redacted before a message reaches a model or the database.
OpenFeature for flags, OpenID Connect for login, the Model Context Protocol for AI tools, the OpenAI API for models. Every resource is a Kubernetes object you can export.
Small by design
Every backend service is a single Rust binary on a shared PostgreSQL. That is what makes self-hosting realistic and the managed service affordable.
memory for all seven services at idle
per service binary
Kubernetes resource types, one per configurable entity
resource to install the whole platform
Measured on release builds with each service connected to its database, October 2026.
Why Rust and WebAssembly
The platform holds your identities, secrets and incidents, so we chose the technology for safety first, and got speed with it.
Rust checks memory safety when the code is compiled. Buffer overflows, use-after-free and data races, the bugs behind about 70% of serious security issues that Microsoft and Google report in C and C++ code, cannot occur in safe Rust.
Rust compiles to machine code and has no garbage collector, so there are no pauses under load. The same hardware serves more traffic, and a full platform fits on one small node.
Each service ships as one binary in a minimal (distroless) container, with no shell or package manager inside. Fewer moving parts means fewer things to patch.
Gateway plugins and on-call workflows run as WebAssembly. A plugin cannot touch the file system or the network, gets a limited CPU budget, and a crash in it cannot take the gateway down.
On-call workflows are compiled to WebAssembly and run on Temporal, which replays them deterministically after a restart, a deploy or a failure, so an escalation is never lost halfway.
A WebAssembly module runs the same on any CPU and operating system, and you can write plugins in any language that compiles to it, not only Rust.
How you run it
It is the same software either way, and it runs on any cloud — so the choice is a deployment decision rather than a commitment. Start managed and bring it in-house later, or the other way round.
We run the platform for you. Nothing to install, upgrade or keep available, and one bill instead of the shelf of subscriptions it replaces.
You run it on your own Kubernetes cluster, on any cloud or on your own hardware, against your own PostgreSQL and inside your own network boundary, so your incident data and your prompts never leave your infrastructure.
The economics
Every service here is something teams normally buy separately. Bought separately, each one also has to be integrated separately, reviewed separately and renewed separately — and that is rarely the bill anyone counts.
Feature flags, observability, incident management, secret management, a gateway and an AI layer are six or seven vendors at most companies. Here they are one thing you run.
The services share identity, gateway and audit trail by design, so you are not writing glue between vendors who never planned for each other.
One codebase, one deployment, one data boundary to assess — instead of a fresh questionnaire per vendor, every renewal cycle.
A handful of services and one PostgreSQL. Self-hosted, it is not meant to become a platform team’s full-time job — and managed, there is nothing to run at all.
Declarative by default
A Kubernetes operator installs the platform and reconciles your custom resources into the services behind it. Users, roles, feature flags, gateway routes, alert rules and AI agents all live in your Git repository, not in a UI someone clicked through once.
Every platform resource is a custom resource, 40 kinds in all, so changes go through the same review and rollback process as your application code. One OpsPlanePlatform resource deploys every service.
The operator syncs resources to each service through idempotent endpoints, re-applies them periodically and removes them when you delete the resource. Secrets and ConfigMaps it references are watched too.
The console covers dashboards, incidents, flags, connectors and settings — with dark mode and full mobile support.
Why it is built this way
Everything a product needs but no product is really about — login, flags, secrets, alerts, long-running work — is the platform’s job. That division is the whole point.
Identity is defined once and every service reads it. No duplicated user tables, no permission model that drifts from service to service.
Kubernetes-native from the start, so it runs on any conformant cluster — any cloud, or your own hardware — and the managed service is the same software. Moving is a deployment decision, not a migration, and never a re-platforming.
OFREP for flags, Grafana webhooks for alerts, OpenID Connect for login, MCP and the OpenAI API for AI. Swap OpsPlane out and your integrations still make sense.
Tell us what your team is paying for today and we will help you work out whether OpsPlane replaces enough of it to be worth the move, or say so plainly if it does not.
