Buyer’s Guide

Best Internal Developer Platforms

Written by Govind Kumar Lohar. Reviewed for technical accuracy by Deepak Gupta and Bhaskar Suthar on · Review panel

  • platform-engineering
  • devex
  • internal-developer-platform
  • backstage

Independent buyer’s guide. No vendor paid to be included, ranked or described a particular way. Written for engineers, architects and the people who sign off on their tooling budget. Editorial policy.

The internal developer platform story is always told the same way. Engineers waste time on tickets to get a database, nobody knows who owns which service, onboarding takes weeks. Build a portal with a service catalogue, golden paths and self-service infrastructure, and all three problems go away.

The story is true. What it leaves out is that the failure mode is almost never technical. It is that the catalogue is accurate on launch day, visibly drifting a quarter later, and by the end of the year it is a list of services that mostly do not exist, owned by people who mostly left, while everyone has quietly gone back to asking in Slack.

I have watched this happen and I have watched the retrospective conclude that the wrong product was chosen. It usually was not. The product was fine. The organisation launched a platform and staffed it as a project, and a platform with no owner after launch decays on a predictable schedule regardless of which logo is on it.

So this comparison is organised around a single question: what does each product do, structurally, to keep the catalogue true without depending on humans remembering to update it. Everything else in the category is roughly equivalent. That one thing is not.

Key takeaways

  • A service catalogue that depends on humans updating it will be wrong within two quarters. The only catalogues that stay accurate are the ones assembled from systems that are already true.
  • An IDP with no permanent owner fails. Not slowly, and not because of the technology. Budget the ongoing team before the licence.
  • Backstage is a framework, not a finished product. Choosing it means choosing to staff a platform team; the hosted products exist because that is a real cost.
  • Adoption is driven by making the portal the fastest path to something engineers already want, not by mandating it. Scorecards without self-service produce resentment and stale data.

What an internal developer platform is actually made of

The category name covers four separable capabilities. Products weight them differently, and knowing which one you need eliminates most of the shortlist immediately.

The software catalogue. An inventory of services, libraries, APIs and resources, each with an owner, a repository, a runtime location, dependencies and links to its dashboards and runbooks. This is the foundation and the part that rots.

Golden paths and scaffolding. Templates that create a new service with the organisation’s defaults already applied: CI configured, observability wired, ownership recorded, security scanning enabled. The value here is not the time saved creating a repository. It is that every new service starts compliant, so the standards are enforced by construction rather than by review.

Self-service infrastructure. Developers request a database, a queue, a namespace or an environment and get it without a ticket, within guardrails the platform team defined. This is where the measurable time savings live and it is also the hardest to build, because it means encoding your infrastructure opinions as an API.

Standards and scorecards. Automated checks that every service has an owner, an on-call rotation, a runbook, a current dependency set, a passing security scan. Presented as a score, used to drive migrations and to answer audit questions.

The order matters. Scorecards on top of a stale catalogue score fiction. Self-service without a catalogue creates resources nobody can attribute. Almost every successful rollout starts with the catalogue and proves it is accurate before building anything on it.

Backstage plugins: an ecosystem, not a product

Backstage is an open-source framework, and most of what people mean when they describe “what Backstage does” is actually contributed by its plugin ecosystem: the Kubernetes view, the cost view, the CI integration, the tech radar, the scorecard implementations. That ecosystem is genuinely large, and it is also the part of the story that gets misrepresented most often, so it is worth treating on its own terms rather than as a feature of a product.

What it gives you

  • A published extension model, so a plugin written for one Backstage installation generally works in another, and the integration you need for your CI system or cloud provider has often already been written by someone.
  • A common catalogue data model that plugins read from, which is why adding a plugin tends to light up information across every service rather than requiring per-service configuration.
  • An escape hatch for anything unusual in your estate: if no plugin exists, the same extension points are available to you, and an internal plugin is a normal frontend and backend package.
  • A de facto standard that the commercial products interoperate with, so catalogue definitions written for Backstage are portable to several of the hosted offerings.

What it does not do

  • It does not guarantee maintenance. A plugin is a community contribution, and a meaningful number of them lag the framework’s own releases, so an upgrade can strand an integration you depend on.
  • It does not provide consistent quality or a security review. Plugins vary from production-grade to abandoned proof of concept, and the difference is not visible from the listing.
  • It does not remove integration work. A plugin still needs credentials, configuration and a data path from your systems, and that wiring is where the time actually goes.
  • It is not a support relationship. When a plugin breaks during an upgrade, the resolution path is your engineers reading its source.

