OpsLevel vs Backstage

OpsLevel is a managed developer portal with rubrics and integrations built in. Backstage is an Apache-2.0 framework you host and extend yourself. The right choice depends on how much platform engineering you can staff and where your data must stay.

On this page

Which fits your team: OpsLevel or Backstage

If your OpsLevel renewal, a pricing change or a data residency rule has forced the question, start with who will run the portal. OpsLevel fits teams that want a maintained product with rubrics and integrations out of the box, and Backstage fits teams that will staff a platform group to build and run the portal. Both can produce a service catalog with ownership and checks, but the amount of work after day one differs sharply. Before comparing features, count the engineers you can commit to the portal for the long term, not just the launch.

Three factors usually decide the matter. The first is platform engineering capacity: Backstage is an open framework, so someone must own plugin selection, upgrades and the catalog schema. The Backstage versioning policy describes a monthly main release line and a weekly next line, and high and critical vulnerabilities are backported only to releases from the last 6 months where feasible, so an unstaffed instance falls behind quickly. The second is network isolation. OpsLevel's self-hosted edition needs a license file and an instance reachable over the internet for push-based integrations, while Backstage can run inside a closed network. The third is whether the self-hosted OpsLevel license and its minimum specifications (16 CPU, 16 GB of memory, and 120 Gi of disk for production) change the picture. Ask OpsLevel in writing whether its self-hosted license would still require internet reachability for your integrations, and whether it fits your residency rules.

Run a short test before you decide. Ask your current OpsLevel team to export a sample of services, owners and checks, then have two engineers draft the same ten entries as catalog-info.yaml files and estimate the effort to keep them accurate each quarter. Confirm with each vendor which integrations you rely on are supported in your deployment model, because a self-hosted commercial edition still carries a vendor license. If the rubric and integration gaps are small and your network can accept outbound-only integrations, a managed OpsLevel contract may be the lower-risk choice. If you have a platform group and a hard isolation requirement, plan for Backstage with a named owner from the start.

Which option fits which scenario

This table matches common situations to the option that fits best and explains why. Read each row against your own team size, network controls and existing tooling, then check the open items with the vendor or your own environment before deciding.

ScenarioBetter fitReason
Small team with no platform groupOpsLevel (SaaS)Backstage needs someone to own upgrades, plugins and hosting, and its main release line ships monthly, so a team without that capacity carries ongoing work. A managed catalog moves that maintenance to the vendor, though you still pay a subscription.
Regulated organization needing isolated networksBackstage, or a self-managed edition if the vendor allows itOpsLevel's self-hosted edition requires a license file from OpsLevel and runs on Kubernetes or a VM with the instance reachable over the internet for push-based integrations. Confirm with OpsLevel whether that reachability requirement can be met inside your isolated network before choosing it.
Team with an existing Backstage buildBackstageYour catalog-info.yaml files, templates and plugins already live in your own infrastructure under an Apache-2.0 license with no paid edition from the project. Staying on it avoids a parallel catalog and a second set of ownership data to keep accurate.
Team that wants rubrics without custom codeOpsLevel (SaaS)OpsLevel provides maturity rubrics and checks as product features. Backstage offers Tech Insights checks, but you will build and maintain the facts and rules yourself, which takes platform engineering time.
Team with a standards-heavy catalogDepends on the standards you trackBackstage's API entities can carry OpenAPI, AsyncAPI, GraphQL or gRPC definitions and it supports custom kinds, which suits teams that model many systems. Confirm whether OpsLevel's data model covers your standard types before you commit.
Team that must stay on current Node.js and security patchesBackstage with a funded upgrade ownerBackstage supports two adjacent even-numbered Node.js releases and backports high and critical vulnerabilities to releases from the last 6 months where feasible. Someone must apply those upgrades on a regular schedule.

How Backstage catalog descriptors compare with OpsLevel's ownership model

