Dora NodaSpotify's Backstage is free and open source, and it can still cost you $700,000 a year. That is not a contradiction — it is the central fact of the 2026 internal developer portal market.
The license costs nothing; the two to four platform engineers who install it, customize it, upgrade it, and keep its plugins alive cost everything. Meanwhile Port, the SaaS challenger that raised $100M at an $800M valuation in December 2025 precisely to take on Backstage, will sell the same 100-engineer org a working portal for $30,000 to $80,000 a year, live in days. This post puts both sides' real numbers in one table, traces where each dollar goes, and names exactly what the cheaper, faster option trades away.
The 60K portal
Here is the comparison for a 100-engineer organization, using 2026 cost breakdowns from across the portal market:
| Cost line | Self-hosted Backstage | Port (SaaS) |
|---|---|---|
| License / subscription | $0 (Apache 2.0) | ~$30K–$80K/yr (roughly $30–$65 per dev/month at 100 seats) |
| Platform engineering headcount | 2–4 FTE at $150K–$200K fully-loaded each: $300K–$700K/yr | $0 (vendor operates the portal) |
| Portal infrastructure (PostgreSQL, hosting, CI) | ~$5K–$15K/yr | $0 (included) |
| Time to a portal engineers actually use | 3–12 months from a blank canvas | Days to weeks |
| Realistic all-in total | ~$450K–$700K/yr | ~$30K–$80K/yr |
The delta is roughly 10x, and it is almost entirely headcount. One comparison puts Backstage's staffing TCO at $150,000–$400,000 a year for one to two engineers before infrastructure; another prices 2–4 FTEs at €120K each, or €240K–€480K a year, before the portal reaches production. Port's own ROI analysis prices a 300-developer Backstage build at over $1M in initial investment alone. However you slice the inputs, a self-hosted portal for a 100-engineer org lands in the mid-six figures, and the SaaS alternative lands in the low five.
That gap is the whole market story of 2026: Backstage holds dominant mindshare (one survey puts awareness near 89%) while commercial portals mop up every team that cannot staff a portal team. Understanding the gap means understanding what each side's money buys — starting with where Backstage's $700K goes.
Where Backstage's $700K actually goes
Backstage is a framework, not a product. What you download is a blank canvas: a software catalog, the Scaffolder for templates, and TechDocs — plus the obligation to turn them into your company's portal. Every line of the bill traces back to that fact.
Installation and customization (months 0–6). Standing up production Backstage means wiring it into your SSO, your CI, your Kubernetes clusters, your cloud accounts, and your PagerDuty/Opsgenie rotation, then writing catalog-info.yaml files and custom Scaffolder templates for every golden path. Practitioners consistently report 6–12 months and 2–5 full-time engineers to reach a portal that delivers daily value; 3–6 months is the optimistic case for a team that already knows the stack. At fully-loaded cost, the build phase alone can consume $200K–$400K before a single developer self-serves anything.
Upgrades and plugin maintenance (forever). Backstage ships fast, its plugin ecosystem ships faster, and breaking changes are a fact of life. Somebody has to track upstream releases, test every custom plugin against them, and fix what breaks — plus handle the operational trivia (GitHub API rate limits are a famous one) that a framework leaves to you. Budget one to two engineers in perpetuity; this is the line item that turns a build project into a $450K+/yr run rate.
Portal infrastructure (small but real). PostgreSQL, container hosting, and CI for the portal itself run roughly $4K–$15K a year — noise next to headcount, but another thing your team owns at 3 AM.
The adoption risk nobody budgets. Here is the cruelest line: after spending all of the above, 45.3% of platform teams in the 2026 State of Platform Engineering findings name developer adoption a leading challenge, 36.6% resort to mandates to force usage, and 40.9% cannot demonstrate measurable developer value within twelve months of launch. One mid-sized company found 64% of its engineers still typing kubectl run for local testing, sidestepping the golden paths entirely. Gartner explicitly warns against mistaking DIY frameworks like Backstage for ready-to-use portals, noting the disillusionment when maintenance costs balloon. The $700K portal can fail the way a $60K subscription cannot: by being ignored.
None of this means Backstage is bad — for organizations with a real platform team and genuinely unusual requirements, unlimited extensibility is worth paying for. It means the price is headcount, and you should underwrite it with eyes open.
What Port's subscription buys
Port inverts the deal: instead of a framework you build on, you get a working portal you configure. You define entities, relationships, and scorecards through a no-code UI (what Port calls blueprints) rather than writing TypeScript plugins, and the portal is live in days to weeks instead of quarters.
For the 100-engineer org, the math is simple. Port's pricing runs from a free tier (15 seats, 10,000 entities) through paid tiers around $30–$65 per developer per month depending on plan and scale — call it $36K–$78K a year at 100 seats, squarely inside the $30K–$80K band. What that subscription includes out of the box reads like Backstage's build backlog: a software catalog, self-service actions with workflow automation, in-context maturity scorecards, SSO, and RBAC — with upgrades, uptime, and rate-limit wrangling handled by the vendor.
Setup time is the other half of the pitch. Commercial portals deploy in days to 30–45 days with vendor support, against Backstage's months-to-a-year build. For a team without a dedicated platform squad, that is not just convenience — it is the difference between having a portal this quarter and having a portal project. It is also why the market has sorted itself by headcount: under 50 developers, teams default to Port or OpsLevel (from ~$39/dev/month); the 50–200 band picks Backstage only when it can staff the dedicated two-person team; past that, the calculus depends on how much custom platform engineering you were going to do anyway.
So the subscription buys speed and the absence of a second team to run. What does it trade away? More than the pricing page suggests.
What the days-to-weeks setup trades away
Every dollar Port saves comes from something you no longer own. Four tradeoffs matter:
1. SaaS-only: your engineering metadata lives on someone else's servers. Port has no self-hosted option. Your service catalog, your scorecards, your self-service audit trail — the map of everything your engineering org builds and runs — sits on vendor infrastructure. For regulated industries or anyone with data-residency requirements, that alone can end the evaluation. Backstage runs on your machines, behind your SSO, under your compliance boundary.
2. A proprietary data model instead of an open ecosystem. Port's blueprints are configuration, not code — fast to start, but you are building inside one vendor's model rather than on catalog-info.yaml files and an open plugin ecosystem any engineer can extend. Backstage's moat is the hundreds of community plugins and the guarantee that anything can be customized; Port's moat is that you never need to. Teams that outgrow no-code discover the ceiling exactly when migration is most expensive.
3. Per-seat pricing compounds with headcount. $30–$65 per developer per month is cheap at 100 engineers and real money at 500 — $180K–$390K a year, at which point the gap to a staffed Backstage team narrows substantially while the SaaS constraints remain. Backstage's headcount cost is roughly flat with org size; Port's scales linearly with every hire. Model both curves past your current headcount, not just at it.
4. Less deep customization. A framework bends to genuinely unusual requirements — custom entity kinds, bespoke Scaffolder actions wired into internal systems, TechDocs rendered your way. A SaaS portal covers the common 90% beautifully and the weird 10% never. If your golden paths involve internal systems no vendor has heard of, budget the framework.
There is also a middle lane worth knowing: managed Backstage. Roadie (~$22–$24 per developer per month) and Spotify's own Portal ("Backstage in a box") keep full Backstage compatibility — same catalog format, same plugins — while outsourcing upgrades and operations to a vendor. For a 100-engineer org that is roughly $26K–$29K a year: SaaS-like operations spend with the open ecosystem intact. It does not remove the customization work, but it removes the 3 AM pager for the portal itself.
The headcount split: who should pick which
Distilled to a decision table:
| Org size | Default pick | Why |
|---|---|---|
| Under ~50 developers | Port or OpsLevel | No portal team to staff; days-to-value beats framework power |
| ~50–200 developers | Port — or Backstage only with a dedicated 2-person platform team | Backstage's $450K+/yr run rate needs owners, not volunteers |
| ~200+ developers | Backstage (self-hosted or managed) if requirements are unusual; SaaS if they are not | Per-seat SaaS scales linearly while headcount cost flattens |
| Regulated / data-residency constrained | Backstage or managed Backstage with on-prem connectivity | SaaS-only metadata storage may be disqualifying |
But the deeper question is not which portal — it is whether the portal should be a second platform at all. Both Backstage and Port layer a catalog-and-template UI on top of wherever your apps actually deploy. Somebody still owns the deploy path underneath: the CI pipelines, the cluster configs, the TLS certificates, the environment sprawl. The portal tells developers which golden path to walk; a different system paves it.
That split is the real $700K lesson. The pitch for a self-hosted PaaS was never "cheaper than Backstage" — it is that the golden path is already the deploy platform, not a second portal layered on top of one. When git push produces a running HTTPS service with preview environments, rollbacks, and sane defaults, the catalog writes itself from the thing developers already use, and there is no portal team because there is no second system to run. The portal market exists to paper over deploy paths too complicated to use directly; simplify the deploy path and much of the portal's job disappears.
The verdict
For most teams under 200 engineers, the 2026 math is blunt: a self-hosted Backstage deployment costs roughly 10x a Port subscription ($450K–$700K vs $30K–$80K a year at 100 engineers) and takes quarters instead of days — and still faces the adoption crisis where nearly half of platform teams cannot prove value in year one. Port earns that discount honestly with SaaS operations and no-code setup, and charges for it honestly with SaaS-only data, a proprietary model, and per-seat scaling. Pick the portal that fits your headcount and compliance boundary — then ask whether the deploy platform underneath it could make half the portal unnecessary.
Watch the two forces that could redraw this table: Backstage's v3 federation push, which aims to cut multi-team maintenance cost, and the AI-agent-readable standards race — whether an agent can read a scorecard, write the fix, and route it for approval may soon matter more than which UI humans click. Either way, the teams that win will be the ones whose golden path is the shortest distance between an idea and production, with the fewest systems to staff along the way.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.
