I wrote the longer version, with every config detail I studied and the full prep timeline, on my blog.
I scored 80 on the Certified Backstage Associate exam. Passing is 75.
No single domain sank me. I gave two or three soft answers in each of the four domains, and they stacked up until I was a couple of bad guesses away from a retake. CBA takes a point here and a point there, wherever you were pretty sure instead of certain.
Why CNCF exam habits don’t help
CBA was one of my last exams on the Golden Kubestronaut track. Other CNCF certs test you on operating something. CBA is 60 multiple choice questions in 90 minutes about how a framework works. No kubectl, no cluster to fix.
The wrong answers are written to catch people who learned Backstage by osmosis. I felt confident going in.
What made it click: Backstage is a TypeScript framework you build on and own. Once I stopped thinking of it as a wiki with plugins and treated it as a platform for building platforms, the plugin and architecture questions started to make sense.
| Domain | Weight |
|---|---|
| Customizing Backstage | 32% |
| Backstage Development Workflow | 24% |
| Backstage Infrastructure | 22% |
| Backstage Catalog | 22% |
Customizing Backstage (32%)
Mostly: what’s a frontend plugin and what’s a backend plugin.
Frontend plugins are React components. They run in the browser, register routes, show up in the sidebar, and talk to backend plugins over HTTP. Backend plugins are server-side, independent services with their own database connections, exposing REST or GraphQL APIs. Expect questions on where code runs, plugin registration and what App.tsx does (it wires plugins together).
Smaller items: Material UI is the UI library (not Tailwind, not shadcn), and extension points let modules hook into existing plugins without forking them.
Development Workflow (24%)
Three commands matter:
npx @backstage/create-app@latest
yarn dev
yarn build && yarn build-image
The first scaffolds a monorepo with the frontend app and backend together. yarn dev runs both in watch mode. yarn tsc is a separate step from building the Docker image, and the exam asks where each step fits, including where yarn install sits relative to yarn tsc.
Infrastructure (22%)
PostgreSQL is for production, SQLite for development only. The exam will offer answers that present SQLite as production-ready.
The backend uses Knex, and each plugin gets its own logical database. Cache backends (memory, Redis, Memcached) are in scope too.
The rest is mostly app-config.yaml, which is layered. app-config.yaml is the base, app-config.local.yaml and app-config.production.yaml sit on top, and later files override earlier ones. Secrets come from environment variables via ${...} substitution. Know the integrations, backend.database and catalog.locations blocks.
Catalog (22%)
Small weight, subtle distinctions. The entity descriptor format is tested directly:
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
name: my-service
annotations:
backstage.io/techdocs-ref: dir:.
spec:
type: service
lifecycle: production
owner: team-a
system: my-system
Know every kind: Component, API, System, Domain, Resource, Group, User, Location. Confusing Component with API is the most common way to drop catalog points. Well-known annotations carry meaning and point at external systems (backstage.io/techdocs-ref, github.com/project-slug), while labels are plain key-value pairs for filtering. Entities arrive through a static catalog.locations entry or through discovery providers.
I underestimated ingestion troubleshooting most. You register an entity and it doesn’t show up: invalid YAML, wrong apiVersion, missing required fields, a processing error in catalog-backend. All in scope, and “I think I know” won’t get you through it.
How I prepared, and what I’d change
About 6 hours on the official docs first, starting with the architecture overview and then the catalog and plugin pages linked above. Then LFS142 from the Linux Foundation, which is free and covers the material at the right depth. I did it in one sitting, maybe 3 hours. I think it beats most third-party courses because people who work on Backstage wrote it.
My Kubernetes knowledge didn’t carry over; I caught myself applying k8s mental models to catalog questions.
The bigger mistake was quieter. I read each domain until it felt familiar, then moved on. On exam day “I’ve seen this” wasn’t enough, and that gap is where my soft answers came from. Next time I’d drill each domain until I could answer from memory.
That’s why I built a free CBA practice test. It’s catalog-heavy on purpose and shows you the difference between “familiar” and “certain” before the exam does. The other CNCF practice tests use the same approach, and the rest of my resources live in awesome-kubestronaut.
If I sat it again, I’d bank the easy points fast (entity kinds and spec fields, the three commands, frontend vs backend scope) and spend the remaining prep on ingestion troubleshooting and annotations vs labels.
I still can’t settle the dev workflow question. Backstage ships so often that I’m not certain what I studied matches what you’ll get. If something in that domain surprised you recently, I’d like to hear about it.
Originally published on yetmike.com.