In Backstage, ownership is declared in catalog-info.yaml files that sit in each repository, so the record of who owns a component lives next to the code it describes. A descriptor declares an entity with a kind such as Component, API, Resource, System, Domain, Group, User, Template or Location, and fields such as spec.owner link a component to the team that runs it. API entities can carry an OpenAPI, AsyncAPI, GraphQL or gRPC definition, so the interface contract is catalogued with the service. The Backstage catalog then ingests these files through Location entities or registered URLs. Before you plan a migration, confirm the exact kinds and fields your Backstage version expects in the descriptor format documentation.

The main tradeoff is where edits happen. Descriptors are reviewed in pull requests, versioned in Git, and changed by the teams that own the code, which suits organizations that already enforce code review and want ownership changes to be auditable through commit history. The cost is that someone must keep descriptors present and correct in every repository, and a missing or stale file leaves a gap until a platform team notices. A managed catalog like OpsLevel centralizes ownership and service records in the product, usually edited through its interface, API or integrations. That reduces repository-level work but moves the source of truth into a vendor system. Confirm OpsLevel's current model, including how it maps services to repositories and where its ownership data can be exported, against its current documentation before deciding which records need to be rebuilt as descriptors.

Plan for the descriptor model as ongoing work, not a one-time import. Decide early whether ownership changes will be made by pull request in each repository, by a platform team through a generated or templated file, or by a combination, and assign who answers for descriptor drift. Validate descriptors in continuous integration so malformed files fail a build instead of silently dropping an entity. Set a sign-in and resolver policy so owner references resolve to real groups, since a catalog that cannot match spec.owner to a known Group produces ownership gaps that look like missing teams. The effort to maintain these files scales with repository count and how often teams reorganize, so measure both before committing.

Where your data lives and who controls the platform

Each option places the catalog, its credentials and its integration traffic in a different location, and each has a different owner for upgrades and access. The cards below cover the decisions that follow from that split, so you can check them against your residency rules and your sign-in design before you compare features.

OpsLevel multi-tenant SaaS

OpsLevel's default model is a multi-tenant SaaS service, so OpsLevel operates the hosting, upgrades and availability. Your service, team and ownership data sits in the vendor's environment, and your team's control is limited to configuration, access roles and integration scopes. Ask the vendor where each tenant's data is stored, which regions are available, how backups are kept, and how data is deleted at contract end.

OpsLevel self-hosted through Replicated

The self-hosted edition is installed through Replicated and requires a license file from OpsLevel, so the subscription continues even though the instance runs in your environment. OpsLevel documents Kubernetes as the preferred host, with a VM as an alternative. Push-based integrations need the instance to be reachable over the internet, which can conflict with a tightly controlled network. Confirm this with your network team before you plan a design.

Backstage in your own cloud or data center

Backstage runs as an application you deploy, so the catalog, TechDocs output and plugin data stay wherever you place its PostgreSQL database and backend. The project is Apache-2.0 licensed with no paid edition from the project itself, so no vendor license file gates the software. You own the hosting, patching, Node.js runtime support and access control. Confirm that your cluster or data center can reach your source hosts and identity provider without opening inbound paths to the internet.

Data location and residency

Residency depends on where catalog records, integration tokens and documentation artifacts are stored, not only on the product name. With SaaS, ask for the regions of processing and storage, subprocessors and any cross-border support access. With self-hosting, the location follows your own deployment, but the vendor license check or integration callbacks may still send data outside your network. Map each data flow in writing before you accept a residency statement.

Sign-in resolver design

Backstage ships 19 built-in authentication providers, and each one can resolve a user to a different identity unless you configure resolvers. Map every provider to one identity model so a person signing in through GitHub and through your corporate directory lands on the same catalog User entity. Avoid guest access in production, as the authentication documentation advises. OpsLevel users are managed through its own identity and role settings, so compare how each option handles ownership and offboarding.

