Skip to content

Engineering

Platform engineering: harmonize to innovate

What I learned studying Gregor Hohpe and the book Platform Strategy: why platforms and IT services are opposites, the difference between harmonizing and restricting, abstractions that don't deceive, and why a platform has to be treated as a product.

Fernando Ghisi · 13 min read

How I got to Hohpe

I met Gregor Hohpe the way I meet most people who influence me: by reading. First came the articles, like The Architect Elevator, published on Martin Fowler's site, where he argues that architects need to ride between the boardroom and the engine room. Then came interviews and talks, while I was studying a subject that had been taking up a good part of my head: platforms.

That is how I got to Platform Strategy: Innovation Through Harmonization, which he wrote with Michele Danieli and Jean-François Landreau, and which belongs to the same series as the Architect Elevator. The subtitle already sums up the thesis: innovation through harmonization. A platform does not exist to control teams or to save on servers. It exists so that teams can innovate faster, because they don't have to solve again, each in their own way, what should be the same for everyone.

In the article on Team Topologies in practice, I explained that our payments team has three platform teams: infrastructure, DevEx and data. There I said platforms need to be treated as products. Here I want to go deeper into that, with Hohpe's help, and explain why that sentence became my main concern with our DevEx team.

One word for everything

Few words in engineering are as worn out as "platform". The infrastructure team becomes a platform, the internal portal becomes a platform, the set of shared libraries becomes a platform. The book itself starts by acknowledging this: the term has been used so much that, before talking strategy, you have to separate what is a platform from what is not.

The distinction that helped me most is simple and provocative. For Hohpe, IT platforms and IT services are antonyms. A whole chapter of the book has that title.

IT services and platforms are opposites

The traditional IT service works on request. A team opens a ticket, joins a queue and waits for someone on the other side to do the work. Usage is usually mandatory, the provider takes care of everything and the priority is stability: the less it changes, the better. Over time this model becomes a bottleneck, because every new team that arrives makes the queue longer.

A platform works the other way around. Teams use it on their own, without asking anyone. Adoption is, most of the time, voluntary: people choose the platform because it solves their problem. Responsibility is shared, and no platform will magically take care of the requirements of whoever builds on top of it. And it has to keep evolving, because a platform that stands still becomes a burden.

IT service and platform: with the service, teams open tickets into a queue for a central team; with the platform, teams use a shared base on their own and build different things on top of it IT SERVICEPLATFORM teamteamteamteam QUEUE centralteam ABCsomethingnew shared self-service base tickets, queue and mandatory usethe more teams, the longer the queueeach team uses it alone, by choicethe more teams, the better the base
For Hohpe, IT services and platforms are antonyms. The service gets worse as it grows; the platform gets better, and lets teams build what nobody had foreseen.

The most interesting consequence is scale. An IT service gets worse as it grows, because the queue grows. A platform gets better, because every team that joins brings feedback, finds problems before the others and justifies the investment. In his interview with the TechLead Journal, Hohpe sums it up by saying that platforms live from scale: a platform without users creates exactly zero value.

The idea from the book: If your "internal product" depends on tickets, queues and mandates to be used, it is an IT service under another name, not a platform.

Harmonize without restricting

This is the distinction I use most since I started studying the subject. Standardization tends to have a bad reputation, and not without reason: the standards team is usually remembered for saying no. Hohpe argues that platforms also harmonize and standardize, but without restricting.

His example is HTTP. It is a strict standard that defines precisely how client and server talk. And it was exactly that strictness that let millions of people build completely different things on top of it, without asking anyone for permission. The standard did not limit innovation; it made it possible.

The car industry, where the book takes several of its metaphors from, does the same. Carmakers build very different models on the same base: chassis, suspension and components the driver never sees. Nobody buys a car for its floor pan, but that is what lets them launch more models, faster and at lower cost.

Harmonize without restricting: on top, different products (app, card terminal, payment link, Pix); underneath, a base that is the same for everyone with security, compliance, deployment, observability and sensitive data DIFFERENT · WHERE THE INNOVATION IS AppCard terminalPayment linkPix securitycompliancedeploy and rollbackobservabilitysensitive data THE SAME FOR EVERYONE · HARMONIZED BY THE PLATFORM
What needs to be the same so that teams can be different? Like a carmaker's shared chassis, nobody sees the bottom part, but it is what lets you launch more "models", faster.