Treat the ecosystem as a large library of starting points rather than as a feature list you are buying. Every plugin you adopt is a dependency your platform team now maintains.

The catalogue nobody updates

This is the mechanism section, because this is the whole problem.

A catalogue entry is a claim about the world: this service exists, it is owned by this team, it runs here, it depends on these things. Every one of those claims decays. Teams reorganise, services are decommissioned without anyone removing the entry, a dependency is added in a pull request nobody thought to reflect in a YAML file, an owner leaves and the entry keeps their name on it.

The decay is not laziness. It is that updating the catalogue is work with no immediate payoff to the person doing it, performed at a moment when they are busy with the thing that made the update necessary. Any design that relies on that person choosing correctly will lose.

There are four mechanisms that actually fight it, and a product is worth evaluating on how many it implements.

Derive rather than declare. The entry is assembled from systems that are already true: the repository list, the cloud provider’s resource inventory, the Kubernetes API, the CI system, the identity provider’s group membership. A service that exists in the cluster appears in the catalogue whether or not anyone registered it. This is the single most important property, because it makes the catalogue self-healing rather than self-reporting.

The counterargument is that derived data is noisy and does not know intent: it cannot tell a real service from an experiment. The answer is to derive the existence and let humans annotate the meaning, not the other way round.

Co-locate the declaration with the code. Where a declaration is needed, it lives in the repository, next to what it describes, and is reviewed in the same pull request. A team renaming its service changes the file in the diff that renames it. This is why the descriptor-in-repository pattern that Backstage popularised works better than a web form, and why a web-form-only catalogue is a warning sign.

Detect orphans actively. Something must periodically ask: this entry claims an owner, does that team still exist in the identity provider. This entry claims a repository, does it still have commits. This cluster workload has no catalogue entry, who deployed it. An unreconciled catalogue is a catalogue that only grows.

Make the catalogue load-bearing. This is the mechanism nobody wants to hear because it is organisational rather than technical. The catalogue stays accurate when something people need depends on it being accurate: the on-call routing, the deployment pipeline, the access request flow, the incident tooling. If ownership data is wrong and that means the page goes to nobody, ownership data gets fixed. If it is wrong and the only consequence is a red square on a dashboard, it stays wrong.

Teams that get this right usually wire one high-consequence flow through the catalogue early, most often incident routing. Teams that get it wrong build the scorecards first and wonder why nobody cares about their score.

Needs first-hand data: Three months after launch, take a random sample of fifty catalogue entries and verify each one by hand against the cluster, the repository and the identity provider. Record the percentage with a wrong owner, a dead repository or a runtime that no longer exists, and repeat the exercise quarterly. That single number predicts whether your platform will still be used next year, and no vendor will produce it for you.

The staffing question, said plainly

An internal developer platform is a product with internal customers. It needs a roadmap, a support channel, release notes, and someone whose job it is when it breaks. If the answer to “who owns this in twelve months” is a name and a percentage of their time, you have a platform. If it is “the team that built it, alongside their other work”, you have a project that will be abandoned.

The cost is not small and it is not one-off. Plan for a persistent team, and note that the framework choice moves this number more than any licence does: self-hosting an open-source framework means you own upgrades, plugin breakage, authentication, availability and the user interface work forever. The hosted products exist precisely because that ongoing cost is real, and their pitch is to convert engineering time into a subscription. Whether that is a good trade depends entirely on whether you can actually hire and retain the platform engineers, and most organisations overestimate that.

The second half of the staffing question is adoption. A platform is used when it is the fastest way to do something engineers already want to do: get a database, find who owns the failing dependency, create a service that is compliant without reading a wiki. Mandates produce compliance theatre, which produces the stale catalogue this article opened with. Instrument the portal, watch which pages are actually opened, and delete what is not.

Needs first-hand data: Instrument the portal for page views and template executions per engineer per week, broken down by team. Compare that against a survey question asking where people actually go to find out who owns a service. Where the two disagree, the survey is right and the portal is decoration.

Backstage

Backstage homepage

Backstage is the open-source framework that created this category, originally from Spotify and now a Cloud Native Computing Foundation project. It gives you a catalogue with a repository-resident descriptor format, a scaffolding engine, a documentation system and a plugin architecture, and then leaves the assembly, hosting, authentication, upgrades and user experience entirely to you. It is a toolkit for building your portal, not a portal.

