This guide was last updated on June 2, 2025.
Comparison Guide
What to expect?
This comparison is broken out not just by feature or function, but by the steps required to successfully roll out an IDP and affect material improvements to your engineering organization.
For each of these steps, the comparison document provides an overview of why it matters, the requirement set, a TL;DR, and a detailed breakdown.
Step 1
Import your data & build your catalog
Step 2
Define ownership
Step 3
Create your first 3 Scorecards
Step 4
Deliver your first self-service experience
Step 5
Extend the IDP and make it your own
Step 6
Run an org wide initiative
Step 7
Measure & improve
Step 8
Make your engineering team happy
Note from the Founders
When we set out to build Cortex, we were solving a problem that we faced as engineers, and our personal product philosophy along with the feedback from users who felt Cortex was the right fit for them are the things that drive how our product works.
We’re tired of B2B SaaS compare pages that are so horribly biased that don’t actually serve any purpose. It’s always the same – one column with green checks, and the other with vague indicators of missing features that verge on being outright lies. The reality is that competing products are similar in many ways, but different too, having strengths and weaknesses depending on what the user cares about.
We hope that this comparison page is meaningful and actually helps you decide which product is the right one for you – and of course, we hope it’s Cortex!
Cortex Founders
Cortex vs Backstage: Comparison overview
We’ve broken down the comparison by the steps involved in building, rolling out, driving adoption, and measuring the impact of your Internal Developer Portal with details so you can better understand our perspective on how we compare.
Cortex is a fully-baked IDP that starts delivering value on day 1. Backstage is a framework to build an IDP that requires ongoing investment, not an IDP.
Even the official FAQs stresses that Backstage “is not a packaged service that you can use out of the box.”
Cortex achieves org-wide adoption.
Backstage averages just 9% adoption across orgs.
Cortex is for all engineering stakeholders – engineering leadership, developers, platform engineers, and more.
Backstage focuses more narrowly on Platform Engineers and developer experience.
Cortex starts the IDP journey with service ownership – clear ownership and accountability is the foundation for a successful IDP.
Backstage treats ownership as secondary.
Build your IDP with Cortex
See why Canva, Skyscanner, EarnIn, and more companies chose Cortex over Backstage
Compare the journey of building an IDP
Step 1
Import your data & build your catalog
Why it matters
The foundation of your IDP is the data in it, including the catalog, integrations, and data model. The accuracy, completeness, and trust in this data is critical when it’s used to drive org-wide initiatives like Production Readiness, security compliance, migrations, and more.
Requirements
Catalog services & infrastructure
Connect all tools in your engineering stack
Model your engineering data ecosystem (like product areas, systems, lines of business, etc)
TL;DR
Both Cortex and Backstage provide a customizable entity data model. Cortex is more opinionated, with flexibility when needed. Backstage lets you build your own entity providers, but scale depends on how well you build and maintain those homegrown providers. Each community plugin you adopt becomes your responsibility to update and maintain.
Full comparison
Vendor supported Integrations
Built in, first class integrations – drop an API key, we handle the rest.
Live data, both push and pull. View current oncall, live health metrics, and more in the catalog.
Hybrid integration model with Axon Relay to support connecting to self-hosted integrations.
All integrations are third party plugins. Most are OSS plugins you install & maintain yourself. Limited official connectors.
Any plugins not in the marketplace must be built out from scratch.
Data import
UI import, or automated based on your configuration.
Through entity providers, catalog-info.yaml files
Performance and scale
Can handle hundreds of thousands of entities
We handle third party rate limits with self-throttling, caching, eTag handling, and more.
Catalogs support basic things like pagination. There are reports in bug trackers of degraded performance with large catalogs.
Some integrations handle caching, eTags, etc but it’s a case-by-case basis.
EntityProviders for data ingestion don’t support distributed locking or rate limit handling, so scale of ingestion is limited.
Custom entity types and properties
Custom relationships (basic) to relate entities to each other
Complex relationships including hierarchical and recursive (like an org chart)
Full control over the relationship cardinality and shape (cyclic or acyclic). Supported in reports with multi-level drilldowns.
Support for controlling cardinality, but not shape – could lead to cyclic data issues without validation.
No native reporting in Backstage, so unusable for leadership views.
GitOps, UI, and Terraform
Step 2
Define ownership
Why it matters
Whether it’s enabling innersourcing or driving accountability around Scorecards and Initiatives, ownership is the cornerstone of a successful IDP. You can define all the best practices you want, and catalog everything under the sun, but without accurate ownership and organizational context, migrations take longer, production readiness falls by the wayside, and operational overhead increases.
Requirements
Reflect your teams & members accurately
Define org chart hierarchy, from VP -> Directors -> Managers -> ICs
Define ownership across all software assets – from services to repos to infrastructure and more
TL;DR
Both support basic ownership constructs. Cortex predicts ownership with AI, supports multi-level org charts in reporting and prevents the risks that come with orphaned services. Both support syncing from tools like Okta or Azure, but Backstage doesn’t support many HRIS providers, like Workday.
Full comparison
Automatically sync teams and team members from source of truth
Sync from Workday, Okta, Google Groups, Entra, GitHub, and more
LDAP, community providers
Reflect multi-level org-chart (VP -> Directors -> Managers -> ICs)
Automatically synced from Workday, and supported natively in the team catalog.
Can model an org chart, but cannot be used in reporting for multi-level drilldowns.
Fallback ownership for orphaned services
An entity that doesn’t have an owner can inherit ownership through the entity graph, recursively. For example, a credit card processing microservice that’s orphaned may be auto-assigned to the owner of the Payment product area.
Orphaned entities report
Built into the Executive Report.
Requires a custom built plugin, filtering on services without owners, doesn’t handle inherited ownership
Manually define teams and memberships
Map a user’s representations across multiple tools to create a single identity. For example, tie a GitHub user to a Slack User to a Workday account to a Cortex user
Native capability and user properties are used to send notifications, compute productivity metrics, and more
Need to manually create and manage properties on user entities. These properties are not automatically used to map a user’s objects, for example tying a PR to a User.
You could build this manually using custom Resolvers, but you would have to build and maintain a custom mappings table capability to resolve a GitHub user to a Backstage user, for example.
✨AI predictions for ownership
Using AI & ML to predict ownership of repositories with over 90% accuracy.
Need to define ownership manually, repo-by-repo.
Step 3
Roll out your key Scorecards
Why it matters
Scorecards are a key driver of adoption and ROI for an IDP. They supercharge your engineering organization by letting you automate manual processes like Production Readiness, Operational Excellence Reviews, Security compliance, and migrations.
Requirements
Build a Scorecard that combines data from third party and internal tools
Enable stakeholders, like SRE and Security, to build their own Scorecards
Provide leadership with actionable, tailored reports
Notify and nudge users and teams to take action
TL;DR
This is the most glaring capability missing from Backstage. Scorecards are one of Cortex’s most used and powerful features. Backstage does not provide Scorecards out of the box, and requires you to purchase Spotify’s Soundcheck plugin.
Cortex lets you build Scorecards with deep access to integration data, makes it easy for technical and nontechnical users, provides out of the box drill-down leadership reports, and supports enterprise features like rule exemptions and notifications. Soundcheck supports only rudimentary reports, has a complicated fact collector + checker system for building rules, and has a limited set of native integrations.
The following comparison is for Soundcheck, Backstage’s paid plugin, since Backstage itself does not provide a Scorecarding capability.
Full comparison
WITH SOUNDCHECK
Support for user-defined rules in a Scorecard
Ability to create Scorecards based on third party integration data
Yes, but collectors need to be pre-configured and ingesting necessary data before they can be used in Scorecards. They also have a limited number of native integrations.
Custom data
Supports JQ for additional parsing within Scorecard rules.
Supports a Facts API.
Config as code / GitOps
YAML/JSON
Declarative language for rules within a Scorecard
Turing complete, with complex filtering, conditionals, JQ, and more.
Supports operators like =, !=, contains, startsWith, etc.
UI-based Scorecard rule builder for non-technical users
Functionally a UI wrapper around Fact YAMLs – no fact-builder experience to let non-technical users build Scorecards.
Complex conditionals & logic in Scorecard evaluations
CQL is turing complete.
Only supports AND or OR conditions across multiple rules. Doesn’t support scopes, like (A and B) or (C and D)
Allow users to request exemptions for specific rules
Reports for engineering leaders, with multi-dimensional rollups
Provides reports across Scorecards and rules, but no drill down experience. Filtering a report by an owner does include recursively its child teams, but no drill down level-by-level is supported.
Notifications for individuals and teams
Automatically sends weekly rollups to service owners, as well as team channels. No additional configuration needed for email or after installing Slack or Microsoft Teams.
Note that you will need to manually map users to their Slack and Microsoft Teams accounts, or build a resolver to handle this for you, to get user-level notifications working.
Step 4
Deliver your first self-service experience
Why it matters
A core pillar of an IDP is providing easy to use self service experiences to end users, especially developers. These may include bootstrapping new services, provisioning infrastructure, deploying new versions, granting access to tools, and more.
Requirements
Collect user inputs
Coordinate with internal and external systems
Collect necessary approvals
Run code scaffolding for new services or terraform
Handle edge cases and multiple user journeys
TL;DR
Cortex provides a full workflow engine for multi-step self-serve workflows with conditional branching, API calls, out-of-the-box actions, and more. Backstage supports multi-step self-service flows, but lacks advanced self service features such as conditional branching, out-of-the-box steps aside from repo management, and approval gates.
Full comparison
Form builder to collect user inputs
Dynamically update user input forms based on previous data
Dynamically generate inputs based on responses from API calls, previous context, user inputs, or even in-line JavaScript code.
Not a natively supported capability in templates. Requires building custom input React components (Custom Field Extensions).
Make API calls to internal or external systems, using a broker when necessary
Pause self-service action for approval by individuals
Supports multiple approvers, conditionally based on the self service flow.
Advanced, multi-step self service experiences
Workflow engine supports orchestrating across multiple tools, conditional branching, JavaScript support
Conditional branches are not supported in a template
Out-of-the-box steps to call third party integrations
Over 200 out of the box steps for actions from Git, CI, ServiceNow, PagerDuty, and more that use your existing connected integrations.
Most OOTB integrations are Git related for repo management. Day 2 operation integrations such as incidents and CI are not included.
Native code scaffolder for service bootstrapping
Built-in support for Cookiecutter to create repos and bootstrap projects, generate code, and open PRs against existing repos.
Inline code execution for complex logic
Sandboxed JavaScript can be run in-line in a self-service workflow.
Step 5
Extend the IDP and make it your own
Why it matters
High performing engineering organizations view the IDP as the foundation of their engineering excellence initiatives and the beating heart of their engineering team. This means that the IDP should be extendable, and the data it manages should be consumable from external systems. It should allow you to centralize all the disparate tools and UIs in your engineering toolkit, including homegrown tools.
Requirements
Ingest data from custom sources
Consume data from the API, including Scorecards
Build custom UI plugins to reduce tool spraw
TL;DR
Both Cortex and Backstage support custom UI plugins. Backstage supports (and needs) custom backend plugins, while Cortex does not. Both have comprehensive APIs to read data from the catalog, but Create/Update operations are lacking for entity lifecycle management in Backstage.
Full comparison
Standard framework to ingest data from custom sources
API for CRUD operations including Catalog and Scorecards
Read operations are available, but catalog and scorecards must be created in a “pull” model, i.e. you need to implement custom entity providers in Backstage to pull in entities, rather than being able to push them in via REST API.
Build custom plugins for the UI
Build backend plugins
Cortex UI plugins can connect to any backend, including ones you host through a secure proxy configurable in Cortex.
Most use cases that require backend plugins can be solved natively in Cortex through built in integrations or features, or Workflows.
Custom layouts and pages
Pages are fully customizable with Plugins, but no “widget” based custom layouts.
More customized widget based layouts are on the roadmap.
All pages can be fully customized.
Step 6
Run org wide initiative
Why it matters
Engineering organizations commonly run initiatives such as migrations, vulnerability mitigations, seasonal event scaling, and more. These initiatives are often managed using spreadsheets, but an IDP can serve as a “TPM copilot” and help you automate all the toil around tracking and driving progress on these org-wide initiatives.
Requirements
Create an initiative with a deadline based on your Scorecard
Create items in issue management system
Send notifications and reminders to ensure completion
TL;DR
Cortex helps you drive org-wide initiatives with deadlines, reminders, and backlog ticket creation. Backstage does not provide this natively, and requires you to purchase their Soundcheck plugin. The Soundcheck plugin’s Campaign feature.
The following comparison is for Soundcheck, Backstage’s paid plugin, since Backstage itself does not provide a Scorecarding capability.
Full comparison
Define requirement-scoped initiative with a clear deadline
Send notifications and reminders to ensure completion
Built in notification cadence for nudges and reminders.
Supports customized cadence for notifications.
Requires configuration of user-slack/teams mapping
Create backlog items and auto-close when completed
Automatically create tickets in JIRA, ClickUp, and more and place them in the appropriate team’s backlog.
Step 7
Measure & improve
Why it matters
You shouldn’t have to buy two separate tools to find bottlenecks that are slowing down your team and then change the process, systems, and culture to unblock them. Engineering Intelligence metrics should be a core part of an IDP – the whole point of an IDP is to reduce the number of places your developers, managers, and leaders need to go to find everything they need!
Requirements
Visualize engineering metrics, including productivity and DORA
Drill down into metrics across multiple dimensions (org chart, product, system, etc)
Handle mapping of identities across multiple systems (git, on-call, project management, etc)
TL;DR
Cortex provides a full fledged Software Engineering Intelligence platform natively, including velocity, incident, and issue related metrics. Backstage does not provide an engineering intelligence platform.
Full comparison
Out of the box dashboards
Cortex automatically calculates and tracks velocity, incidents, issue, deploy, and other metrics.
Roll up metrics in multiple dimensions, such as developer seniority
Roll up metrics across the org chart
Supports complex organizational structures
Custom metrics
Supports timeseries data ingestion, as well as CQL based queries to generate timeseries metrics based on catalog data.
Map users across multiple systems for metrics tracking
A single user can be mapped to their representations across VCS, Issue tracking, and more.
Step 8
Make your engineering team happy
Why it matters
At the end of the day, IDPs are only effective in helping you accelerate engineering initiatives if they are fully adopted across the organization. This requires ensuring that everyone across the organization, from engineering leaders to SREs and platform teams to developers are realizing the value of the IDP.
Requirements
Use your IDP in core meetings, like operational excellence reviews and quarterly planning.
Show users clear benefits through self-service, improved initiative tracking, and more.
Drive adoption across your organizations.
TL;DR
At the start of this page, we admitted that we’re tired of B2B SaaS compare pages. We hope that this in-depth guide gives you an honest view of the differences of our two products and a foundation for how to think about building an IDP and the core requirements.
Read how customers like Relias, Rapid7, Xero and more accelerated their engineering excellence initiatives with Cortex.
Empowering world-class engineering teams
Join leading companies like Clear, Grammarly, and Canva who use Cortex to accelerate engineering initiatives, including Production Readiness, operational maturity, and migrations
Explore the results: fewer incidents, faster delivery, better engineering outcomes.
"One of the biggest improvements we've seen since implementing Cortex is in our Mean Time to Restore- which we reduced by 67%. Being able to quickly find service information is a small operational change that has enormous impact."
Javier de Vega Ruiz
Chief Software Engineer
“More and more we think of Cortex less as a product and more as a platform on which we are building all of our internal intelligence for engineering.”
Kurt Christensen
Senior Engineering Manager
"With Cortex, we’re not just managing services better; we’re fundamentally changing the way we work and collaborate to support the healthcare organizations who rely on us every day."
Franz Hemmer
Principal Software Engineer
“We know if an engineer gets pulled out of what they’re doing, it takes 30 minutes to re-engage, Cortex lets us reduce noise and keep our team focused on the highest priority work.”
Shaun McCormick
Principal Software Engineer
“Walk away from a spreadsheet for a minute, and it’s already stale. With Cortex, we never have that issue. I can just trust that information is always up to date, and we can leave devs alone that have already done what they need to do.”
Amanda Jackson
Technical Program Manager, Rapid7