For Backstage Teams
Your portal is ready. Now build the platform behind it.
Backstage gives developers a great experience layer. OpenChoreo adds the platform behind it, turning developer actions into governed, production-ready workloads across your Kubernetes environments.
The Problem Statement
The hard part starts after the catalog
You invested in Backstage, and it delivered. But as developers start asking harder questions, the limitations of a portal without a platform underneath it become clear.
The Path Forward
The three stages of Backstage maturity
Just a Catalog: Service Discovery
Services are registered. Docs and ownership are centralized. It's far better than tribal knowledge, but it's still read-only. Developers look things up; they don't act from here.
An Interactive Map: Live Visibility
Plugins surface live Kubernetes status, recent deployments, CI/CD results. Developers can see what's running in Kubernetes, but the moment they need to act on it, the complexity leaks through.
An Actionable Platform: Self-Service Execution
A runtime sits beneath Backstage. Developers deploy, promote, and configure from the portal. Golden paths are enforced at the infrastructure level. Runtime state flows back automatically.
OpenChoreo is the runtime that bridges Stage 1 and Stage 3, adding the missing execution layer beneath your Backstage portal. No rip-and-replace. It's designed to plug directly into your existing catalog.
Read the DocsHow It Works
From point-to-point integrations to a platform architecture
Most Backstage deployments grow organically. Each new capability wired in manually, one integration at a time. OpenChoreo replaces that with a layered architecture that scales.
Learn more about OpenChoreoStart with Backstage
You adopt Backstage as your developer portal. Teams register services, docs get centralized, then the requests come in. CI status, live Kubernetes health, observability links. Each answer becomes a new point-to-point integration. This is the messy middle.
Add a control plane
Instead of wiring Backstage to every tool, a control plane sits between your portal and your infrastructure. Developers and platform engineers work with high-level abstractions; the control plane compiles these into Kubernetes config and feeds runtime state back into Backstage automatically.
Organize your runtime
Behind the control plane, your runtime separates into purpose-built planes: the Workflow Plane for CI/CD, the Data Plane for running workloads, and the Observability Plane for logs, metrics, and traces — all scoped back to each component in Backstage.
Platform Maturity Assessment
Where does your Backstage deployment stand?
Answer 9 questions to find out whether you're running a catalog, an interactive map, or a true actionable platform, and what it would take to close the gap.
How do developers in your organization find information about services — who owns them, what APIs they expose, whether they're healthy?
Result: Just a Catalog
Your Backstage deployment is doing exactly what it was designed for — centralizing service discovery and reducing tribal knowledge. That's real value. But right now it's primarily a reference tool, not a platform. Developers look things up here; they don't act from here.
Your highest-impact next steps
- Instrument your existing CI/CD pipelines and K8s clusters to feed live state back into Backstage — even basic plugin integrations will dramatically improve your catalog's usefulness.
- Build Backstage scaffolding templates that encode your org's standards at service creation time — this is the fastest way to establish consistent golden paths.
- Consider what a control plane layer would give you — OpenChoreo can add a complete execution layer beneath Backstage without replacing any of your existing catalog work.
Result: An Interactive Map
You've moved beyond a static catalog — your Backstage portal surfaces live data and gives developers a meaningful window into what's running. But it's still a map: it shows you where things are, not a platform that lets you act on them. The gap between visibility and execution is where most teams get stuck.
How to bridge the gap to an Actionable Platform
- Identify the "messy middle" in your current setup — the point-to-point integrations that need constant maintenance. A control plane replaces this entire layer.
- Move from golden paths as templates to golden paths as platform invariants — enforced at the infrastructure level, not just at scaffolding time.
- Add self-service deployment and promotion flows so developers can act from Backstage, not just observe from it. OpenChoreo makes this possible without rebuilding your existing portal.
Result: An Actionable Platform
You're operating at the leading edge. Your Backstage deployment has a real execution layer beneath it — self-service deployments, enforced golden paths, runtime state flowing back automatically. Now the question is what you build on top of it.
What comes next at this level
- Your platform is already AI-ready — activate it. If you're not already exposing MCP servers or agent skills, this is your highest-leverage next move.
- Deploy built-in agents as platform capabilities — an SRE agent for root cause analysis, FinOps agents for cost visibility, and Architect agents for dependency and impact analysis.
- Treat the platform as a product. Measure adoption, DORA metrics, and developer satisfaction — and publish a roadmap so your internal users know what's coming.
What changes when you add a runtime.
OpenChoreo doesn't replace Backstage; it gives it an engine.

CI/CD and GitOps, built in
Stop wiring pipelines to clusters. OpenChoreo handles the full path from source code to production, with Backstage showing the result, not just a link to another tool.
Observability wired to your catalog
Logs, metrics, and traces appear scoped to each Backstage component and environment. Developers get the full picture via a single pane of glass, with no configuration required.
Golden paths that stay golden
OpenChoreo enforces relationships between components and environments at the infrastructure level. Standards aren't just documented, they're compiled into every deployment.
Zero rip-and-replace
OpenChoreo integrates with your existing Backstage catalog and the tools already registered in it. Your current investments stay intact; the runtime fills the gap.
AI agents as first-class platform participants
When your platform has well-defined abstractions and a control plane, AI agents can interact with it just like developers do: creating components, triggering deployments, querying service dependencies, and surfacing root causes via MCP servers and agent skills. Good platform architecture is what makes AI actually useful in your infrastructure.
OpenChoreo is a CNCF Sandbox project. It is an open-source developer platform for Kubernetes with an active contributor community. The architecture described here is also documented in the CNCF Platform Engineering Maturity Model.
1-Week Quick Start
See it working in your environment, free
- Day 1–2
Onboard sample services
We work with your team to connect a set of real services to OpenChoreo, demonstrating a complete code-to-cloud flow in your environment.
- Day 2–3
Populate Backstage natively
Watch those services automatically appear in your Backstage portal with live logs, metrics, GitOps state, and deployment history, no manual wiring.
- Day 3–4
Validate golden paths
Test our architectural abstractions and see how they eliminate the need for glue code while enforcing your org's standards at the infrastructure level.
- Day 4–5
Expert debrief & roadmap
Our platform architects walk you through findings, answer your team's questions, and co-design a migration path that respects your existing toolchain.