Putting it together: one golden path, end to end
You now have every piece. Here is how they fit into the path a developer actually walks on day one of a new service - and what the platform team owns at each step.
1. Backstage > Create > "Java service" the template (platform team)
│ name: billing-api, owner: team-billing, database: small
▼
2. scaffolder: fetch:template ─ publish:gitlab ─ catalog:register
│ repo apps/billing-api on git.lab, with:
│ catalog-info.yaml Component + Resource (the database)
│ deploy/database.yaml kind: Database (the Crossplane API)
│ deploy/app.yaml Deployment labelled backstage.io/kubernetes-id
│ docs/ + mkdocs.yml TechDocs
▼
3. GitOps (Argo CD) syncs deploy/ into the team's namespace
▼
4. Crossplane: Database/billing-api ─▶ Composition ─▶ RDS Instance + Secret
▼
5. Backstage shows it: the catalog entity, owner, relations, Docs tab,
Kubernetes tab, links to the repo and the pipeline
Two design decisions make this a platform rather than a pile of scripts:
- The template writes declarative files, not resources. It never calls AWS. It writes a
Databaseobject into the repository, and GitOps applies it. The request is reviewable, reproducible and lives with the service. - Every decision the team did not make is in one reviewed place. Instance class, backups, encryption, tags, the deletion protection: the Composition. The repository layout, CI and docs skeleton: the template. Change them once and every new service gets the change; existing ones follow through Composition revisions (carefully - the lifecycle lesson).
The catalog entry for the infrastructure
Model the database in the catalog too, so ownership and dependencies are visible and on-call can find who owns billing-api-db at 3 a.m.:
apiVersion: backstage.io/v1alpha1
kind: Resource
metadata:
name: billing-api-db
description: PostgreSQL for billing-api (Crossplane Database/billing-api)
spec:
type: database
owner: team-billing
system: billing
---
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
name: billing-api
annotations:
backstage.io/kubernetes-id: billing-api
backstage.io/techdocs-ref: dir:.
spec:
type: service
lifecycle: experimental
owner: team-billing
system: billing
dependsOn:
- resource:billing-api-db
Community plugins go further and show Crossplane XRs and their trees directly on the entity page; the principle is the same: the portal is the front door, the control plane does the work.
Operating the platform
A platform is production software with internal customers. Run it like one:
- SLOs for the platform itself. "A new service is live in under 30 minutes" (template to running pod); "a Database is Ready within 15 minutes, 99% of the time". Measure them from the objects you already have: task timestamps, conditions'
lastTransitionTime. - Alert on stuck reconciles. Crossplane exposes Prometheus metrics; at least alert on XRs and managed resources that stay
Synced=FalseorReady=Falselonger than their normal creation time. The expired-credentials incident is invisible to application monitoring: the database keeps working while nothing manages it. - Upgrade on purpose. Crossplane ships a minor release every few months with patch releases in between; providers and functions release more often. Pin versions, read release notes, upgrade in a staging control plane first. Backstage moves faster still - a release every month (
backstage-cli versions:bumpupgrades an app's packages together). - Credentials are the platform's crown jewels. The ProviderConfig secret can create and delete everything. Prefer workload identity (IRSA, Pod Identity) over keys; restrict who can read
crossplane-system. - Version your APIs. XRDs get new versions instead of breaking changes; templates get new names (
java-service-v2) instead of silently changing whatjava-serviceproduces.
What to measure
Ask whether the platform reduces load and speeds teams up, not whether it exists:
| Signal | Example |
|---|---|
| Adoption | share of services created from templates this quarter; share of databases requested through the API |
| Time to first deploy | template run to first successful deploy |
| Waiting | tickets to the platform team per month (should fall) |
| Outcomes | DORA metrics of teams on the golden path vs off it |
| Satisfaction | a short survey each quarter; the free-text answers are your backlog |
Where to stop
The thinnest viable platform wins. Do not wrap every AWS service in an XRD; wrap the five things every team needs and let the rest come later, when demand shows. Do not hide everything: a team that needs a non-standard database should be able to request a raw managed resource (with review) rather than be blocked. And keep the escape hatch documented, because every team that uses it tells you what the next golden path should be.
In an interview: a golden path in an IDP: a Backstage template creates the repository with declarative requests (a Crossplane XR for the database), its catalog-info.yaml and docs; GitOps applies the requests; Crossplane builds the infrastructure from a reviewed Composition; Backstage shows the result. Run the platform like a product, with its own SLOs and adoption metrics.