The question that remains is: what needs to be the same so that teams can be different? Having ten ways to deploy doesn't make any product better. Having ten ways to design a checkout screen might. A platform should be firm in the first case and get out of the way in the second.

In payments, the bottom part is large: security, compliance, observability, handling of sensitive data, the way to release and roll back a change. These are exactly the parts no customer sees and no team should solve alone. That is where harmonization pays off the most.

Fruit basket or fruit salad?

This is my favorite metaphor in the book. Imagine a platform that puts together a wiki, a ticketing tool, a code repository and a build pipeline. Having everything in one place is convenient, but it is a fruit basket: each item stays separate, and the whole is not worth more than the sum of its parts.

A fruit salad is different. The ingredients are combined into a new product that solves something none of them solved alone. Not by chance, a kilo of fruit salad costs more than a kilo of fruit.

Fruit basket or fruit salad: in the basket, wiki, tickets, repository and pipeline sit side by side; in the salad, the combined pieces become a new capability, a new service in production the same day FRUIT BASKETFRUIT SALAD wikiticketsrepositorypipeline new service in production all in one place, each piece separatesaves clickscombined pieces become something newchanges what the team can do
Putting tools together is a basket: the whole is worth no more than the sum of its parts. Combining them into a new capability is a salad, and that is where a platform creates value.

Translating to day-to-day work: a platform that hands out a link to each tool is a basket. A platform that lets a team create a new service, with repository, pipeline, observability and security already wired, and put it in production the same day, is a salad. The first saves clicks. The second changes what the team is able to do.

Abstractions, not illusions

Every platform hides complexity, and that is what it is for. The risk, according to Hohpe, is hiding too much, or hiding the wrong thing. He puts it strongly: no logical layer can abstract away physical properties. The network has latency, the disk fills up, the service on the other side goes down.

It is a new take on Joel Spolsky's law of leaky abstractions: every non-trivial abstraction leaks at some point. Hohpe's example is the remote call that pretends to be a local call. It works well on the happy path and becomes an illusion at the first failure, because it hides exactly what the team would need to know: that the network is slow and that the answer may never arrive.

Abstraction and illusion: the illusion is a charge that looks like a local call and hides latency, timeouts and partial failure; the abstraction exposes the deadline, the idempotency key and the pending state ILLUSIONABSTRACTION charge(order) looks like a local call charge(order, idempotency_key, deadline) → approved · declined · pending network latencytimeout with no answercharge made, response lost HIDDEN explicit deadlinesafe retry, never charging twicepending state to reconcile later IN SIGHT works on the happy pathand deceives at the first failuresimplifies without pretendingthe network isn't there
"No logical layer can abstract away physical properties." In payments, the platform can make timeouts and retries easier, but it cannot hide them.

In payments, this matters a lot. Timeouts, retries, idempotency and consistency between systems are concepts the platform can make easier, but cannot hide. The product team needs to know that a call may be repeated, even if the platform takes care of the boring part. A good abstraction creates a vocabulary that makes sense in the domain. An illusion just postpones the discovery to the worst possible moment, which is usually an incident.

Mechanisms, not magic

Another idea from the book that changed how I talk about platforms: making things simpler isn't simple. "The platform will take care of it" is not a plan. Hohpe lists the concrete mechanisms a platform has to reduce the teams' effort:

  • Restricted choice: offering fewer options, well chosen.
  • Meaningful defaults: starting values that already solve most cases.
  • Assumptions and scope: deciding who the platform is for, and who it is not for.
  • Aggregation: putting together pieces that always go together.
  • Abstraction: creating a higher-level concept, without becoming an illusion.
  • Automation: taking repetitive work off the teams' hands.
  • Functional addition: offering something that would not exist without the platform.

