From DevOps to platform engineering: why the promise stalled
The question of DevOps and platform engineering generally arises after a first phase of adoption. Teams have automated their deployments, learned to describe their infrastructure as code and taken on part of operations. The principle could be summed up in one phrase: whoever builds an application also keeps it running.
At small scale, the model works. At large scale, it produces an unexpected effect. Each team builds its own delivery pipeline, its own modules, its own security settings. Developers spend a growing share of their time on tooling that has nothing specific to their product. Practices diverge, configuration gaps accumulate and a rule change has to be repeated as many times as there are teams.
Platform engineering responds to this burden. A dedicated team provides the others with ready-to-use capabilities. It does not take back responsibility for the applications: it removes from product teams what does not set them apart. Our glossary entry on platform engineering details its definition.
Delivery pipeline, infrastructure as code, platform: who does what
Three building blocks are layered on top of one another. Confusing them leads to buying one in the belief that you are getting all three.
| Building block | What it provides | Who owns it | Sign that it works |
|---|---|---|---|
| Integration and deployment pipeline | A code change is built, tested, checked and then deployed without any manual action | Platform team for the foundation, product teams for their own steps | A production release is a routine event |
| Infrastructure as code | Infrastructure is described in versioned files that are reviewed and can be replayed | Platform team for the modules, product teams for their use | An environment can be recreated identically from the repository |
| Internal developer platform | Common capabilities are offered on a self-service basis, with their rules built in | Platform team, with a product owner | Teams obtain what they need without opening a request |
The delivery pipeline is also where controls are applied: automated tests, dependency analysis, verification of security rules expressed as code. This aspect connects with our software quality offering, which deals with test strategy.
Golden paths: standardising without prohibiting
A golden path is a complete answer to a frequent need: exposing a web service, launching a scheduled job, publishing a programming interface. It brings together a repository template, a preconfigured delivery pipeline, the necessary infrastructure resources, collection of logs and metrics, and documentation.
Its strength lies in a design choice: it is not imposed. A team can depart from it if its need requires, provided it takes responsibility itself for what it builds off the path. This freedom obliges the platform team to make its offering genuinely convenient. A platform that has to be made mandatory in order to be used has a product problem, not a discipline problem.
Our approach: treating the platform as a product
Observing before building. We follow a few real changes from end to end and ask developers what slows them down. The list of irritants identifies the first capabilities to offer.
Delivering a first, complete path. Rather than a broad and unfinished foundation, we recommend aiming for a path usable by a volunteer team, from the first commit to production. This team acts as first customer and first critic.
Establishing a product relationship. The platform has a roadmap, a product owner, documentation, a support channel and versions. Teams’ requests are prioritised according to their frequency, not according to the influence of the requester.
Extending through demand. Each new path meets a need observed in several teams. Contributions from user teams are encouraged and governed.
Operating the platform itself. A platform on which all deliveries depend becomes a critical service. It must have its own reliability objectives, according to the practices described in our SRE and observability offering.
The same logic applies to data science teams, whose model deployment needs are dealt with in our page on MLOps.
The pitfalls of a platform approach
- Building for assumed users. A platform designed without developers solves its authors’ problems.
- Starting with the shop window. A polished portal that only triggers manual requests in the background has changed nothing.
- Renaming the operations team. If the platform team continues to handle requests by hand, the name has changed and nothing else.
- Leaving infrastructure code without discipline. Changes made by hand in the provider’s console make reality diverge from its description. Without review or drift detection, the code loses its value as a reference.
- Piling up tools. Each tool added must be operated, updated and documented. A lean, maintained platform is better than an extensive, fragile catalogue.
Measuring delivery and adoption
Two families of indicators complement each other.
The first concerns delivery. Four measures are commonly used: deployment frequency, the time between a code change and its production release, the change failure rate and the time to restore service after a failure. They are often called DORA metrics, after the DORA research programme (dora.dev), which now publishes a fifth: the share of unplanned deployments caused by a production incident. They have nothing to do with the European regulation of the same acronym.
The second concerns adoption of the platform:
- the share of services that follow a golden path;
- the time a team needs to release a new service to production for the first time;
- the time a newcomer needs to deliver their first change;
- the volume of manual requests still sent to the platform team;
- developers’ assessment, gathered at regular intervals.
We set with you how each indicator is calculated from the framing stage. A measure whose source changes along the way no longer makes it possible to observe progress.