Skip to content

Product Builder Interview Daily — 2026-11-14: Technical PM

Nov 14, 20261 min
TL;DRToday's core framework classifies API changes: adding a field is safe, renaming or retyping one is breaking, and breaking changes get handled with a dated, auto-pinned versioning scheme instead of a forced migration deadline. The practice question has engineering wanting to change a field 200 customers already depend on.

Look up & save

Loading dictionary…

🌏 中文版

Today's Focus

A Technical PM interview rarely tests whether you can write code. It tests whether, when engineering hands you a technical constraint, you can tell the difference between "there's genuinely no way around this" and "there's no way around this one specific approach." copilotinterview.com's breakdown of TPM interviews puts it bluntly: the technical round exists to find out where your understanding actually stops, because interviewers keep going a few levels deeper to check whether you're reasoning or just naming concepts. Today's drill uses one of the most common versions of that test: engineering says a field has to change, hundreds of customers already depend on the old one, and you need the new feature to ship anyway.

Core Frameworks

Framework 1: classify the API change before you argue about it

Not every "change to the API" carries the same risk. Classify it first, and the right move follows:

Change typeExampleImpact on existing customers
New endpointA brand-new APIAffects no one — safe
New fieldA response gains a field that never existed beforeAffects no one — safe
Rename or retypeA boolean field becomes an enumAny existing code reading that field breaks — a breaking change
Change a defaultA field that used to be omitted now ships by defaultDepends on client code, but usually breaking too

Framework 2: handle breaking changes with dated, auto-pinned versions

A genuinely breaking change doesn't mean you have to stop and coordinate every customer onto the same upgrade schedule. Stripe names versions by release date (for example, 2017-05-24). The first time an account calls the API, it gets pinned to whatever version is current; every call after that keeps the same behavior contract unless the customer actively opts into a newer one, either by setting the Stripe-Version header on a single request or upgrading the account's pinned version in the dashboard. Compared to a traditional v1/v2 major-version scheme, the difference is that each change is small, so customers never get hit with one giant bundle of incompatible changes at once.

Put the two together and the split is clear: whether a change counts as breaking is a technical call, and that stays with engineering. Whether a new feature justifies forcing existing customers to upgrade right now is a business trade-off, and it's the PM's job to solve it with a mechanism — not a one-time negotiation that has to happen again next time.

Today's Practice Question

The Question

"You're the PM for a B2B API platform. Engineering wants to change a field's type from a boolean (verified) to a more expressive enum (status, with values like verified, pending, failed), because a new feature needs to distinguish between 'under review' and 'review failed' — something the boolean can't express. The problem: over 200 enterprise customers have integration code that reads this boolean field directly, and changing its type or name will break their parsing outright. The CEO wants this feature shipped next quarter. How do you move this forward?"

(Source: self-authored, modeled on Stripe's real 2014 change from a bank account's verified boolean to a status field — see "Today's Case" below.)

How to Break It Down

  1. Clarify the problem: first confirm whether engineering genuinely needs to overwrite the existing field, or whether that's just the first idea that came up. If a new, independent field can express "under review" and "failed," there's no breaking change to argue about in the first place.
  2. Define who's affected: which customers depend on this field, how much of total call volume or revenue they represent, and what the ratio of new to existing customers looks like — that sets the real cost of forcing an immediate switch.
  3. Structure the analysis: apply the change-classification framework. Renaming or retyping a field is breaking, full stop. Check whether adding a new field instead can satisfy the new feature's requirements while leaving the old field untouched.
  4. Propose a plan: add an independent status field (additive, no impact on existing customers), keep verified returning exactly what it always has, and build the new feature on top of status without waiting on any customer migration. If verified genuinely needs to be retired later, that becomes a separate, dated version upgrade customers opt into on their own timeline.
  5. Define success: the new feature ships this quarter, zero of the 200+ existing integrations break, and whether the old field eventually retires stays a separate timeline from this release.

A Sample Answer (how to actually say this in the interview)

First, check whether this is really a dead end. "When I heard 'we need to change the field type,' my first question to engineering was: if we add an independent status field and leave the existing verified field completely alone, does that satisfy the new feature? It turned out it does — the original proposal to change the existing field was just the first idea that came up, not something the new feature actually required."

Split the two decisions apart. "Whether the new feature ships and whether the old field eventually retires don't need to be tied together. This quarter we only add the new field: verified keeps returning exactly what it always has, and the new feature is built entirely on status. All 200-plus existing integrations are unaffected, and the CEO's timeline doesn't get stuck waiting on a migration negotiation."

Leave a path to retirement, but don't force it. "If we do want to retire the old field eventually, I'd suggest Stripe's dated-version approach: an account gets pinned to whatever version is current the first time it calls the API, and any customer who wants the newer version opts in on their own schedule instead of facing a hard deadline for everyone. That way we can keep evolving the API without re-fighting the same coordination battle every time."

Self-Check Checklist

Use this table to check whether your answer missed anything important:

Check itemCovered?
Problem framing: did you check for an additive alternative before assuming there's no way around it
Scope of impact: which customers, how much of the business, gets hit by the breaking change
Framework used: did you classify the change as safe vs. breaking before arguing about it
Concrete plan: shipping the new feature and retiring the old field are separate timelines
Success metric: zero breakage on existing integrations, feature ships on schedule
Bonus: did you show that "is this breaking" is engineering's call, but "do we force customers to upgrade for this" is the PM's business judgment

Today's Case

Stripe's 2014 switch from a verified boolean to a status field — and the versioning system it grew into

Stripe's engineering blog post "APIs as infrastructure: future-proofing Stripe with versioning" (Brandur Leach, 2017) describes a concrete example: an early bank-account endpoint used a boolean field called verified to show verification status. In 2014, Stripe replaced it with a status field, because they needed to express more states than a boolean could hold. The change itself was breaking — any existing code reading verified would stop working. Stripe's answer wasn't to force every customer onto the same cutover date. They used the dated, incrementally-breaking versioning scheme they already had: an account gets pinned to the current version the first time it calls the API, and nothing changes afterward unless the customer actively opts in via the Stripe-Version header or a dashboard upgrade. The post notes this scheme let them ship nearly a hundred backward-incompatible upgrades over six years without ever running a traditional v1/v2 migration.

Interview angle: this case directly answers "how do you keep evolving a product or API without burning the trust of existing customers" questions. The point isn't demonstrating that you know API-design vocabulary — it's showing you understand that "is this breaking" and "do we force an immediate upgrade" are two separate decisions, and the second one can be solved with a mechanism instead of a negotiation every time.

Further Reading

References