Blog
/
Share this article

Developer experience over Backstage for your autonomous operations

Developer experience over Backstage for your autonomous operations

The argument in brief

We believe Backstage can be a practical front door for autonomous operations. Many developers already use it to understand a service, and agents can act on the information it holds.

CI, declarative infrastructure, ephemeral environments, and observability often live in four separate consoles. The Backstage catalog can give them a shared identifier: the component and its owner. Agents can then work through the same tools developers use, rather than around them.

Developers get one portal and one approval flow, and the platform team keeps governance in templates, policies, and runbooks. The Backstage touchpoints described here are a design pattern, not a claim about any one product.

The problem

AI made the inner loop fast, but operations did not change. Developers and coding agents now produce more changes, while review, environments, rollout, and incident response still run at human speed.

For a developer, the cost shows up as context switching. One change touches a CI system, a Terraform repo, a test environment, and a dashboard, each with its own login, vocabulary, and owner. Agents that write code and infrastructure changes make this worse, because they produce more changes than people can review across four consoles.

The fix is not another console. It is a shared management layer that the tools, the developer, and the agents all read from.

Why Backstage is the shared management layer

The Backstage software catalog describes what exists: components, APIs, resources, systems and domains, and who owns them. It is declared in catalog-info.yaml files kept next to the code, so people, plugins, and agents can all read it.

Three properties matter for this argument.

  • One identity per service. CI runs, environments, dashboards, and incidents can all attach to the same component.
  • One entry point. Developers already use the catalog, the Create page and entity pages, so no new habit is needed.
  • Extensible by plugin. Each tool can add a tab, card, or scaffolder action to the entity page instead of sending developers elsewhere.

Here is a minimal catalog-info.yaml for one service. Each annotation points a tool at the component, and the owner and dependsOn lines tell people and agents who to contact and what is affected:

apiVersion: backstage.io/v1alpha1
kind: Component  # a service
metadata:
 name: payments-api
 annotations:
   github.com/project-slug: acme/payments-api  # code and CI live here
   grafana/alert-label-selector: "service=payments-api"  # its alerts
   acme.io/slo-availability: "99.9"  # (custom) reliability target
   acme.io/runbook: "https://example.com/rollback"  # (custom) runbook
   acme.io/preview-url: "https://pr-{pr}.acme.dev"  # (custom) PR preview
spec:
 type: service
 lifecycle: production  # live, not experimental
 owner: group:default/payments-team  # who to contact or page
 dependsOn:
   - resource:default/payments-db  # what it needs to run
---
apiVersion: backstage.io/v1alpha1
kind: Resource  # a piece of infrastructure
metadata:
 name: payments-db
spec:
 type: database
 owner: group:default/payments-team

The three acme.io lines are examples of custom metadata, not standard Backstage annotations. The preview-url line is how the component page can show a Preview link for each pull request, with {pr} replaced by the PR number. Use whatever convention your platform team already has.

Bringing CI systems together

Many large organizations run more than one CI system, often because of mergers and acquisitions or because different teams made different tooling choices over time. For example, one team may use GitHub Actions while another uses GitLab CI. Backstage does not replace them. It maps each pipeline to the component it builds and shows the runs on that component’s page.

That gives the developer one answer to “is my change green?” without knowing which system ran it. It also gives agents a single place to find the pipeline, the owner, and the last result for a component.

CI stays where code is built and tested. Backstage supplies the context around it: who owns the service, what it depends on, and what else is running for the same change.

Bringing declarative systems together

Declarative means the desired state is written down and checked: catalog-info.yaml for the catalog, kind: Template for scaffolding, Terraform or OpenTofu and Kubernetes manifests for infrastructure. Backstage ties them together at creation time. One template can create the repo, the catalog entry and the infrastructure request in a single step.

Platform teams encode their standards once, as approved modules and policy checks. Developers describe what they need, and the template produces a pull request that already follows those standards. Because everything is code in Git, humans and agents review the same artifact.

Example flow from StackGen’s Aiden for InfraOps. A Backstage plugin built on Aiden’s APIs can pass a plain-language request to Aiden, which returns policy-checked OpenTofu or Terraform for review. Nothing deploys until it is approved.

The Create page becomes a governed path: the easy way is also the approved way.

Bringing ephemeral environments together

An ephemeral environment helps only if people find it. Surfacing it as a Preview link on the component page puts it where the pull request and the owner already are.

Shared staging versus an environment per pull request, from StackGen’s Shipyard. Each PR, including one opened by an agent, is tested in its own full-stack copy and torn down on merge.

Large engineering teams reached the same conclusion on their own. Uber built SLATE so developers could spin up short-lived test environments on demand, instead of competing for a shared staging setup that was flaky and limited how many people could test at once. The pressure is growing: DORA’s 2025 research found that AI adoption now raises delivery throughput but still increases instability, because the systems around the code haven’t caught up.

