skip to content

What does a Postman mock server fuse when one collection is definition, documentation and stand-in at once?

level: middleimportance: must knowfreq 55%

answer

  1. Count what a single edit touches
  2. Documentation and double are the same bytes
  3. No seam means nowhere to catch it
  4. Edit right on requests reaches the replies
  5. Fusion of content, not of custody

basics

~20 s

A Postman mock server fuses the documented reply and the served reply into one saved example, so a single edit by anyone with collection edit rights moves documentation and stand-in together, with no diff or review on the consumer's side.

solid answer

~50 s

Because the stand-in answers with the collection's **own saved examples**, one stored artefact is the definition of what calls exist, the documentation a person reads, and the double a consumer's code talks to. The fusion is a statement about **what one edit touches**: change an example and the documented reply, the served reply, and every consumer currently pointed at the stand-in all change together, with nothing recorded in the consumer's history. The second half is the permission: since the replies are the collection, the right to change the replies *is* collection edit right — there is no separate custodian of the double. What it does **not** fuse is custody or fidelity. The document still lives in an account that is not your repository, and whether the canned reply still resembles the real service is a separate subject entirely.

go deeper

for a junior

Know the one-line version: the same saved example is what a reader sees and what a caller receives. Being able to say that the collection is the doc and the double at once is enough at this stage.

for a middle

Explain what one edit touches and why no seam exists to catch it, then name the permission consequence: editing requests and editing replies are the same right, so the blast radius includes other teams' builds.

for a senior

Demonstrate that you separate the two things the fusion joins from the two it does not. Content is fused; custody and fidelity are not, and each of those absences is a different production risk.

for a principal

Take a position on when the fusion is an asset and when it is a liability, and say what your organisation should keep in its own repository so a shared collection edit cannot block a delivery path.

## One document wearing three hats In the Postman arrangement, a mock server answers with the **examples already saved inside the collection** it was created from. Nothing is copied, exported or compiled into a separate stub definition. The consequence is that a single stored artefact simultaneously acts as: - the **definition** of what calls exist; - the **documentation** a human reads about them; - the **double** a consumer's code actually talks to. Interviewers reach for this leaf because that fusion is a genuinely two-sided design, and candidates usually see only one side of it. ## What "fused" actually means Fusion here is not a metaphor about tidy organisation. It is a statement about **what one edit touches**. When a saved example is changed: - the documented reply changes, because the documentation renders that example; - the served reply changes, because the stand-in answers from that example; - every consumer currently pointed at the stand-in inherits the change, without redeploying anything of theirs; - nothing in the consumer's repository records that anything happened. There is no seam at which somebody could have caught it, because a seam is precisely what the arrangement removed. ## The permission consequence The second half of the fusion is the one candidates miss. Because the replies are the collection's own examples, **the right to edit the replies is the right to edit the collection**. There is no separate custodian of the double. Anyone trusted to fix a request path, rename a folder, or tidy a header list is, by that same trust, able to change what the stand-in returns to a build. Compare that with how the same team treats its own code, and the asymmetry is stark. | | A change to your service's test fixtures | A change to the collection's examples | |---|---|---| | Where it is written | in your repository | in a hosted account | | Who may make it | anyone who can merge | anyone who may edit the collection | | What review it passes | your pull-request review | whatever that account applies | | Where it shows up | a diff, in history | nowhere on your side | | Who notices first | the reviewer | the consumer whose call fails | ## What the fusion buys It is not a trap; it is a trade, and the upside is what made the pattern popular: 1. **The doc cannot lie about the double.** In arrangements where documentation and stub are separate artefacts, they drift apart quietly. Here they are the same saved bytes, so drift between them is not expressible. 2. **The double costs nothing to author.** Somebody saved a real reply while exploring; that same reply is now the stand-in's answer. No second file, no second maintainer. 3. **Onboarding is one link.** A newcomer reads the collection and consumes the stand-in from the same place. ## What it does not fuse Be precise about the limits, because overclaiming is a red flag of its own: - it does not fuse the stand-in to **your** release cycle — the two move independently, which is exactly the problem; - it does not fuse the stand-in to the **real service** behind it. Whether the canned reply still resembles reality is a fidelity question owned by other material, and no amount of fusion inside the collection answers it; - it does not fuse **custody**. The document is in an account; your repository is not that account, and the two have separate membership. ## How to answer this in the room A complete answer moves through three beats: 1. **Name the source.** The replies are the saved examples in the collection, not a separately written stub definition. 2. **Name what one edit moves.** Documentation, the served reply, and every consumer at once — with no diff in the consumer's history. 3. **Name the permission.** Collection edit right is reply edit right; there is no second gate, so the blast radius of an ordinary collection tidy-up includes other teams' builds. Then take a position: the fusion is excellent while the stand-in is a **conversation aid** among people who all hold the same account, and it becomes a liability the moment it is load-bearing for a pipeline whose owners cannot see the edits.

  • What class of problem does this fusion genuinely eliminate?
    Disagreement between the documentation and the double. When a doc page and a stub are separate artefacts, they drift apart silently and a consumer builds against a reply no reader was shown. Here they are the same saved example, so that drift is not expressible. The tradeoff is that the same property removes every seam at which a change could have been reviewed.
  • Does the fusion also keep the stand-in aligned with the real service?
    No, and claiming so is a common overreach. Fusion is internal to the collection: the documented reply and the served reply cannot disagree with each other. Whether either still resembles the real dependency is a fidelity question owned by other material, and it is answered by comparing against that service, not by anything inside the collection.
  • Why is the permission half the part candidates miss?
    Because it converts an ordinary housekeeping action into a cross-team change. Tidying a header list or renaming a request is normal collection work, but the same right covers the examples the stand-in serves, so a routine edit can block somebody else's pipeline without the editor ever intending to touch it.

saying these in an interview costs you the question

  • Claims the fusion keeps the double aligned with the real service
  • Thinks documentation is generated from traffic the mock served
  • Assumes a publish or build step separates edit from serving
  • Believes the consumer's repository records the change somehow
  • Says a tighter permission removes the shared edit right