Pros

  • The catalogue descriptor lives in the repository and is reviewed with the code, which is the pattern most likely to stay accurate
  • Complete control over the data model, the user interface and the integrations, so an unusual estate can be modelled honestly rather than forced into a vendor schema
  • No licence cost and no per-engineer meter, which matters at large headcount where per-seat pricing dominates the decision
  • The de facto standard, so its catalogue format and concepts are portable and its ecosystem is by far the largest

Cons

  • It is a TypeScript application you now own, including authentication, deployment, availability and every upgrade, and upgrades routinely break plugins
  • Time from decision to something engineers will voluntarily use is measured in quarters, not weeks, and teams consistently underestimate it
  • No support relationship, so a production problem in your developer portal is your on-call engineer reading framework source
  • The out-of-the-box user experience is a starting point, and making it pleasant is real frontend work that platform teams rarely staff

Best for: Organisations large enough to fund a permanent platform team, with requirements unusual enough that a vendor schema would be a fight.

Pricing: No vendor and no bill. Open source under a permissive licence; the entire cost is the engineering team that builds, hosts and maintains it, which is substantial and ongoing.

Port

Port homepage

Port takes the opposite approach to the catalogue: rather than shipping a fixed service model, it gives you a configurable data model where you define the entity types, their properties and the relations between them, and then ingest data into it from your existing systems. The result is closer to a graph of your engineering estate than a service list, which suits organisations whose reality does not fit a services-and-owners schema.

Pros

  • Fully configurable entity model means you can represent whatever your estate actually contains, including things that are not services
  • Ingestion-first design pulls data from cloud providers, Kubernetes, CI and version control, which is the derive-rather-than-declare property that keeps catalogues true
  • Self-service actions are a first-class part of the product rather than an afterthought bolted onto a catalogue
  • Scorecards and ownership rules sit naturally on top of the same graph, so standards enforcement uses the same data as discovery

Cons

  • The flexibility is also the cost: you have to design your own data model, and a badly designed one is hard to change later
  • Ingestion mappings are configuration that needs maintaining as source systems change, so the work moves rather than disappearing
  • Hosted platform means your engineering estate metadata lives with a vendor, which some security reviews will want to discuss
  • Per-engineer pricing scales with headcount, which is exactly where the open-source alternative looks most attractive

Best for: Mid-sized and large engineering organisations that want a configurable catalogue and self-service without staffing a platform team to build one.

Pricing: Free tier for small usage, then per-engineer subscription tiers with higher tiers adding advanced governance, single sign-on and support commitments.

Cortex

Cortex homepage

Cortex leads with the standards and scorecards half of the category rather than the portal half. Its central artefact is a set of rules that every service is measured against, with the catalogue existing to make that measurement possible. For organisations whose real problem is driving a migration or answering an audit question across hundreds of services, that emphasis is the right one.

Pros

  • Scorecards are the primary object, so defining, tracking and driving a standard across the estate is the workflow the product is shaped around
  • Strong integration breadth for pulling ownership, deployment and vulnerability data from existing systems
  • Initiatives and campaigns give a structured way to run a migration with visible progress per team, which is the thing engineering leadership actually asks for
  • Ownership modelling handles the realistic case of shifting teams and multiple owners rather than assuming one stable owner per service

Cons

  • Scorecards on an inaccurate catalogue produce confident nonsense, so the catalogue accuracy work is still entirely yours to do first
  • Scoring teams is politically loaded, and a rollout that leads with scores before self-service reliably produces resistance
  • Less emphasis on developer self-service actions than the platform-oriented competitors, so it may not reduce ticket volume
  • Enterprise-oriented commercial model with limited value at small scale

Best for: Engineering organisations with enough services that driving a consistent standard is the problem, and leadership that will act on the scores.

Pricing: Commercial per-engineer subscription with enterprise tiers, quoted rather than published, and no meaningful free tier.

Roadie

Roadie homepage

Roadie is managed Backstage. You get the framework’s catalogue model, scaffolding and plugin ecosystem, with the hosting, upgrades, authentication and a curated set of maintained plugins handled by a vendor. It is the direct answer to the most common Backstage failure, which is a team that adopted the framework and then could not sustain the operational load.