For autonomous operations, the same pattern adds a safety step. An agent’s code or infrastructure change is validated in a real environment before it is allowed into production.

Bringing observability together

Observability data is useful when it is tied to the thing that broke. The catalog supplies that tie. Each component names its owner, system and dependencies, so a metric, a dashboard, and an alert can all point back to one entity.

Open standards make this practical. Metrics in Prometheus format, traces and logs through OpenTelemetry, and dashboards in Grafana can all be linked from the component page without moving the data.

In Backstage, this would be an Observability tab that shows the service’s SLO and remaining error budget next to its owner.

Where autonomous agents fit

An autonomous operations layer is a set of agents that act on infrastructure, delivery, observability, and incidents. Backstage is its human-facing surface. The catalog says what exists and who owns it, and the agents act on that model through the same tools developers use.

Agents act through the same four tool layers, under human approval

Backstage sits in front; the catalog is the shared model, and agents act through the four tool layers under human approval.

Each kind of agent has one job:

  • InfraOps agent: turns intent into reviewed Terraform or manifests, and flags drift.
  • CI/CD DevOps agent: works on requests such as rollbacks and access from a ticket queue.
  • Observability agent: watches SLOs and links alerts to the right component.
  • SRE Incident agent: triages by SLO impact, finds the likely cause, and proposes a runbook.

What an incident agent looks like in practice, from StackGen’s Aiden for SRE: triage by SLO impact, investigate across logs, traces, and diffs, then propose a fix that ships only after approval.

Autonomy is a dial, not a switch. Start with agents that propose and humans that approve, keep an audit trail on every action, and raise autonomy only for workflows with a clean record.

End-to-end: a new payments service

To make this concrete, consider a fictional developer, Maria, who needs a new payments-api. The work happens in two flows. Infrastructure comes first, so the database is ready before the application is deployed.

Flow 1: Provision the infrastructure

  1. She describes what she needs (Backstage). Maria opens Backstage and requests a private, encrypted Postgres database for a new payments API.
  2. Aiden drafts the infrastructure (Aiden for InfraOps). A Backstage plugin built on Aiden’s APIs passes the request to Aiden, which produces OpenTofu or Terraform from the platform team’s approved modules, runs policy checks, and opens a pull request with the plan and estimated cost.
  3. People approve. The platform team and the payments team review the same pull request. Nothing is applied until it is approved.
  4. The database is created and registered. After approval, the change is applied, using either Aiden’s remote OpenTofu runners or the customer’s own Terraform or OpenTofu runners in its CI/CD pipeline. payments-db is registered in the catalog with an owner.

Flow 2: Build the service

  1. She creates the service (Backstage). A separate Create service template makes the repository, the pipeline, and the catalog-info.yaml, which lists payments-db under dependsOn. As service owner, Maria sets the SLO.
  2. CI builds and tests (GitHub Actions or GitLab CI). When she opens a code pull request, the pipeline runs, and the results show on the payments-api page in Backstage.
  3. A preview environment appears (Shipyard). For each code pull request, Shipyard builds a full-stack copy from the Docker Compose file. Its Postgres volume starts as a copy of the base environment’s data, so Maria tests against realistic test data without touching production. The Preview link appears on the component page, and the environment is torn down on merge.
  4. The service deploys. After merge, the service goes to production through the normal pipeline.
  5. Observability is attached (Aiden for Observability). Managed Grafana dashboards are linked from the component page, and a natural-language query box, built as a plugin on Aiden’s APIs, lets her ask about the service’s health. As service owner, Maria defines the SLO and the alert rules, for example, a burn-rate alert on that SLO. The Observability tab shows the SLO and error budget next to the owner.

What to confirm, and where this can be challenged

This is a design pattern. Backstage tabs, scaffolder actions and approval views can be built with its plugin and template model, but each integration still needs a plugin or custom work. Check what exists for your CI, cloud and observability stack before committing.

Three objections deserve a straight answer.

  • Backstage costs effort to adopt. True. The argument is strongest where a catalog already exists, or where a platform team is ready to own one.
  • Agents acting on production worry people. Start at low autonomy, with approvals, decision traces and audit trails on every change. Raise autonomy only after clean runs.
  • One more layer can hide the tools. Keep the underlying consoles one click away. Backstage should link to them, not replace them.

To get more details about Backstage integration with StackGen, checkout this detailed page here and book a demo with our expert team.

Related posts
Nov 13, 2026
·

Shipyard and Aiden for SRE are now on the Microsoft Marketplace

shipyard-aiden-sre-microsoft-marketplace
Nov 13, 2026
·

StackGen at AWS re:Invent 2026: Visit Us at Booth #1738

stackgen-aws-reinvent-2026
Nov 12, 2026
·

AI SRE in Production: Seven Lessons from KubeCon 2026

ai-sre-lessons-kubecon-2026
View more posts
×

Download the brochure

Complete the form to get your copy.