Most companies that ship software have asked the same question about their internal developer platform: is it worth the cost? A platform needs a team, a budget and years of attention. The business wants to know what it gets back.
This post answers that question in four parts: the benefits, where the return comes from, the challenges that eat into it, and what AI assistants and agents change about the case.
What an internal developer platform is for
Definition
Internal developer platform
An internal developer platform lets developers, and now their AI assistants and agents, get what they need to ship without waiting on a platform team. It holds the organization's standards as rules a machine can check, and it applies them to every change before the change reaches the cloud.
Many people picture a portal when they hear "internal developer platform": one place to find services, owners and docs. Portals are useful for discovery. The business impact, though, comes from the layer under the portal: the layer that turns a request into a running, compliant change. That delivery layer decides how long developers wait and how often a change breaks production.
The benefits of internal developer platforms
The research agrees that platforms pay off. In a Forrester Opportunity Snapshot commissioned by Humanitec in 2023, 85% of respondents said internal developer platforms had a positive impact on revenue growth, and 77% said the same about time to market.
The benefits fall into four groups.
Faster time to market. When developers get environments, databases and releases without a ticket, a feature reaches customers as soon as it is ready. Faster releases also mean faster feedback, so teams learn sooner which ideas work.
Developer productivity. Developers spend less time on setup, waiting and context switching, and more time on the product. The next section covers how.
Standards by default. Security, reliability and cost rules apply to every service in the same way, because they live in the platform. Teams stop rediscovering the same rules in review comments.
Talent retention. Good engineers leave teams where they spend their days waiting and fighting tools. A platform that removes that friction is part of why they stay.
Where the return comes from
The benefits above are real, but a business case needs numbers you can defend. The return of a platform comes from four places, and each one can be estimated from data you already have.
Developer time. Count the requests that made a developer wait on the platform team last month: environments, databases, pipeline changes, access. Multiply by the average wait and by the share of that wait in which the developer was blocked. That is the time a platform can give back.
Platform team time. Count the tickets the platform team closed by hand, and the hours each one took. With self-service, most of these become rules the team writes once. The time moves to work only the platform team can do: better building blocks, security and cost.
Fewer production issues. Look at the incidents caused by a change: a wrong setting, a missed standard, a manual step done out of order. A platform that checks every change before it runs, and keeps a record to roll back from, prevents a share of them. Price each one at the engineering hours and the customer impact it cost.
Faster go-live. Look at the last few launches of a new service, environment or region, and how many weeks the infrastructure took. When an environment becomes a request, those weeks shrink. For a sales-led business, a new region can also mean deals that were blocked on data residency.
Add the four together, and set them against the cost of the platform: licenses or a build team, plus the time to adopt it. The first two sources are the easiest to measure. The last two are harder to price, so write down how you estimated them.
How a platform raises developer productivity
Developers lose a large share of their week to work that is not the product. In Stripe's Developer Coefficient survey (2018), developers reported 17.3 hours a week on maintenance: bad code, errors, debugging, refactoring and modifying.
A platform wins some of that time back in three ways.
It removes the waits. The developer asks for an environment or a database and gets it, inside the rules. No ticket, no follow-up questions, no days in a queue.
It limits choices on purpose. A platform can only give guarantees if it limits the options a developer must choose from. A good platform asks the developer for a few settings, such as the size and version of a database, and the platform team decides the rest inside the building block: encryption, backups, network placement, monitoring. The developer makes fewer decisions, and every result is safe by default.
It lowers the mental load. Developers do not need to know how each cloud service is wired, which pipeline does what, or where the rules for production are written down. They state what they need, and the platform handles the rest. Less to hold in your head means fewer mistakes and faster onboarding.
Productivity is one part of developer experience. The others are tooling, process, culture and support. A platform helps most with the first two, and it gives the rest room to grow. Developer experience and why it matters covers all five.
The challenges of internal developer platforms
The return is real, and so are the costs that eat into it. Why Facets names three hurdles that platform engineering ran into.
Too specific. Most internal platforms are built for one company's setup at one point in time. When the stack changes, the platform has to change too, and each change is a project.
Adoption. Getting developers to use the platform is harder than building it. If the platform is slower or more rigid than the old way, teams keep the old way, and the platform team runs two systems.
Cost. An internal platform needs its own team to build and maintain it, and the work never ends: upgrades, integrations, new building blocks, support.
Teams also report two more challenges:
- Stakeholder buy-in. A platform asks for an upfront investment before the return shows. Leaders need a business case they can track.
- Legacy systems. Most of what runs today was built before the platform. If the platform only covers new services, the oldest and riskiest systems stay on the old path. Bringing them under the platform is often the hardest part.
- Measuring ROI. Without a baseline, the gains are hard to show. Measure the wait before the platform starts, so you can compare after.
What AI changes about the ROI
AI made code fast. A coding assistant writes a feature in an afternoon, and each engineer now sends more changes every week. Many of these changes need infrastructure.
This changes where the return of a platform comes from. When writing code took most of the time, a platform that saved developers some setup time paid off. Now that code is fast, most of the time between an idea and production is the wait to ship it. Engineering teams talk about pull requests that wait after AI. Why Facets describes how the bottleneck moved from writing code to shipping it.
Two things follow for the business case:
- The delivery layer holds most of the return. A portal on top of the same per-project pipelines does not scale with AI's volume. Each pipeline runs with privileged access, so only a few experts change it, and every change still waits for them.
- Agents need a check before they act. AI assistants and infrastructure agents now make changes too. A platform that checks every change before it runs, whoever sends it, lets agents work without a person reviewing every line. A platform without that check makes every agent change a new risk.
How to build the business case
A good business case starts small and measures what matters.
- Get executive buy-in. Show the cost of the wait today: how long a merged change takes to reach production, and how many requests sit with the platform team. Use peers' results where you have them.
- Start small, then scale. Pick one product or team with clear, frequent requests. Show the result, then extend the platform in phases.
- Involve developers early. Developers are the users. Ask them where they wait, design for those waits first, and let them contribute building blocks over time.
- Measure results. Track a few numbers before and after, and report them on a fixed schedule.
Three measures tell you most of what you need:
| Measure | What it shows |
|---|---|
| Time from a merged change to production | How long changes wait in delivery |
| Requests waiting on the platform team | How much of the work still needs a person |
| Change failure rate | Whether faster delivery is also safe delivery |
Key KPIs for platform engineering covers more measures and how to read them.
When you evaluate a platform, check for what the AI era asks of it:
- Typed contracts for each building block, so a wrong value cannot pass.
- One declared model of each system, so people and agents start from the same facts.
- Plan, policy and approval before every change.
- An orchestrator that holds the cloud keys, so no person or agent needs them.
- Terraform you can read, so engineers trust every plan.
- An API and a CLI that AI assistants can use, under the same roles as people.
- A way to bring what already runs under the platform without rebuilding it.
To decide between building these parts and adopting them, read in-house or third-party internal developer platform and building an internal developer platform.
Where Facets fits
Facets is the infrastructure delivery platform for developers and their AI assistants. It is built on the Terraform your engineers already know (Why Facets).
Your platform team puts its standards into modules: Terraform with a contract that sets what developers can choose, what each module needs and what it gives back (Modules and the catalog). Each project declares what it needs in one blueprint, with no pipeline per project to write. Every change shows its Terraform plan, passes guardrail policies and waits for approval where a rule applies, and only the Facets orchestrator applies it in your cloud.
Developers use the web UI. AI assistants such as Claude Code, Codex and Cursor work through the Praxis CLI, with the role of the person who uses them. What already runs can be imported into the same model, so every change after that goes through the same checks.
Across customers, the return shows in both developer and platform team time. Facets customers typically cut DevOps toil by 80%. Facets customers ship 8-25x faster, from MPL's 8x deployment frequency to Purplle and GGX at 25x.
To build the business case on your own numbers, book a demo. For a wider view of the options, see the best internal developer platforms to consider.