Compliance evidence and auditor roles

DeployOpen can help prepare systems, controls and evidence for a compliance assessment, including access reviews, change records and backup configuration for either platform. DeployOpen does not issue audit reports or certifications, and independent auditors decide whether the evidence meets your control requirements. Ask your auditor early which platform records, logs and vendor reports they will accept, and whether a SaaS provider's own assurance reports cover the parts you rely on.

Hosting models for OpsLevel and Backstage

In the multi-tenant model, OpsLevel runs the catalog application, its data stores and its upgrades. Your team connects source control, CI and cloud accounts, defines teams and ownership, and configures rubrics and access for engineers. Nothing about the portal itself lives in your network, so the main decisions are about data location and integration paths.

  • What your team runs: the integrations and their credentials, the catalog configuration, team and ownership data, and rubric definitions.
  • What the vendor runs: the application, hosting, databases, upgrades and availability of the service.
  • Network reachability: the portal needs no inbound endpoint in your network. Confirm with OpsLevel how its integrations reach your tools, and which outbound addresses or ranges you must allow through firewalls and proxies.
  • Infrastructure needed: a browser, your identity provider for sign-in, and whatever agents or runners your integrations use. You do not provision cluster capacity for the OpsLevel application.
  • Data location: confirm the hosting region, data residency commitments and subprocessors in writing before you sign.

Ask for the data export options and the exit terms, because these decide how hard a later move would be.

How to keep Backstage current without falling behind

Keeping Backstage current is a recurring operating cost that a self-hosted team carries itself, so the first decision is who owns the upgrade calendar. Backstage's main release line ships monthly, on the Tuesday before the third Wednesday of each month, and the next release line ships weekly on Tuesdays, according to the Backstage versioning policy. A team that wants to stay on the main line needs a named owner who reviews each monthly release, reads its notes for breaking changes to plugins and the app-config.yaml keys in use, and schedules a staging upgrade before production. Backstage also expects you to track its plugin packages, which can move at a different pace than the core, so plan time for dependency bumps in your custom plugins as well.

Security fixes add a second clock. The versioning policy says high and critical severity vulnerabilities will always be backported to releases from the last 6 months if feasible, and other security fixes may be backported. That backport window only helps a team that is already on a supported release, so falling more than six months behind can leave you with a fix you cannot pick up without a larger jump. The runtime also has to keep pace: Backstage supports exactly two adjacent even-numbered Node.js releases, and as of Backstage 1.46.0 these are Node.js 22 and 24. Confirm the currently supported Node.js pair on the versioning policy page before you build your container image, and budget a separate check whenever Node.js moves.

OpsLevel moves this work to the vendor on its multi-tenant SaaS, so upgrades to the service are not on your calendar. A self-hosted OpsLevel edition is different, because it is installed through Replicated and the upgrade path is governed by the license and the vendor's release process, so confirm with OpsLevel how and when that edition is updated in your cluster. For a self-hosted Backstage portal, the Backstage guidance on keeping Backstage updated describes the upgrade steps to plan around. As a reference point only, the Backstage releases page listed v1.55.3 as the latest release, with 1.56.0 in the next line. Check that page on the day you plan, since the current version will have moved on.

What each option costs to run, by component

Both options carry a recurring line for the platform itself and a recurring line for the people who keep it current. The difference is which costs appear on a vendor invoice and which appear on your own budget, so the cards below separate them by who gets paid and what recurs.

OpsLevel subscription and onboarding

OpsLevel is a commercial product, so the main recurring cost is the subscription, which is quoted rather than published here. Ask whether pricing is per developer, per service or a platform fee, whether the quote covers SaaS or the self-hosted edition, and whether any one-time onboarding or implementation fee applies. Confirm how the price changes as headcount and service count grow, and what happens to the subscription at renewal.

Self-hosted edition license and infrastructure

