Back to all articles
The Shared PlatformPart 06
Org designTeam TopologiesIncident managementPlatform engineering

The Shared Platform, Part 6: Organising Teams Around a Shared Core

Janahan Thavendran4 min read

TL;DR

  • Ownership must be settled before an incident, not during it; the opening 2 a.m. event-bus outage is an illustrative scenario.
  • Stream-aligned teams own products end to end; the platform team owns the paved road and core services, and never becomes the release gate.
  • When a core service is down, the platform on-call restores it whoever caused it; blame waits for the post-mortem, which should also ask why the bus accepted a malformed payload.
In this article

The Shared Platform, Part 6 of 7 · Who owns what when one core serves every product.

It's 2 a.m. and the core event bus goes down. Half the platform stops with it.

The on-call engineer for Product A gets paged first. They look, see the event bus is dead, and pass it on: not ours, page the platform team. The platform on-call opens the logs and finds that Product A published a huge, malformed payload that broke the consumer. Not ours either, they say. Product A broke the contract.

Both of them are right. Thirty minutes later the bus is still down, and enterprise clients are on the phone.

I've worked on payment releases, rollback plans and production incidents in a product organisation of more than a hundred engineers. In that kind of organisation, ownership has to be settled before something breaks, not while it's breaking.

Melvin Conway put it plainly in the 1960s: organisations design systems that mirror their own communication structures. If you want a coherent shared core, the teams around it have to be shaped to match.

Two kinds of team

The Team Topologies model, from Matthew Skelton and Manuel Pais, gives a useful split.

Stream-aligned teams own a product end to end: its UI, its workflows, its customers. The platform team exists to make their work easier. It provides a paved road of infrastructure, CI/CD and core APIs, so product teams don't have to think about those things to ship.

That makes the platform team's customers internal. Its job is to reduce how much every product team has to carry in their heads.

Draw the ownership line where the code line is

The platform team owns the paved road and the core services: identity, billing, the event bus. Product teams own what they build on top. If you run an extensibility framework for enterprise clients, give it to a dedicated group inside the platform team, because it sits on the boundary and will be pulled both ways.

When the architecture diagram and the org chart disagree, one of them changes to match the other. It's usually the architecture.

The platform provides the tools, not the release gate

Product teams should release when they're ready. The platform team provides the pipeline, the checks and an easy way to roll back. It should never be the queue every release waits in.

If a product team needs a platform engineer in the room to ship, the paved road isn't finished yet. Rollback especially should be a feature of the road, not a heroic effort on the night.

Route incidents by ownership

Run blameless post-mortems, and make the paging rules boring. If the core database or the event bus goes down, the platform on-call is paged. If a product feature breaks, the product team is paged.

The hard cases sit in between, like that 2 a.m. outage. Decide them in advance. When a core service is down, the platform on-call owns restoring it, whoever caused it. The product team joins the same call to fix its side, and one named person owns what clients hear. Who broke the contract is a question for the post-mortem, not the incident.

That post-mortem should also ask why the bus accepted a malformed payload at all. Checking every event against its schema when it's published, and rejecting the bad ones at the door, is exactly the kind of promise a shared core should keep.

One owner for every part

A shared core needs a shared responsibility model. In practice that means every part has exactly one owner, and everyone knows who that is before anything breaks. When everyone owns something, nobody does.