When is it defensible for a delivery path to depend on a Postman mock server hosted in an account you do not hold?
answer
- It is a custody question, not tooling
- Distance between editors and the pager
- Exploration versus a blocking delivery path
- Price the exit before taking the dependency
- Own the replies your pipeline asserts
basics
~20 sDepending on a hosted Postman mock server is defensible while the account holder sits inside your accountability boundary and the exit is cheap. For a delivery path other teams depend on, own the reply set yourself.
solid answer
~40 sTreat it as a **custody** decision, not a tooling preference. The stand-in answers from saved examples in a collection held in an account, so depending on it delegates the content of a dependency, its change control, its timing and its audit trail to editors you may not manage. That is a fine trade for exploration, onboarding and demos, where a surprise costs one person one re-run. It is a poor trade for a path that blocks other teams, because the first sign of a change is a consumer failing mid-run, with no diff of yours to read or revert. My conditions: the holder is inside the same accountability boundary, my own tests assert the replies I depend on, and someone named owns the collection. Price the exit before taking the dependency.
go deeper
Know the shape of the concern: the replies live in an account rather than your repository, so somebody outside your team can change what your build receives. That alone is worth saying.
Explain what depending on it delegates — content, change control, timing and the audit trail — and why the first sign of a change is usually a consumer failing rather than a review comment.
Give conditions rather than a verdict: whose tests assert the replies, who owns the collection, and what your team does the day a reply changes without warning.
Own the boundary rule and its economics. Say where the line sits between exploration and a blocking delivery path, price the exit in work, and make the safer option the cheaper one so the rule needs no enforcement.
## The decision, stated honestly A Postman mock server answers with the **saved examples inside a collection**, and that collection sits in an **account**. Putting it on a delivery path — a build, a release gate, a demo that must not fail, an integration another team relies on — means accepting that **the content of a dependency is governed by whoever may edit that collection**, under whatever review that account applies, with no diff and no revert on your side. The principal-level answer is not "never" and not "sure, it is convenient". It is a rule about **where the accountability boundary sits**. ## What you are actually delegating Name the pieces, because "we use their mock" hides all of them: - **Content.** What the dependency returns is decided by editors you do not manage. - **Change control.** Your pull-request review, code owners and branch protection do not apply. - **Timing.** A change lands when they save it, not when you release. - **Evidence.** After an incident, your history explains nothing; the record is in their account. - **Availability of the arrangement itself.** Your access to the account is a relationship, not an artifact you hold. - **Exit.** Leaving means rebuilding the reply set somewhere you control and repointing every consumer. ## Exploration versus delivery path | | Exploration and demos | A delivery path | |---|---|---| | Cost of a surprise | someone re-runs a call | a pipeline blocks other teams | | Who is affected | the person clicking | everyone downstream | | Who notices first | the same person | a consumer, mid-run | | Acceptable custody | any account | one inside your boundary | | Verdict | excellent fit | own the reply set yourself | The line in that table is the whole answer. The arrangement is genuinely good at the left-hand column: the examples already exist, the documentation and the double cannot disagree, and nobody has to operate anything. It is weak in the right-hand column for reasons that have nothing to do with quality and everything to do with **who holds the pen**. ## A checklist you can defend 1. **Is the account holder inside your accountability boundary?** If the same organisation is answerable for both the collection and the pipeline, the risk is a coordination problem. If not, it is a supply relationship, and that is a different conversation owned by vendor-trust material. 2. **Would a silent change be caught by something you own?** If your own tests assert the expected replies, a surprise fails in your yard. If not, it fails in a consumer's. 3. **What is the exit cost, measured in work?** Rebuilding the reply set plus repointing consumers. If you cannot describe that work, you have not evaluated the dependency. 4. **Who is paged when it breaks?** If your team is paged for a change your team cannot see, the arrangement is mis-shaped. 5. **Is there a cheaper arrangement with the same benefit?** Often keeping the expected replies in your repository gives you most of the value with none of the custody problem. ## The honest counter-argument Push back on your own answer, or you sound dogmatic: - Homegrown stand-ins **also** rot, and they cost engineering time nobody funds. A hosted arrangement that costs zero authoring is a real saving. - The fusion of documentation and double removes a whole class of drift — the doc and the stub cannot disagree when they are the same saved bytes. - For a team that already lives in that account every day, the "somebody else's account" framing is theatre: it is *their* account. The judgement is therefore about **distance**, not about tooling. The further the editors are from the people paged for the pipeline, the worse the arrangement gets, and it gets worse quietly. ## How to land it in the room Give a position and its conditions, in this shape: - **Yes**, while the stand-in serves exploration, onboarding and demos — the fusion is a genuine win there and I would not rebuild it. - **Yes with conditions**, when the account holder is the same organisation that owns the pipeline: my own tests assert the replies I depend on, and someone named owns the collection. - **No**, when a pipeline other teams depend on would be blocked by an edit my organisation cannot see, review or revert. There I want the reply set in a repository, under the same review as the code that depends on it. Then say the exit cost out loud. A principal-level answer always prices the way out, because the way out is what everybody forgets to budget until the day it is needed.
- What does the exit cost consist of, concretely?Rebuilding the reply set in something you control, then repointing every consumer that currently aims at the stand-in, plus finding consumers nobody remembered. Teams routinely price the first item and forget the second and third, which is why an easy dependency becomes an expensive migration exactly when access is being lost and there is no time to do it calmly.
- Is a homegrown stand-in automatically the better choice?No, and saying so is dogmatic. One you operate costs authoring, hosting and maintenance that nobody funds, and it rots. The hosted arrangement reuses examples that already exist and keeps documentation and double identical by construction. The judgement is about distance between the editors and the people paged, not about which tool is superior.
- How would you make the rule cheap for teams to follow?Give them an owned alternative that is easier than the risky path: a place to keep expected replies in the repository, a test helper that asserts them, and a default in the project template. Rules that require extra work get quietly ignored; a rule attached to a ready-made, lower-effort option gets adopted without enforcement.
It is borrowing a neighbour's spare key cabinet: perfectly fine while you both live in the same house, and a serious problem once your front door depends on a cabinet they can rearrange.
saying these in an interview costs you the question
- Bans the arrangement outright without pricing the alternative
- Ignores who holds the account and who is paged
- Never states the exit cost of the dependency
- Assumes a stricter permission removes the shared edit right
- Treats convenience during exploration as evidence for pipeline use