Running the OpsLevel self-hosted edition still requires a license file from OpsLevel, so the subscription does not disappear. Infrastructure is your cost: OpsLevel documents a minimum of 16 CPU, 16 GB of memory and capacity for at least 20 pods, with 24 Gi of disk for pilots or 120 Gi for production. Ask whether the license price changes with the deployment size and whether support for Replicated-based installs is included.

Backstage hosting and database

Backstage has no license fee, so its recurring costs are the compute, storage and database that run it. Backstage uses PostgreSQL in production, with a separate logical database per backend plugin, and a cache such as Redis. Costs rise with the number of catalog entities, plugin count and sign-in traffic. Size these in your own cloud account and include backups, high availability and log storage in the estimate.

Build, plugin and integration development

This is the largest one-time cost on the Backstage side. Teams build the app, configure the Software Catalog and Software Templates, connect source control, CI/CD and cloud accounts, and write custom plugins for anything the built-in set does not cover. Estimate this as engineering time from your own platform team or a fixed-scope implementation partner, and request a written scope that lists each integration before work starts.

Upgrades and version maintenance

Backstage ships a monthly main release line and a weekly next line, so upgrades are a recurring task. The versioning policy backports high and critical vulnerability fixes to releases from the last 6 months where feasible, which means you must stay within that window. Plan a recurring upgrade cycle, track supported Node.js versions and budget time for plugin breakage on every upgrade. Ask any implementation partner whether upgrades are priced as a retainer or as project work.

Security testing, support and ownership

Backstage is Apache-2.0 licensed with no paid edition from the project, so commercial support comes from a vendor or partner if you want it. Authentication design, sign-in resolver configuration and disabling guest access in production need review and testing, and the portal's catalog data should be checked for accuracy as it grows. Ask for a written support scope with response expectations, and decide who owns the plugin code after handover.

What moving from OpsLevel to Backstage involves

The sequence moves ownership, service and check data out of OpsLevel and into Backstage descriptors and checks, with both systems running side by side until the catalog is verified. The result is a Backstage catalog your teams can trust before OpsLevel is switched off.

  1. Inventory services, teams and checks

    Before exporting anything, the platform team lists what OpsLevel holds: services, teams, owners, tiers, dependencies and every rubric check, with the teams that rely on each one. Someone from platform engineering leads this, with service owners confirming their entries. It is done when the inventory has a count of services and checks that both sides agree on, and each rubric has a named owner who will review its replacement.

  2. Export data through the OpsLevel CLI or API

    Pull the inventory out of OpsLevel using the MIT-licensed CLI with its Terraform export or JSON and CSV output, or the GraphQL API if you need custom fields. Plan for paging and rate limits when the catalog is large, and keep the raw exports under version control so each later comparison has a fixed source. It is done when the exports load cleanly into a scratch workspace and the record counts match the inventory.

  3. Convert ownership data to catalog-info.yaml

    Translate each service into a catalog-info.yaml descriptor with the right kind, owner reference and system relationships, and place the file in the repository it describes. Ownership fields need the most attention because Backstage resolves them against Group and User entities, so the platform team must confirm team names and group membership before bulk conversion. It is done when every converted entity validates and each owner resolves to an existing group.

  4. Replace rubric checks with Backstage checks

    Translate each OpsLevel rubric check into a Tech Insights fact and check, or keep it as a documented manual review where the signal cannot be read automatically. Some checks will map cleanly and others will need new data sources, so expect review cycles with the teams that own the rubrics. It is done when every check has a Backstage equivalent or a recorded decision to drop it, and the team-level scores can be compared against the OpsLevel results for the same services.

  5. Run both systems in parallel

    Keep OpsLevel active while Backstage shows the same ownership and check results. Service owners review their entries in Backstage and report mismatches, and the platform team fixes the descriptors or the sync that produced them. Parallel running is the only reliable way to catch stale ownership, missing services and checks that give different results. It is done when the discrepancy list is empty or each remaining item has an agreed fix and an owner.

  6. Cut over and retire the OpsLevel tenant

    Point teams, notifications and any automation that reads from OpsLevel at Backstage, then confirm that every workflow has moved. Export a final copy of the OpsLevel data for your records and check your contract terms for the exit and data return steps before you cancel anything. It is done when no active process depends on OpsLevel, the final export is archived, and the subscription end date is confirmed in writing with the vendor.