These mechanisms connect directly to cognitive load, which is at the center of Team Topologies. Hohpe makes a criticism I found spot on: the "shift left" movement, bringing security, operations and compliance closer to development, has in many places turned into "pile left", piling everything onto developers. A good platform does the opposite: it takes real weight off. And just hiding parameters doesn't help: taking half the pieces out of a puzzle doesn't make it easier, it makes it impossible. You need to hand over a smaller, coherent puzzle.

A platform is a product: my concern with DevEx

This brings me to the point that occupies me the most. On our team, DevEx is the platform team that takes care of the developer experience: how a team creates a service, ships a change, finds documentation, understands what is happening in production. It is a team that can multiply the speed of all the others, or become one more place where people open tickets.

My concern with it is exactly what the book argues: a platform is a product. Hohpe devotes the last part of the book to this, in a chapter called Platform, Inc.: running a platform team is much like running a company. There is someone thinking about strategy, someone owning the product, someone building, someone giving support, and even someone doing marketing, because nobody adopts what they don't know about.

In practice, this means not stopping at delivery. A platform team that works as a project delivers the tool and moves on to the next one. A platform team that works as a product delivers and keeps looking: is anyone using it? Is it solving the problem we imagined? What do people do to work around it? What changed in the teams' lives after the delivery?

Platform as a product: a continuous cycle of discovering the teams' problem, delivering with the easy path being the right one, following adoption and workarounds, and measuring the outcome for teams, then discovering again platform as a product 1. Discover2. Deliver3. Follow up4. Measure which team problem?who is the customer?is the easy path the right one?usable without asking?who adopted it, by choice?who worked around it or gave up?what improved for the teams?DORA, load, first deploy
A project ends at delivery; a product continues after it. The question stops being "is it done?" and becomes "how will we know it worked?".

The questions I bring to my conversations with DevEx follow that cycle:

  • Before building: what team problem are we solving, and how do we know it is a real problem? Who is the customer of this delivery?
  • At delivery: is the easy path the right path? If using the platform takes more work than going around it, people will go around it.
  • After delivery: how many teams adopted it, and of their own will? How long did it take until first use? Who tried and gave up?
  • In the outcome: what improved for the teams that adopted it? Do they deploy more often, take less time to reach production, recover faster from failures?

The book has a line about mandating usage that I repeat often: making a platform mandatory tends to be a last-ditch effort to make the economics work, and often marks the beginning of its decline. Mandatory adoption hides exactly the information a platform team needs most: whether the product is good.

How to know it worked

Hohpe doesn't propose a closed dashboard of metrics, and I like that, because each context needs its own. But he offers two heuristics I use a lot.

The first is scale: a platform nobody uses creates no value at all. Adoption, especially voluntary adoption, is the first sign of life.

The second is the surprise test: if nobody built something on top of the platform that you hadn't foreseen, you probably built a service, not a platform. It is the same lesson as HTTP: a standard works when people do things with it that its authors never imagined.

To those two, I add what I learned from other books:

  • The DORA metrics, from Accelerate: deployment frequency, lead time from code to production, change failure rate and time to recover. They show whether the base is helping the flow or getting in its way.
  • Time to first deploy of a new service, which measures how much the platform shortens the beginning.
  • Cognitive load, asking the teams themselves how much of their day goes to things that are not their product.
  • Workarounds: every time a team solves on its own something the platform offers, that is feedback, and among the most honest kind.

What I take from this

  • A platform is not infrastructure under another name. It is an internal product, with customers, adoption and evolution.
  • Harmonizing is choosing what needs to be the same so that the rest can be different. It is not telling everyone how to work.
  • Prefer the salad to the basket. Putting tools together saves clicks; combining them changes what teams can do.
  • Abstract without deceiving. In payments, hiding latency and failure is asking to find out about the problem during an incident.
  • Delivery is only the beginning. A platform team's work continues after delivery: following up, measuring and adjusting.

Closing

I started studying platforms because I wanted to understand why some platforms speed teams up and others become just another queue. Hohpe gave me the vocabulary for it. The difference is almost never in the technology. It is in treating the platform as a product, harmonizing what needs to be the same and being honest about what cannot be hidden.

On our team, this became a question I ask every time DevEx delivers something new. It is no longer "is it done?", but "how will we know it worked?".

Sources