Pros

  • Removes the largest real cost of Backstage, which is hosting, upgrading and keeping plugins working through framework releases
  • Catalogue descriptors are standard Backstage format, so the data and much of the configuration remain portable
  • Curated and maintained plugin set avoids the abandoned-plugin failure that catches self-hosted installations
  • Much shorter time to a usable portal than self-hosting, which matters because slow rollouts lose sponsorship

Cons

  • You are constrained to what the managed offering supports, so deep custom frontend work is more limited than self-hosting
  • Still Backstage underneath, which means its opinions and its data model are your opinions and data model
  • Catalogue metadata for your whole estate sits in a hosted service, which is a security review conversation
  • Per-engineer pricing removes the main economic argument that pushed people to the open-source framework in the first place

Best for: Teams that want Backstage’s model and ecosystem but have concluded honestly that they cannot staff its operation.

Pricing: Per-engineer subscription with tiers, plus a trial period; infrastructure is the vendor’s, so there is no separate hosting bill.

OpsLevel

OpsLevel homepage

OpsLevel is a catalogue and standards product with a strong emphasis on ownership and operational maturity. Its distinguishing quality is how deliberately it handles the messy parts of ownership: teams that own many services, services with no owner, ownership inferred from repository activity when nobody has declared it. That focus makes it good at the problem most catalogues fail at.

Pros

  • Ownership modelling and orphan detection are treated as core problems rather than as a field on a form
  • Maturity rubrics and checks are straightforward to define and produce a defensible answer to audit questions about coverage
  • Automated ingestion from repositories, cloud and deployment systems reduces the manual declaration burden
  • Self-service actions and scaffolding are present, so it can reduce ticket volume as well as report on standards

Cons

  • Overlaps heavily with its direct competitors, and the differences show up only in detail during a real trial
  • More opinionated data model than the configurable alternatives, so unusual entities need to be forced into a service shape
  • Effectiveness depends on integration coverage for your specific toolchain, and a gap there is a significant blind spot
  • Commercial per-engineer model with the same headcount scaling concern as the rest of the category

Best for: Organisations whose immediate pain is that nobody knows who owns what, and who want that fixed before building self-service on top.

Pricing: Per-engineer subscription tiers, with higher tiers adding advanced checks, integrations and administrative controls.

Humanitec

Humanitec homepage

Humanitec is a different animal from the portals. It is an orchestration layer that sits between a developer’s declaration of what an application needs and the actual infrastructure that gets provisioned, resolving abstract resource requests into concrete cloud resources per environment. It is the self-service infrastructure half of the category taken seriously, with the catalogue and portal explicitly left to other tools.

Pros

  • Abstracting resource requests from concrete infrastructure means the same application definition provisions correctly in every environment without per-environment manifests
  • Platform teams encode infrastructure policy once as resource definitions, which is genuine standardisation rather than documentation of standards
  • Removes a large class of ticket-driven work, which is the part of the IDP promise with the most measurable payback
  • Composable with a separate portal, so it does not force you to abandon a catalogue you already run

Cons

  • It is not a portal, so if what you wanted was a service catalogue this is the wrong product entirely
  • Adopting it means putting a new component in the deployment path of every application, which is a serious reliability and migration commitment
  • Requires the platform team to model infrastructure properly up front, and a poor abstraction is worse than none
  • Assumes a reasonably mature container and infrastructure-as-code practice already exists

Best for: Platform teams whose bottleneck is provisioning and environment configuration rather than discovery, with containerised workloads already in place.

Pricing: Commercial subscription priced around scale of applications and environments orchestrated, with enterprise tiers, quoted rather than published.

Configure8

Configure8 approaches the category from the discovery direction, building a map of the estate by connecting to the systems that already know about it and then layering catalogue, scorecards and self-service on that discovered graph. The pitch is faster time to an accurate catalogue, because less of it is declared by hand.

Pros

  • Discovery-led ingestion means an initial catalogue exists before anyone has written a descriptor file, which removes the worst part of a rollout
  • Relationship mapping between services, infrastructure and cloud resources gives dependency context that a flat service list cannot
  • Combines catalogue, scorecards and self-service actions in one product rather than requiring assembly
  • Faster initial rollout than framework-based approaches, which helps keep sponsorship alive

Cons

  • Discovered data is noisy by nature, so curation work shifts from creating entries to pruning and annotating them
  • Smaller product and community than the leading alternatives, which matters for integration breadth and long-term risk
  • Less customisable than the configurable-model competitors when your estate does not fit its assumptions
  • Depends on integration coverage for your particular cloud and toolchain, and gaps are hard to work around

