skip to content

Your build depends on a Postman mock server whose replies changed with no commit in your repository — how do you respond?

level: seniorimportance: should knowfreq 45%

answer

  1. The evidence is not in your history
  2. Ask people before reading logs
  3. Establish who may edit the collection
  4. A dependency changed without your graph changing
  5. Own a copy of what you depend on

basics

~20 s

Look outside your history: a Postman mock server answers from examples in a collection held in somebody's account, so an edit there changes a build dependency with no commit and no review. Establish custody and ask the holders.

solid answer

~50 s

Stop bisecting your own history: the evidence cannot be there. The stand-in answers from **saved examples in a collection held in an account**, so a change lands with no commit of yours, no diff and no reviewer to ask on your side. Capture what the stand-in returns now versus what your consumer expected, establish which account holds the collection and who may edit it, and ask those people directly — most incidents close there, because someone edited an example while doing unrelated work. Then change what the pipeline depends on rather than promising more care: keep the expected replies in your own repository, assert them in your own tests, and reserve the hosted stand-in for exploration. This is a **custody** incident, not a fidelity one; nothing about the real service is implicated by somebody editing a document.

go deeper

for a junior

Know where to start looking: the replies are examples inside a collection held in an account, so the change is not in your repository and no amount of reading your own diff will find it.

for a middle

Explain the mechanics that make it silent — collection edit right is reply edit right, and there is no build step between an edit and what a caller receives, so nothing on your side records the change.

for a senior

Show the investigative sequence and then change the dependency rather than the promise: capture the difference, establish custody, ask the holders, pin a copy you own, and write the decision where your team reviews things.

for a principal

Frame the recurrence: decide which delivery paths may depend on content your organisation cannot see change, and make that rule cheap to follow by giving teams an owned alternative.

## Why your own history explains nothing The first move is to stop looking where the evidence cannot be. A Postman mock server answers with the **saved examples inside the collection** it was created from, and that collection lives in an **account**, not in a file your repository tracks. So when the replies change, there is no commit to blame, no diff to read, and no reviewer to ask on your side. Candidates who spend the first stretch bisecting their own history are answering a different incident. The right framing to say out loud: **the dependency changed without your dependency graph changing.** Your build pinned a URL, not a version of a reply set. ## What actually happened Almost always one of these, and they are distinguishable by asking, not by digging: - somebody with collection edit rights **edited or replaced a saved example** while working on something unrelated; - somebody **added or reordered** requests, and the example the stand-in now answers from is not the one it answered from yesterday; - the collection was **replaced wholesale** by an import or a bulk tidy-up; - **access changed** — the account, or your ability to reach it, is no longer what it was. Note what is *not* on that list: your code, your deploy, and the real service behind the stand-in. Whether the canned reply still resembles the real dependency is a **fidelity** question owned by other material; here, the stand-in changed because a person changed it. ## The sequence to run 1. **Capture the difference.** Record what the stand-in returns now and what your consumer expected. That artefact is the only evidence you will own at the end. 2. **Establish custody.** Identify which account holds the collection and who is admitted to edit it. This is a people question, and it is the fastest one. 3. **Ask the holders, plainly.** "Did anyone touch the examples in this collection?" — in most incidents this closes it inside minutes. 4. **Decide the immediate unblock.** Pin your consumer to a copy of the replies you hold yourself, so the pipeline stops depending on an answer you cannot see change. 5. **Write the decision down** where your team reviews things, since the cause will never appear in your history. ## Symptom to source | What you observe | Where the change happened | Where to look | |---|---|---| | Reply body differs, same call | a saved example was edited | the collection's holders | | A call that worked now misses | requests added or reordered | the collection's holders | | Everything fails at once | access or the account changed | your account relationship | | Only your branch fails | your consumer, after all | your own diff | ## Hardening the arrangement The fix is rarely "be more careful"; it is to change what the pipeline depends on: - **Keep the expected replies in your repository.** Then a change is a diff, reviewed by you, revertible by you — and the hosted stand-in goes back to being a convenience. - **Assert your expectation in your own tests**, so a changed reply fails in a place you own rather than three services downstream. - **Move the stand-in you depend on to something you start and operate**, if the pipeline genuinely needs one. That is a different subject with its own tooling; the point here is the custody change, not the tool. - **Reserve the hosted stand-in for exploration** and for consumers who can tolerate a surprise. - **Agree who announces edits**, if you must keep the dependency. It is a weak control — it is a promise, not a gate — but it is better than silence. ## What not to conclude - Do **not** conclude the stand-in "rebuilt itself" from the real service. It answers from saved examples; nothing regenerates them for you. - Do **not** conclude that a stricter permission would have prevented it. The reply set is the collection, so the edit right is the ordinary collection edit right — the arrangement has no separate gate to tighten. - Do **not** conclude that a retry, a longer timeout or a cache flush is a fix. The dependency's content changed; making the call again gets the new content again. - Do **not** treat it as a fidelity incident. Nothing about the real service is implicated by somebody editing a document. ## The senior signal What an interviewer listens for is whether you reach for **custody** rather than for a debugger. The strong answer says: the reply set is not mine, the edit is not in my history, the people who can change it are the people who can edit that collection — so my remediation is to own a copy of what I depend on, not to investigate harder next time.

  • Why is a retry, a cache flush or a longer timeout not a fix here?
    Because nothing failed transiently. The dependency's content changed, so calling again simply fetches the new content again. Treating it as flakiness buries a governance problem under a workaround and guarantees the same incident returns, next time in the middle of a release rather than in a build somebody was watching.
  • What single change most reduces the exposure without abandoning the collection?
    Keep the replies you depend on in your own repository and assert them in your own tests. A change then arrives as a diff you review and can revert, and any divergence fails in a place your team owns. The hosted stand-in stays useful for exploration, where a surprise costs one person one re-run.
  • How would you tell this apart from a fidelity problem?
    By asking what moved. If a person edited an example, the stand-in changed and the real service is untouched — a custody incident. If the real service changed and the canned reply stayed put, that is fidelity, a separate subject with its own remedies. The remediation differs completely, so name which one you are in before proposing fixes.

saying these in an interview costs you the question

  • Bisects the team's own commits looking for the cause
  • Claims the mock rebuilt itself from the live service
  • Proposes retries or a cache flush as the remedy
  • Assumes a tighter permission would have prevented the edit
  • Files it as flakiness and closes it without changing the dependency
  • Confuses this with the stand-in drifting from the real service