Questions buyers ask before choosing Backstage or OpsLevel

Does self-hosting OpsLevel remove the subscription?

No. OpsLevel's self-hosted edition is installed through Replicated and requires a license file from OpsLevel, so the commercial subscription stays in place even when the instance runs in your own cluster. What changes is where the data and the runtime live. Ask OpsLevel for the license terms, the renewal mechanics and what happens to the instance if the license lapses. The self-hosted documentation also lists minimum specifications of 16 CPU and 16 GB of memory, with capacity for at least 20 pods and 120 Gi of disk for production, so include that infrastructure in your comparison. Also confirm that the instance must be reachable over the internet for push-based integrations, which matters for isolated networks.

How long does a Backstage build take, and what drives it?

No reliable duration can be given without scoping the work, because the effort depends on your catalog size, the number of integrations, the templates you need and the plugins you must build or maintain. Start by listing the systems that hold ownership data, the entity kinds you will model from Backstage's descriptor format, and the authentication provider you will use. Then ask for a fixed-scope plan with deliverables and a timeline agreed in writing before work begins. Each added integration, custom plugin or migration of existing OpsLevel checks extends the schedule, so treat them as separate line items.

Can our team run Backstage without outside help?

A team with platform engineering experience and TypeScript or React skills can build a Backstage portal in-house, but it needs ongoing ownership of the codebase, not a one-time setup. Backstage's versioning policy describes a main release line shipped monthly and a next line shipped weekly, and high and critical vulnerabilities are backported to releases from the last six months where feasible. Someone must track those releases, supported Node.js versions and plugin changes. Assess whether you have that capacity before committing, and consider a scoped engagement for the initial build with a clear handover.

What does a Backstage portal need from our engineers and platform team?

It needs named owners for the catalog, the templates and the plugins, plus people who maintain the hosting platform. Engineers must add catalog-info.yaml descriptor files to their repositories, and TechDocs expects Markdown documentation kept next to the code it describes. The platform team handles PostgreSQL for production, caching, authentication configuration and upgrades. Authentication needs care: the documentation advises sign-in resolvers so every provider resolves to the same identity and no guest access in production. Agree these responsibilities before the build starts so ownership data stays accurate after launch.

What are the main cost drivers for each option?

For OpsLevel, the recurring cost is the vendor subscription, which remains even when self-hosted, plus the infrastructure for the minimum specifications. For Backstage, there is no license fee from the project, since it is Apache-2.0 licensed with no paid edition, but you pay for hosting, the initial build, plugin development, upgrades, and staff time to maintain them. Costs rise with the number of integrations, custom plugins, authentication providers and environments. Ask any vendor or partner for a quote that separates one-time build work from recurring hosting, upgrade and support work.

How does Backstage handle identity and single sign-on?

Backstage ships 19 built-in authentication providers, including GitHub, GitLab, Google, Azure, Okta, Auth0 and generic OIDC, so most corporate identity sources can be connected without custom code. The critical design step is the sign-in resolver. Configure resolvers so that every provider maps to the same user identity, otherwise the same person can appear as several catalog users and ownership data becomes unreliable. Confirm which provider your identity system supports in your Backstage version and disable guest access in production.

Can DeployOpen run our Backstage portal after launch under a retainer?

Yes. DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure, and ongoing support, upgrades and continuous testing are available as retainers. The initial build is typically agreed as a fixed-scope engagement with scope, deliverables and timelines set in writing before work starts. Ask for the retainer scope in writing, including which Backstage upgrades, plugin maintenance and security patching it covers, and how upgrade windows are scheduled with your teams.

