Back to all articles
APIs as a ProductPart 03
API productsInternal platformsPlatform strategyTeam topology

APIs as a Product, Part 3: API as a Product Internally, Not Just Externally

Janahan Thavendran3 min read

TL;DR

  • Internal teams fail on an API in the same ways partners do, but instead of churning they route around the core and copy its logic.
  • Give both doors one contract written first, the same docs, the same per-consumer health view and the same deprecation plan.
  • Judge internal requests by the same test as partner requests, and settle priority clashes openly with the trade-off written down.
In this article

APIs as a Product, Part 3 of 10 · Your own teams are API customers too.

A team needs one field the menu API doesn't return. They have a release in two weeks, and asking the core team to add it means joining a queue. So they copy the logic they need into their own service and move on. Nobody tells the core team, because from their side nothing has gone wrong.

Months later, the rule behind that field changes. Every partner picks it up through the core API the same day. The internal product doesn't, because it is no longer asking the core. It is asking its own copy.

The partner integrations are right. The app the company built itself is wrong.

Why internal consumers get less care

Most teams that take API products seriously do it for partners. Partners have contracts, they can leave, and their problems arrive with a commercial manager attached. Internal teams get a different deal. The docs are thinner because "they can just ask". Changes land on them with less warning because "they can't go anywhere". Nobody tracks their error rates, because they aren't customers.

But internal teams fail in exactly the same ways partners do. An unclear contract confuses them. A surprise breaking change breaks them. A deprecation they hear about late costs them a sprint. The only real difference is what they do when they're frustrated. A partner churns. An internal team routes around you: it copies the logic, reads from somewhere it shouldn't, or builds a private endpoint. That is how point-to-point integrations come back, one deadline at a time.

The same discipline for both doors

Once the core API layer served our own products and partners, we stopped running two standards. The contract was written first, for everyone. The docs internal teams used were the same docs partners used, with internal-only endpoints marked. Internal consumers appeared on the same per-consumer health view as partners, so a team with rising errors got a conversation, not silence. And every version change went through the same deprecation timeline and the same communication plan, whoever was calling.

Some things stayed different on purpose. Partners went through certification before go-live. Internal teams could sit in roadmap discussions, which partners couldn't. That made it more important, not less, to judge their requests by the same test we used for partners: does this help the next ten consumers, or only this one?

The hardest conversations were about priority. An internal product with a launch date wants the core to change now. A partner with an app in review wants it not to change at all. Treating both as customers of the same product didn't make that choice easy. It made it a decision we took openly, with the trade-off written down, instead of one decided by whoever pushed hardest.

API as a product isn't only for people outside the company. Your own teams are the first consumers you'll lose, and you won't notice, because they'll still be in the building.