Mark changes in assumptions
A trust boundary marks a change in the assumptions made about data or operations. In a shared-document service, a browser-supplied owner=A field is not proof that A owns the document. The API distinguishes an external claim from ownership information obtained through an authoritative source. Two boxes in a diagram do not automatically define one universal kind of boundary. Ask who can create or change a value and why a later component is entitled to rely on it. Even within one process, parsing external input and using the resulting information for permission decisions require explicit contracts. Moving the same claim to another server does not transform it into a verified fact; annotate architecture diagrams with reasons for trust.
Trace actor, resource and operation separately
Decompose an update request into actor A, resource D and the update operation. The browser can select D, but the actor should come from a verified session rather than an arbitrary user_id field. Obtain D’s owner and sharing policy from the source the design treats as authoritative. This provenance trace exposes an error that ordinary type validation cannot catch: a perfectly well-formed identifier may still name someone else’s resource. Authentication establishes an actor; authorization decides whether that actor may perform this operation on this target. Keep those results distinct and follow which verified facts support each decision. Repeatedly overwriting one variable with both untrusted and verified values makes this reasoning unnecessarily difficult.
Do not confuse transport protection with authorization
HTTPS does not make a caller-chosen user_id a truthful identity claim. An encrypted channel can faithfully deliver a value deliberately selected by an unauthorized actor. Similarly, an internal network location does not justify granting every incoming request the same powerful authority. Which service was authenticated, which user it acts for and where resource permissions are checked remain separate questions. Transport confidentiality, service identity and actor-specific authorization address different premises. This lesson does not prescribe a new identity platform; it prevents assigning extra guarantees to a mechanism simply because its name sounds protective. When explaining a mitigation, separate protection of data in transit from verification of the actor, intent and resource-specific permission involved in an operation.
Inspect alternate paths to the same asset
Authorization on the main body API does not cover a preview, search result, history view or cache that returns the same information by another route. A checked boundary is not evidence that every path to an asset has been checked. Cached content after revocation also raises the question of when current policy is consulted. Logging external input creates another flow: the eventual log viewer interprets those values in a new output context. Storage does not automatically make them harmless or authoritative. Extend the diagram with retention, reuse and investigation flows where they affect the protected asset. The purpose is not exhaustive infrastructure detail, but avoiding an unnoticed path from an asset to an observer.
Follow responsibility through one request
For one request, tabulate what the browser claims, what the API verifies and what the store returns. B may authenticate successfully yet still lack permission to update A’s document. Hiding an update button does not demonstrate that a directly submitted API request was rejected. Compare an authorized update by A, an unauthorized update by read-only B and an unauthenticated request. Inspect state changes and response content, including partial changes or protected data returned on rejection. Diagnostic records should not unnecessarily contain document bodies or session secrets. Assigning a concrete responsibility to each component reduces the gap in which two components each assume that the other performs the decisive check.
Exercise: select the authoritative identity
A request contains user_id=A and document_id=D, but its verified session identifies B. The authorization actor is B, not the externally claimed A. Treat D as the requested target and decide B’s permission using the resource policy the design trusts. Now suppose a separate check establishes that D exists. That still does not establish permission to return its body: existence and access are different facts. Finally add a preview API returning information from D and assign the necessary check to that path too. For every added arrow, explain whose claim arrived, which fact was verified and what action became permitted afterward. The permission-boundary experiment turns this trace into an explicit policy table and executable tests.