Why a Backstage threat model checklist comes before go-live
A platform or security team about to put a Backstage portal in front of engineers faces a specific problem: the portal will hold catalog data, software templates and credentials for integrations, and every one of those can reach systems the portal does not own. The threat model checklist answers the question that matters before go-live: which decisions have been made, by whom, on which trust levels, exposure, plugins, permissions, sign-in and resource limits. Each item needs a named owner, because the checklist only protects you if someone is accountable for keeping each control true after launch. Backstage is Apache-2.0 software with no paid edition from the project, so there is no vendor who ships hardening defaults for your environment or runs the portal on your behalf. The hardening work, the patching and the day-two operations belong to your organization, and the checklist is how you make that ownership explicit.
The checklist should cover the components that most often change what an attacker or a careless user can reach. Start with network exposure: decide which backend endpoints are reachable from the internet, from corporate networks or only from inside the cluster, and who sits in front of the frontend. Then review the plugins you intend to install, since each one adds code, routes and possibly stored credentials. Map permissions to roles so that catalog writes, template runs and admin functions have explicit approvers. Choose the sign-in providers and resolvers deliberately, and confirm that guest access is off in production, as the authentication documentation advises. Finally, set limits on URL readers and resource-heavy operations so that one request cannot exhaust the backend. Confirm the exact configuration keys and defaults for your Backstage version in the Backstage authentication documentation and your own app configuration, rather than relying on memory or older blog posts.
Trust levels and the controls each one needs
This table maps each party that touches a Backstage portal to a trust level and the minimum control it needs. Read each row as a question to answer for your own deployment, since the exact trust model should be confirmed against the project's threat model document in the repository. The main takeaway is that most findings come from parties you trust less than you assume, such as plugin code and catalog data sources.
| Party | Trust level and operator meaning | Minimum control to set |
|---|---|---|
| Anonymous visitors | Untrusted. Anyone who can reach the sign-in page or the frontend bundle over the network. | Sign-in required for all routes, guest access disabled in production, and a decision on whether the frontend bundle may be read without login. |
| Authenticated engineers | Trusted to their granted permissions only. Their identity is what the portal logs and authorizes. | One sign-in resolver so every provider maps to the same identity, and permission policies that limit what each group can read or change. |
| Template authors | Partly trusted. Their templates run actions on the backend host and can call integrations. | Restrict who can publish templates, review every custom action, and run scaffolder tasks with user tokens rather than shared elevated credentials. |
| Plugin developers | Partly trusted. Plugin code runs inside the backend with access to its configured secrets. | Vet each third-party plugin before installation, pin versions, and review what credentials and routes it registers. |
| Catalog data sources | Untrusted input until verified. Entity files and providers can register kinds and owners that look authoritative. | Allow-list the kinds each location can register, and confirm who can write to the source repositories and organization data feeds. |
| Integration tokens | High trust. Read or write access to source control, ticketing or cloud APIs, often broader than one portal feature needs. | Keep tokens out of configuration files, scope them to the minimum permissions, and assign an owner who rotates them on a schedule you set. |
| URL readers and remote fetches | Untrusted destinations. A user-supplied or catalog-supplied URL can point at internal services or cloud metadata endpoints. | Allow-list reader hosts in backend.reading.allow and block metadata addresses, as set out in the URL reader hardening page. |
| Operators | Highly trusted, and the most likely source of exposure through configuration drift or shared administrator accounts. | Named administrator accounts, change review for app-config files, audit events shipped to your SIEM, and a documented owner for each control in this checklist. |
Eight checklist areas and who owns each item
The eight areas below cover where a Backstage operator is exposed, from network reach to patch cadence. Each area has one owner role, so no item is left to whoever notices it first. Work through them in order when preparing a production instance.
Network exposure and trust levels
Decide which callers can reach the backend and which are trusted to call it at all. A portal that is reachable from the internet with weak sign-in exposes every plugin route behind it. Check that the frontend, backend and any database or cache sit on separate network paths, that only the frontend and the required ingress are public, and that the trust level for each caller type is written down. Owner: platform team.
Plugin vetting before installation
Every plugin runs with backend access and may add routes, proxies or scaffolder actions. Before installing a third-party or community plugin, review its maintainer activity, its dependencies, the permissions it requests and the credentials it needs. Record each approved plugin and its version in a list the platform team owns. Owner: security team approves, and the app team requesting it supplies the justification.
Permissions and guest access
Permission policies decide what each signed-in user can read, create and change in the catalog and templates. Confirm that guest access is not enabled in production, as the authentication documentation advises, and that the policy grants write access only to the groups that need it. Review the policy whenever a new plugin adds routes. Owner: identity team sets the groups, and the platform team maintains the policy.
Authentication providers and sign-in resolvers
Backstage ships 19 built-in authentication providers, and an operator may enable several. The authentication documentation advises configuring sign-in resolvers so every provider resolves to the same identity. Without that, one person can appear as two users with different ownership and permissions. Test each provider with an account that should map to a single catalog user. Owner: identity team.
URL readers and server-side request forgery
URL readers fetch remote content during catalog ingestion and template runs, so a crafted location can make the backend call internal addresses. Restrict the hosts the backend may read, block cloud metadata endpoints at the network layer, and remember that readers operate outside the permission model. Review the allow list whenever a new source is added. Owner: security team sets the allow list, and the platform team enforces it at the network layer.
Resource exhaustion and rate limits
A large catalog, a long-running scaffolder job or a flood of search queries can consume backend memory, database connections and worker time. Size the database connection pool, set limits on ingress and proxy traffic, and watch queue depth for the scaffolder and catalog. Test with a catalog larger than the one you expect in production. Owner: platform team.
Keys, secrets and token signing
Auto-generated token signing keys reset on restart, which invalidates sessions and can hide key handling gaps. Store static signing keys and integration tokens outside app-config files, use encryption at rest for Kubernetes Secrets or an external secrets manager, and set a rotation schedule. Confirm who can read the private keys and the secret store. Owner: security team sets the rotation policy, and the platform team runs it.
Patching and security advisories
Backstage backports high and critical severity fixes to releases from the last six months where feasible, so an instance that falls behind may lose that coverage. Track the monthly main release and the weekly next line, subscribe to security advisories, and keep the app repository on automated dependency updates. Patch third-party plugins on the same cycle as the core. Owner: app team applies routine updates, and the platform team owns the schedule.
Sign-in and network exposure choices
Here the portal itself handles sign-in through one of the built-in authentication providers. Backstage ships 19 built-in providers, including GitHub, GitLab, Google, Azure, Okta, Auth0, OneLogin, Bitbucket, Cloudflare Access, AWS ALB, Google IAP and generic OIDC. Anyone who can reach the sign-in page can load the frontend bundle, because the sign-in page does not protect the JavaScript. The API is reachable too, and every call must carry a valid session. Identity is resolved by a sign-in resolver, and the project advises that every provider resolves to the same identity, so a person who signs in with two providers does not end up as two users.
- Reach: the bundle and sign-in endpoints are exposed to whatever network can route to the portal, so pair this model with network restrictions.
- Identity: configure resolvers so each provider maps to one catalog user, and do not enable guest access in production.
- Run: your team owns provider app registrations, redirect URIs, client secret rotation and the resolver logic.
- Failure mode: a permissive resolver or an unexpected provider can create identities you did not intend.
Check that guest sign-in is disabled, that each enabled provider resolves to the same catalog identity, and that the bundle exposure has been reviewed against your network policy.
In this model a reverse proxy or identity-aware gateway authenticates the user before any request reaches Backstage. Common choices are an existing single sign-on front door or the AWS ALB and Google IAP providers, which place the check in front of the portal. The proxy controls who can load the bundle, so unauthenticated visitors may never see the JavaScript. Backstage still needs to know who the user is, so the proxy must pass a verified identity that the portal trusts, and the portal must refuse identity headers that did not come through the proxy.
- Reach: the proxy decides who can load the bundle and call the API, which narrows exposure before the portal runs.
- Identity: the trusted header or token must be validated, and direct access that bypasses the proxy must be blocked at the network layer.
- Run: your team operates the proxy, its certificates, its policy rules and the mapping between proxy identities and catalog users.
- Trade-off: you add a component to patch and monitor, and a misconfigured proxy can silently trust forged headers.
Confirm that the portal is unreachable except through the proxy and that the proxy is the only source of identity assertions your resolver accepts.
Here the portal is reachable only from a private network, such as a corporate network, a VPN or a zero-trust access path that terminates inside your perimeter. This model reduces who can reach the bundle and API, but it does not remove the need for sign-in. Users inside the network still authenticate, and the same resolver rules apply. Private placement is a layer that sits beside a sign-in choice, not a replacement for one.
- Reach: only hosts on the permitted network path can connect, so scanners and internet traffic cannot touch the portal directly.
- Identity: keep a built-in provider or proxy for sign-in, since network position alone does not identify a person.
- Run: your team owns routing, DNS, VPN or access-broker configuration and the firewall rules that enforce the boundary.
- Operational cost: remote staff and integrations such as CI runners need a supported path in, which must be planned and reviewed.
Confirm which networks and integrations must reach the portal, and that the boundary is enforced by rules you have tested from outside it.
How to build the checklist for your own portal
This sequence turns the general threat model into a checklist that matches your installed plugins, integrations and network layout, with a named owner and a verification step for every control.
Inventory installed plugins and integrations
Start by listing everything the running portal touches: each plugin in the frontend and backend packages, every catalog provider, scaffolder action, URL reader host, authentication provider, database, cache and external API token. Record the package name, version, the team that installed it and where its configuration lives. Include plugins that were added for a single pilot and never removed. The step is done when the list matches what is deployed, which you can confirm by comparing it with the dependency tree of the app repository and the live backend configuration.
Assign a trust level to each item
Classify every inventory entry by how much it can do and who can influence it. Typical levels separate first-party code your team wrote, vetted third-party plugins, community plugins with unclear maintenance, and content supplied by users such as templates, catalog descriptors and documentation sources. Mark anything that holds credentials or can make outbound requests as higher risk. The output is a table with one trust level per entry and a short reason. Check it by asking a second engineer to pick three random entries and confirm the level without seeing your reasoning.
Review the threat model against your deployment
Read the threat model maintained in the Backstage repository and map each section to your inventory. Note where your deployment matches the assumptions, for example whether the portal is reachable from the public internet, whether guest sign-in is enabled, or whether templates run on a shared host. Record every assumption that does not hold as a gap. The review is complete when each threat category has either a matched control or a documented gap, and a reviewer has signed off the mapping.
Write one checklist item per control
Convert each gap and each applicable control into a checklist item with four fields: the control, the affected inventory entries, a named owner and the verification step. Owners should be people or teams who can change the configuration, such as the platform team for proxy settings or the security team for audit log shipping. Keep items specific enough to test, for example a stated allowed-host list or a stated disabled provider, rather than a general aim to improve security. The checklist is ready when every item has an owner who has accepted it in writing.
Run the checks before go-live
Execute each verification step against a production-like instance before the portal receives real users. Use a test identity to confirm that guest access is off, try a blocked host through a URL reader, confirm that a disallowed catalog kind cannot be registered and check that audit events reach the log store. Record the result, the tester and the date for each item. Any failed item blocks go-live until the owner fixes it or the risk is accepted by the person named in the checklist. The output is a signed-off run record.
Repeat the checks on every upgrade
Rerun the checklist whenever you bump Backstage packages, add or remove a plugin, change the Node.js version or alter identity providers. Compare the new inventory with the previous one, because upgrades can add default routes or change defaults that the earlier checks relied on. Review the security advisories and backport notes for the release line you run, and treat any item that depends on a changed default as reopened. The step is complete when the run record for the new version is filed alongside the previous one.
Questions operators ask about the Backstage threat model
Does the Backstage project publish a threat model, and where do I read it?
Check the project's current documentation and repository for threat model or security material, and record the version you read, because location and wording change between releases. Start with the backstage/backstage repository and the Backstage documentation, then search for security, trust boundary and threat model topics. Treat the project's material as the starting list for your own checklist. Add items for your network design, identity provider, storage, plugin set and internal templates, since no generic model can know those. Where the project's material is thin for an area you depend on, record that gap as an open item for your review.
Who owns each item on a Backstage hardening checklist?
Assign each item to one accountable team before work starts, because unowned items tend to stay open. Typically the platform team owns deployment, network exposure, patching, upgrades, token signing keys and secrets storage. The identity team owns sign-in providers and resolvers. The security team owns plugin approval, permission policies, audit log review and the SIEM feed. Application or plugin owners own their custom plugins, templates and actions. The catalog owners own registration rules and trusted data sources. Your organization's split will differ, so record each owner, the review cadence and the evidence that proves the control works.
Is guest access acceptable for Backstage outside development?
No. The Backstage authentication documentation advises against offering guest access in production. Guest sign-in is useful for local development and evaluation, but a production portal should require sign-in through a real identity provider. Configure sign-in resolvers so every provider you enable resolves to the same user identity, which prevents one person from appearing as several catalog users. Then confirm that guest sign-in is disabled in the production configuration, and keep that setting in version control so a later change is visible in review. Ask your identity team to test sign-in with a user who has no catalog entry to confirm the resolver behaves as you expect.
How long do Backstage security fixes take to reach a release?
The versioning policy says high and critical severity vulnerabilities will always be backported to releases from the last six months where feasible, and other security fixes may be backported. That means you must stay within that window to receive the backport, so plan upgrades as a recurring task rather than a one-time project. The policy describes a main release line shipped monthly and a next release line shipped weekly, so a monthly upgrade rhythm keeps you current with minimal drift. Confirm the current policy text before you set your own deadlines, and track the security advisories for the packages your deployment uses.
What should I do about Backstage plugins from outside the project?
Vet each plugin before installation, because the project's backport commitment covers its own packages, not every community plugin. Check who maintains the plugin, how recently it was updated, which Backstage versions it supports, and which external services it calls. Review what permissions and tokens it asks for, and whether it exposes routes or proxies to upstream APIs. Pin versions, install through your normal change process, and keep an owner for each plugin who tracks its advisories. Expect some third-party plugins to lag behind core upgrades, and decide in advance whether you will fork, replace or remove a plugin that stops keeping pace.
What drives the cost and effort of a Backstage threat model review?
The main drivers are the number of plugins you run, the number of integrations with source control, identity, cloud and ticketing systems, the complexity of your sign-in setup, and how much internal review capacity you have. Each additional provider, custom plugin or scaffolder action adds checks, and each integration adds credential handling to review. Your own capacity matters because a review stalls when owners cannot answer questions or approve changes. Ask any partner for a quote that lists each component: discovery, configuration review, testing, remediation support and handover, and whether each is one-time or recurring. No price is given on this page, so the figure depends on your written scope.
Can DeployOpen review a Backstage deployment against this checklist?
DeployOpen plans, implements, hardens and supports self-hosted open-source platforms in your own cloud accounts, data centers or air-gapped networks, and it runs security testing for applications, APIs and infrastructure. A review of a Backstage deployment against a checklist like this one can be quoted from a written scope that names the systems, the checklist items and the deliverables. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. DeployOpen prepares systems and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications, so independent auditors and certification bodies still perform those steps.
Operational controls to confirm before production
These controls sit outside the Backstage code itself, in logging, key handling, secret storage, patching and catalog governance. Each one needs an owner in your organization before the portal serves real users. Confirm each card against your own environment and record who approved it.
Audit logging and SIEM shipping
Security-relevant events in Backstage, such as sign-ins, permission decisions and catalog changes, need a destination that your security team monitors. Confirm which plugins emit audit events in the Backstage version you run, which severity levels reach your SIEM, and how long your retention policy keeps them. Ask the security operations lead to sign off on the event list and on who receives alerts for failed or unusual sign-ins.
Token signing key persistence
Backstage signs tokens that services use to trust each other, so the key material must survive restarts and be stored where only the platform team can read it. Confirm that keys are configured as static key stores rather than generated at startup, that private keys sit in a secrets store with restricted access, and that a documented rotation procedure exists. The identity or platform lead should sign off, with a named person who can execute rotation during an incident.
Secrets outside configuration files
Integration tokens for source control, identity directories and cloud accounts should never be committed to app-config files. Confirm how each secret reaches the running container, who can read the Kubernetes Secret or external secrets manager entry, whether encryption at rest is enabled for the cluster, and how a token is rotated without downtime. The security lead signs off on the secret inventory, and each token owner is named in that inventory.
Patching on the release cadence
Backstage ships a main release line monthly and a next release line weekly, and high and critical vulnerabilities are backported to releases from the last six months where feasible. Your patch process should follow that cadence, so an upgrade window and a named owner exist before the portal goes live. Confirm that Node.js versions match the two supported releases for your Backstage version, and that third-party plugins are patched on the same schedule. The platform owner signs off on the window and on the rule for emergency patches.
Catalog registration limits
If anyone can register Users, Groups or Templates, the catalog stops being a trusted inventory and starts reflecting whatever a contributor adds. Confirm which entity kinds each location can create, who can create and delete entities through permission policies, and whether read-only mode is needed for imported organizational data. The catalog owner and the compliance lead should sign off, because audit evidence built from catalog data depends on these limits.
How DeployOpen applies this checklist to a live portal
DeployOpen works through this checklist against your running Backstage portal under a fixed-scope engagement, with the scope, deliverables and timelines agreed in writing before any work starts. The written scope names which checklist items are covered, such as trust levels, network exposure, URL reader allow-lists and audit logging, and which are excluded, so there is no ambiguity about what the review did and did not examine. Your team keeps ownership of every item. Each row of the checklist is assigned to a named person on your side, and that person signs off the findings and the changes before they are considered closed. DeployOpen prepares the evidence and the recommendations; it does not sign off on your behalf or issue any audit report or attestation.
To make the review specific, you supply three inputs before work begins: an inventory of installed plugins, including any custom or community plugins and the version each runs, so that plugin vetting can be checked against real code rather than assumptions; the details of your identity provider configuration, including the sign-in resolvers, the providers enabled and whether guest access is still on; and a test environment that mirrors production closely enough to exercise the scaffolder, the proxy and the URL readers without touching live integrations or live data. Ask us to confirm early which of these you can provide, because gaps in the plugin inventory or the test environment are the most common reasons a review stalls.
Once the one-time review is complete, ongoing checks can be provided under a retainer. A retainer is useful because the checklist is not static: new plugins arrive, Backstage releases change defaults, and advisories require patching within the backport window described in the release policy. Ask any provider to state in the quote what recurs (periodic re-review, advisory triage, patch validation), what is one-time, and who performs each activity. Your own owners should remain responsible for approving changes to production configuration, and the retainer should make that split explicit in writing.
Backstage security hardening questions buyers ask
How much does it cost to harden a Backstage threat model checklist?
The cost depends on the written scope, not on a standard rate. DeployOpen works from a fixed scope agreed in writing before work starts, and a quote follows from that scope. The main drivers are the number of plugins to vet, how many auth providers and identity sources you run, whether scaffolder templates run on the host, how many upstream APIs sit behind the proxy, and whether audit events must reach a SIEM. Ask for the quote to split one-time work (threat model review, configuration changes, sign-in resolver design, key setup) from recurring work (patching, advisory tracking, periodic review). Backstage itself is open source under the Apache License 2.0, so the spend is services and internal staff time, not licenses.
How long does a Backstage hardening review take?
Duration follows the number of items in scope and how many teams must make decisions. A review that covers only the configuration of one instance moves faster than one that also vets third-party plugins, rebuilds sign-in resolvers and wires audit logs into a SIEM. Ask for a timeline in the written scope with milestones for each checklist area and the points where your security, platform and identity teams must sign off. No duration is stated here because none has been supplied for this work.
What do we need to provide before a Backstage hardening engagement starts?
Plan to provide access and decisions, not just documents. The inputs usually include the app-config files for each environment, the list of installed plugins and their versions, the auth providers and sign-in resolvers in use, the catalog locations and who may register entities, the scaffolder templates and actions, the upstream APIs reached through the proxy, and the logging and SIEM destinations. You will also need named owners for each control area and a staging environment where changes can be tested before production.
Can our own platform team harden Backstage without a partner?
Yes, if the team has the time and the skills to read the threat model, test configuration changes and maintain them after each upgrade. The Backstage project publishes its versioning policy and upgrade guidance, so a capable team can start there. A partner adds most value on the items that need cross-team decisions, such as who may create Users, Groups and Templates, how URL readers are allow-listed, and how plugins are vetted before installation. Ask whether your team will own the result after handover and what documentation you will receive.
Who owns each item on the Backstage hardening checklist?
Ownership should be written into the checklist before work starts. Platform engineering usually owns network exposure, deployment, keys and secrets. Identity teams own auth providers and sign-in resolvers. Security owns the threat model, audit logging, plugin vetting approval and advisory tracking. Template authors and catalog maintainers own the content they publish, within limits set by the platform team. Each item should name one accountable owner and a review cadence so that gaps do not sit between teams.
What are the ongoing costs after the hardening work is done?
Recurring work includes applying Backstage releases and security fixes, reviewing new or updated plugins, rotating keys and integration tokens, reviewing permission policies after catalog changes, and checking audit output. The Backstage versioning policy says high and critical vulnerabilities are backported to releases from the last six months where feasible, so an instance that falls behind that window must move to a supported release. Ask whether a retainer covers upgrades and continuous testing, and what is excluded.
Does a hardening review make Backstage certified for an audit?
No. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications. Independent auditors and certification bodies perform those assessments. A hardening review helps your team show how the portal is configured, who controls it and what evidence exists, which is useful input for whichever assessment you face.
How DeployOpen works on this
DeployOpen starts from your Backstage deployment and works through the threat model areas that apply to it, turning each into an owned, testable checklist item. The result is a written scope, a configured and verified portal, and documentation your platform team can run after handover.
How we scope
- We review your app-config files, plugin list, auth providers and network exposure before agreeing what the engagement covers.
- We record which trust levels, plugins and URL readers are in use, so the checklist reflects your real deployment.
- We agree in writing who owns each checklist item, whether your team, DeployOpen or a shared task, before work starts.
How we build
- We apply hardening changes to configuration, sign-in resolvers, permission policies and reader allow-lists in your own environment.
- We test each control with requests that should fail, such as blocked hosts, unauthorized catalog writes and guest sign-in attempts.
- We vet installed plugins and scaffolder actions against the checklist and record any that need restriction or removal.
How we hand over
- We deliver a completed checklist mapping each control to its owner, its configuration location and its verification steps.
- We document how to patch Backstage and its dependencies within the backport window the project describes for high and critical fixes.
- We walk your platform and security teams through audit log routing, key storage and the steps for rotating secrets.
How we support
- Ongoing support, upgrades and continuous security testing are available as retainers after the initial engagement.
- We can re-run the checklist after each Backstage release line upgrade to confirm that earlier controls still hold.
- Ask any provider to confirm which checklist items they will verify in your environment and which remain with your team.

