Day 189 — 🥳How I Cleared My 12th Certification of the Year: Certified Backstage Associate🎉
07th July 2026, Netherlands — Clearing my 12th certification of the year — Certified Backstage Associate (CBA) — was a special milestone for me. Every certification teaches something new, but this one was different because Backstage is not just another tool. It represents a bigger shift in modern platform engineering: improving developer experience, standardizing engineering workflows, and building internal developer portals that help teams move faster with more clarity.
The Certified Backstage Associate certification is offered by CNCF and The Linux Foundation. It is designed for IT engineers, developers, DevOps engineers, platform engineers, and SREs who want to validate their understanding of Backstage and its role in modern software delivery. Backstage helps organizations centralize services, documentation, ownership, software templates, APIs, plugins, and operational metadata into one developer portal. CNCF describes Backstage as an open platform that helps organizations manage and streamline software development infrastructure, improve productivity, and strengthen standardization and governance across projects.
Why I Chose Certified Backstage Associate
As platform engineering becomes more important, developer experience is becoming a serious engineering priority. Today, teams do not only need CI/CD pipelines, Kubernetes clusters, monitoring tools, documentation, and security checks. They also need a unified way to discover, use, and manage these capabilities.
That is where Backstage becomes valuable.
Backstage brings together the scattered parts of engineering work into a single internal developer portal. It helps answer questions like:
What services do we own?
Where is the documentation?
Who owns this component?
How do we create a new service?
Which APIs are available?
Which plugins can improve engineering workflows?
How do we standardize software delivery across teams?
The CBA certification validates whether you understand these concepts from a practical Backstage perspective. According to the Linux Foundation’s badge description, a Certified Backstage Associate has the skills to stand up, deploy, and manage a Backstage project as a standalone engineer or team lead.
For me, this exam was not only about passing another certification. It was about strengthening my understanding of internal developer platforms and how Backstage fits into the platform engineering ecosystem.
Exam Details
The Certified Backstage Associate exam is an online, proctored, multiple-choice exam. The exam cost is listed as $250, and it includes one free retake.
The exam duration is 90 minutes, and the domains are divided as follows:
Backstage Development Workflow — 24%
This domain focuses on the developer workflow around Backstage. You should understand how a Backstage application is created, structured, configured, extended, and maintained. Topics like Node.js, Yarn/NPM, TypeScript, app packages, backend packages, configuration files, and development commands are important here.
Backstage Infrastructure — 22%
This domain covers how Backstage runs in real environments. You should know deployment patterns, databases, authentication, integrations, configuration management, containerization, and production-readiness basics. PostgreSQL, Git integrations, OAuth, Kubernetes, and environment-specific configuration are useful areas to understand.
Backstage Catalog — 22%
The software catalog is one of the most important parts of Backstage. You should understand entities, components, systems, APIs, resources, users, groups, ownership, relations, catalog descriptors, YAML definitions, annotations, and how catalog data enables service discovery and governance.
Customizing Backstage — 32%
This is the highest-weighted domain. It focuses on extending and customizing Backstage using plugins, UI customization, templates, integrations, and configuration. You should understand how plugins work, how Backstage can be adapted for an organization, and how customization improves developer experience.
My Preparation Strategy
My preparation was based on one simple principle: do not prepare only to pass the exam; prepare to understand how Backstage solves real platform engineering problems.
I divided my preparation into four tracks.
1. Understand the “Why” Before the “How”
Before going deep into commands, YAML files, or plugins, I spent time understanding why Backstage exists.
Backstage is not only a dashboard. It is an internal developer platform framework. Its real value comes from reducing cognitive load for developers. Instead of asking developers to remember many tools, links, owners, documents, templates, and processes, Backstage brings everything into one place.
This mindset helped me connect exam topics with real-world use cases.
For example:
The catalog is not just YAML. It is service ownership and discovery.
TechDocs is not just documentation. It is documentation closer to code.
Software templates are not just scaffolding. They are standardization at scale.
Plugins are not just UI extensions. They are the mechanism for platform extensibility.
Authentication is not just login. It is enterprise access control and identity integration.
Once this was clear, the exam topics became much easier to understand.
2. Study the Official Curriculum Carefully
The official CNCF curriculum is very important. CNCF has open sourced the curriculum for its certification exams, including CBA, and recommends it as a preparation guide.
I used the curriculum as a checklist. Instead of randomly studying Backstage, I mapped each topic to the exam domains.
My approach was:
Read the domain.
Break it into subtopics.
Study each subtopic from Backstage documentation or structured training.
Create short notes.
Revise repeatedly.
Connect each topic to a real use case.
This prevented me from over-preparing in one area and ignoring another. Since customization has the highest weight at 32%, I gave extra attention to plugins, UI customization, app structure, and templates.
3. Build a Small Backstage Instance
For any Backstage certification, hands-on practice is extremely valuable.
I created a local Backstage instance and explored:
Creating a Backstage app
Understanding the app and backend structure
Running Backstage locally
Reading app-config.yaml
Adding catalog entities
Creating component YAML files
Understanding systems, APIs, resources, users, and groups
Exploring TechDocs
Reviewing plugins
Understanding authentication and integrations
Looking at PostgreSQL usage for production-style setup
Exploring software templates and scaffolder concepts
Even though the exam is multiple-choice, hands-on practice improves confidence. You do not have to memorize everything blindly when you have already seen how the pieces fit together.
4. Prepare Topic-Wise Notes
I created concise notes for each major topic. These notes were very useful during revision.
My important revision areas were:
Get Alok Rahul’s stories in your inbox
Join Medium for free to get updates from this writer.
Backstage architecture
Backstage app structure
Frontend and backend packages
Configuration hierarchy
Software catalog
Entity kinds and relations
Catalog descriptors
Annotations and metadata
TechDocs
Software templates
Scaffolder
Plugins
Authentication providers
GitHub/GitLab integrations
Database usage
PostgreSQL versus in-memory database
Deployment basics
Containerization
Role of Backstage in platform engineering
Developer experience and governance
I also focused on small but important conceptual differences. For example, understanding the difference between a component, system, resource, and API is very important. Similarly, understanding the difference between local development configuration and production configuration can help in exam scenarios.
What Helped Me Most
The biggest factor was structured preparation.
I want to sincerely thank Vimal Daga Sir for continuous inspiration and guidance in the learning journey. His way of encouraging consistent learning, discipline, and practical understanding has helped me stay focused across multiple certifications.
I also want to thank Sanjeev and Mumshad from KodeKloud for structured content. Good structured content saves time, reduces confusion, and gives a proper direction for preparation. When preparing for certifications, structure matters a lot because it helps you know what to study, how deeply to study, and how to revise effectively.
My Recommended Preparation Plan
For anyone preparing for the Certified Backstage Associate exam, I would suggest the following strategy.
Week 1: Learn Backstage Fundamentals
Start with the purpose of Backstage. Understand internal developer portals, developer experience, software ownership, service discovery, and platform engineering. Do not rush into plugins immediately. First understand why Backstage is useful.
Study:
What is Backstage?
Why do organizations use it?
What problem does it solve?
What is an internal developer portal?
How does Backstage support platform engineering?
Week 2: Focus on Catalog and Configuration
Spend deep time on the software catalog. This is a core part of Backstage.
Study:
Entities
Components
Systems
APIs
Resources
Users
Groups
Relations
Ownership
Catalog YAML
Annotations
Metadata
Catalog ingestion
Also understand app-config.yaml, environment-specific configuration, and how Backstage connects with external systems.
Week 3: Study Plugins, Templates, and Customization
Since customization has the highest exam weight, this area deserves serious focus.
Study:
Plugin architecture
Frontend plugins
Backend plugins
Adding plugins
Customizing UI
Software templates
Scaffolder
TechDocs
Organizational customization
Developer workflows
Try to understand how plugins make Backstage extensible and how templates help teams standardize service creation.
Week 4: Infrastructure and Final Revision
In the final stage, focus on deployment and infrastructure topics.
Study:
Database options
PostgreSQL usage
In-memory database limitations
Authentication
OAuth
Git integrations
Container deployment
Kubernetes deployment concepts
Production-readiness basics
Security and access considerations
Then revise all domains based on their weightage.
Exam Attempt Strategy
During the exam, read every question carefully. Since it is a multiple-choice exam, many options may look similar. Focus on the keyword in the question.
Ask yourself:
Is the question about catalog?
Is it about configuration?
Is it about customization?
Is it about deployment?
Is it about developer workflow?
Is it asking for the best practical approach?
Do not rush. Ninety minutes is manageable if you stay calm and avoid overthinking every question.
My advice is to complete the first pass confidently, mark uncertain questions, and then revisit them. Often, later questions help you remember concepts that clarify earlier doubts.
Final Thoughts
Clearing the Certified Backstage Associate exam as my 12th certification of the year is a proud milestone for me. More than the badge, this certification helped me strengthen my understanding of platform engineering, developer portals, and how Backstage can improve engineering productivity.
Backstage is becoming increasingly important because organizations are looking for better ways to manage complexity. As teams grow, tools multiply, services increase, and documentation gets scattered. Backstage provides a structured way to bring clarity, ownership, and standardization into the software delivery process.
For anyone preparing for this exam, my message is simple:
Do not just study Backstage as a tool. Study it as a platform engineering solution.
Understand the problem it solves. Practice hands-on. Follow the official curriculum. Use structured content. Revise domain-wise. Stay consistent.
This certification is absolutely achievable with the right preparation strategy, and it can add strong value for anyone working in DevOps, SRE, platform engineering, cloud-native engineering, or developer experience.
Grateful to Vimal Daga Sir, and thanks to Sanjeev and Mumshad from KodeKloud for the structured learning content and guidance that helped me in this journey.
On to the next learning milestone.