Best for: Teams that want an accurate catalogue quickly with minimum manual declaration, and can accept curating discovered data instead.

Pricing: Commercial subscription priced per engineer or per catalogued entity depending on tier, quoted rather than published.

How to choose

Decide the staffing question before the product question, because it eliminates half the list.

You can fund a permanent platform team of several engineers, indefinitely. Backstage is a reasonable choice and the economics work at large headcount. Be honest that the first useful version is quarters away and that upgrades are a permanent tax. If you want the model without the operations, Roadie is the same thing with the burden moved.

You cannot fund that team. Do not choose the framework. Port, Cortex, OpsLevel or Configure8, and pick on which half of the problem hurts: Port and Configure8 lean toward catalogue and self-service, Cortex and OpsLevel lean toward standards and ownership.

Your problem is provisioning, not discovery. Humanitec, and keep whatever catalogue you already have. Buying a portal to solve a ticket-queue problem is the most common mismatch in this category.

Your problem is that nobody knows who owns what. OpsLevel or Configure8 first, and do not build scorecards until the ownership data survives a hand audit.

Then, whichever you pick, commit to three things in writing before the rollout: a named owner for the platform twelve months out, one high-consequence workflow wired through the catalogue in the first quarter, and a quarterly hand audit of catalogue accuracy. Those three decide the outcome. The product choice is secondary and everyone gets that backwards.

ProductCentre of gravityCatalogue accuracy strategyYou run itPicks itself when
Backstage (open-source framework, not a finished product)FrameworkRepository-resident descriptorsEntirelyYou have a permanent platform team
PortConfigurable catalogue and actionsIngestion into a custom modelNoYour estate needs a custom data model
CortexStandards and scorecardsIntegration-derived, scorecard-drivenNoDriving a standard across many services
RoadieManaged BackstageRepository-resident descriptorsNoYou want Backstage without operating it
OpsLevelOwnership and maturityIngestion plus orphan detectionNoNobody knows who owns what
HumanitecInfrastructure orchestrationNot its jobPartlyProvisioning is the bottleneck
Configure8Discovery-led catalogueAutomated discovery, curated afterNoYou want an accurate catalogue fast

Frequently asked questions

Do we need an internal developer platform at all?

Below a few dozen engineers, almost certainly not. A repository naming convention, a shared on-call rotation and a single page listing services will do the same job with none of the maintenance. The signals that you have outgrown that are specific: incidents delayed because nobody knows who owns a failing service, new services created without observability or scanning, and a ticket queue for infrastructure that is measurably blocking delivery. Absent those, buying a portal creates work rather than removing it.

Why do internal developer platforms fail?

Two reasons, in this order. The catalogue becomes inaccurate because it depends on people updating it for no immediate benefit to themselves, and once it is wrong nobody trusts any feature built on it. And the platform has no permanent owner, so it stops evolving while the estate around it keeps moving. Both are organisational, which is why the postmortem that blames the product is usually wrong. The technical mitigations are to derive catalogue data from systems that are already true, and to make something people need depend on the catalogue being right.

Should we self-host Backstage or buy a hosted product?

Compute the fully loaded cost of the platform engineers you would need, permanently, and compare it against the subscription for your headcount. For most organisations under a few hundred engineers the hosted product wins clearly, and the reason people still choose the framework is that the licence cost is visible on a budget line while the engineering time is not. Self-hosting is the right answer when your estate genuinely does not fit a vendor model, or when headcount is large enough that per-engineer pricing dominates. Related tradeoffs show up in GitOps tools and infrastructure as code, which are the layers underneath any self-service story.

What should we build first?

The catalogue, and then one workflow that depends on it being correct. Incident routing is the usual best choice because the consequence of wrong ownership data is immediate and visible. Scaffolding templates are the second thing, because they make every new service compliant by construction. Scorecards come last, after the data has survived an audit. Teams that invert this order end up scoring a catalogue that is wrong, which damages the platform’s credibility in a way that is hard to recover from.

How does this relate to developer onboarding and engineering metrics?

A catalogue with accurate ownership and golden-path templates removes a large part of what makes onboarding slow, which is covered in developer onboarding tools. Engineering metrics are a separate concern that often gets attached to the same portal, and attaching them too early is a mistake for the same political reasons scorecards are: see engineering metrics and DORA tools for where those belong.