Linux Foundation Certified Backstage Associate

The fastest way to learn is to run it. You create an app with the official tool, understand the layout of the generated project, install dependencies, and start frontend and backend together.

• Prerequisites: Node.js and a package manager
• Creating an app with create-app
• The generated project layout
• Installing dependencies with NPM or Yarn
• Starting the app and exploring the default portal
• Common setup problems

You build A local Backstage app running with its default catalog, plus a note on the project layout.

Backstage is written in TypeScript, so reading it means reading types. You learn the TypeScript you need to follow the code, compile a project, fix type errors, and use the linter and tests that ship with the app.

• Types, interfaces and modules in TypeScript
• Compiling with tsc and reading errors
• Reading Backstage source and type definitions
• Linting and formatting
• Running the test suite
• Workspaces and how packages depend on each other

You build A small typed utility package added to the app, compiled, linted and tested.

Behavior is set through configuration rather than code. You read and layer app-config files, substitute environment variables, set up integrations and authentication, and keep secrets out of the repository.

• app-config.yaml and its structure
• Local and production configuration layers
• Environment variable substitution
• Integrations with source control
• Authentication providers in outline
• Keeping secrets out of configuration files

You build A production configuration layered over local settings, with secrets supplied from the environment.

Backstage is a client-server application built from plugins. You learn what runs in the browser and what runs on the server, how plugins are wired into each side, and where state is stored.

• Client-server architecture
• The plugin model and what a plugin is
• Frontend plugins and backend plugins compared
• How the frontend calls the backend
• Databases: SQLite for development, PostgreSQL for production
• Reading logs from both sides

You build A diagram of a running portal naming each package, plugin and data store, checked against the project.

A portal on a laptop helps nobody. You build the app for production, package it as a container image with Docker, connect a production database, and deploy it somewhere teams can reach.

• Building frontend and backend for production
• Writing and building the Docker image
• Production database and configuration
• Deploying to Kubernetes or a container host
• Health checks and logs in production
• Upgrading Backstage safely

You build A container image of the portal running against a production-style database, deployed to a cluster.

The catalog is the heart of the portal. You describe software as entities in YAML files, learn the common kinds and how they relate, and see why ownership and structure make the catalog useful.

• Why a catalog matters
• Entity descriptors: metadata and spec
• Kinds: Component, API, Resource, System, Domain
• Users, groups and ownership
• Relations between entities
• Validating a descriptor

You build Descriptors for a small system of components, APIs and resources, each with an owner.

A catalog is only as good as what feeds it. You register entities by hand and automatically, use annotations to connect them to other tools, and work out why an entity does not show up.

• Registering a location by URL
• Automated discovery from source control
• Entity providers and processors in outline
• Annotations that link to source, docs and CI
• Refresh timing and orphaned entities
• Troubleshooting ingestion errors

You build A catalog populated automatically from a set of repositories, with a log of three ingestion faults fixed.

Most customization happens in the frontend. You add and configure plugins, change React components in the app, build pages from Material UI components, and apply a theme that matches your organization.

• Installing and configuring a frontend plugin
• Routes, pages and the app’s structure
• Changing React code in the app package
• Material UI components and layout
• Theming the portal
• Writing a simple frontend plugin

You build A customized portal home page and a small frontend plugin, styled with Material UI.

Backend plugins add data and behavior behind the portal. You install and configure them, write a small one that exposes an API, and connect it to a frontend plugin.

• Installing and configuring a backend plugin
• How backend plugins register and receive services
• Writing a plugin that serves an API route
• Calling it from a frontend plugin
• Permissions in outline
• Testing a backend plugin

You build A backend plugin with one API endpoint, consumed by a frontend card on an entity page.

Stand up a portal a team would actually use. You configure and deploy it, load its catalog, customize its look and one plugin, and write down how someone else would operate and extend it.

• Planning the portal around real needs
• Configuring, building and deploying it
• Populating the catalog
• Customizing frontend and backend behavior
• Writing an operations guide

You build A deployed portal with a populated catalog, one custom plugin and an operations guide.