What to confirm before you commit

Start with the network model, because it decides which edition and hosting path are even possible. OpsLevel's self-hosted edition, installed through Replicated, needs a license file from OpsLevel and expects the instance to be reachable over the internet for push-based integrations. If your catalog sources sit on isolated or tightly controlled networks, confirm with OpsLevel in writing whether that reachability requirement can be met, and what changes if it cannot. Backstage has no license dependency, so the same question for it is about where you will host the portal and its PostgreSQL database, and how your identity and source systems reach it. Also confirm the identity providers your engineers already use. Backstage ships with 19 built-in authentication providers, but the authentication documentation advises configuring sign-in resolvers so every provider resolves to one identity, and against guest access in production. Map each provider to a single user record before you choose a product, because that mapping is the work most often underestimated.

Next, count your services, teams and ownership records, and decide whether existing rubric checks must carry over. Pull the numbers from your current OpsLevel tenant rather than estimating them, and note how many services have no owner today. Ask whether rubric results need to survive the move as historical data or only as current state. OpsLevel's rubrics and checks do not map one-to-one onto Backstage, so a migration that promises identical scoring needs a check-by-check review that the platform team signs off on. Then assess your internal staff. Name the people who will own the platform group, the plugin upgrades and the Backstage release cadence, which the versioning policy describes as a monthly main line plus a weekly next line. If the answer is one part-time engineer, that is a finding in itself, and it should shape the choice more than the feature list does.

Finally, ask for the cost of the self-hosted license and the infrastructure in your own environment, as separate line items. For the OpsLevel self-hosted edition, request the subscription terms for the license file, the Replicated arrangement, and the minimum of 16 CPU and 16 GB of memory that the self-hosted documentation lists, along with the storage figure for production. For Backstage, the license is zero, so the cost is the infrastructure, the build and plugin maintenance, and the people who run them. Ask each vendor, and each implementation partner, to state recurring and one-time costs separately, and to show what drives them up, such as seat count, service count, environment count and upgrade effort. Do not accept a single annual figure without that breakdown. A written scope with named deliverables is the only reliable basis for comparing the two quotes.

How DeployOpen helps evaluate, implement or migrate

DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted open-source platforms inside your own infrastructure. For OpsLevel vs Backstage, we start with a written scope that fixes what is compared, built and handed over, so the decision rests on your ownership data, your network rules and your platform team's capacity.

How we scope

  • We inventory your current OpsLevel services, teams, ownership fields and maturity checks before any comparison.
  • We agree in writing which catalog kinds, integrations and rubric checks move to Backstage and which stay out of scope.
  • We confirm where Backstage would run, including cloud accounts, data centers or air-gapped networks, and which identity provider it will use.

How we build

  • We stand up a Backstage instance with PostgreSQL, catalog ingestion from catalog-info.yaml files and your chosen authentication providers.
  • We convert ownership and service metadata, configure sign-in resolvers so each provider maps to one identity, and disable guest access.
  • We test catalog accuracy, plugin behavior and upgrade paths against the Backstage release line you select, then document the results.

How we hand over

  • You receive architecture documentation, runbooks for upgrades, backups and catalog maintenance, and the configuration under your control.
  • We walk your platform and service owner teams through ownership rules, template and TechDocs authoring, and how to review catalog changes.
  • We prepare a cutover plan that keeps ownership data current during the switch, with a rollback path agreed before go-live.

How we support

  • Ongoing support, upgrades and continuous testing are available as a retainer, scoped separately from the initial engagement.
  • Retainer work can track Backstage monthly and weekly release lines, security backports and Node.js version changes.
  • Ask any provider, including DeployOpen, to confirm the support hours, response commitments and upgrade scope in writing before you sign.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.