Which changes to a system should trigger a new or updated threat model?
answer
- Watch the design, not the diff
- New component, new caller, new data
- A boundary can appear with zero code
- Incidents kill assumptions the model trusted
basics
~20 sTrigger on architectural change, not code volume: a new component or service, a new trust boundary such as a new caller or tenant, a new class of data, and any incident that disproves a design assumption.
solid answer
~50 sI encode four triggers and put them where design changes get described. First, a new component or service, because it adds a process, a store and new flows. Second, a new trust boundary — a new caller, a new tenant, a new operator with access — which often appears with no code change at all: a single-tenant analytics product signing its first external customer has a tenant-to-tenant boundary before anyone writes multi-tenancy code. Third, a new class of data, because it changes what an attacker gains: an HR service that starts holding employee bank details now sits between an insider and salary payments. Fourth, a security incident, which is really a message that a modeled assumption was wrong. The wrong trigger is lines of code — a large refactor may change nothing about who can reach what, while a three-line access-policy edit can.
go deeper
Be able to name concrete triggers rather than saying 'whenever the design changes'. New service, new caller or tenant, new type of data, and after an incident is a complete answer at this level.
Explain why code volume is the wrong signal and give an example of a boundary appearing with no code, such as a single-tenant product taking its first external customer. Interviewers want the reasoning, not the list.
Show how the triggers actually fire in delivery: which template carries the prompts, who owns answering them, and what you deliberately excluded so the policy does not become 'model everything'.
Own the tradeoff between coverage and cost. Be ready to say which changes you consciously let ship unmodeled, how you would notice if that call was wrong, and who is accountable when a trigger is missed.
## What a trigger is, and why you need explicit ones A modeling trigger is the observable event that says *the threat picture of this system may have changed, so look again*. Triggers matter because threat modeling has no natural rhythm inside a delivery process. Nothing in a sprint reminds anyone to do it, so in the absence of written triggers teams fall into one of two failures: they model once at project kickoff and never again, or they try to model continuously until the practice collapses under its own weight. A trigger is not the same thing as a schedule. A schedule fires on the calendar whether or not the design moved; a trigger fires on a change to the design. ## Trigger on the design, not on the diff The most common mistake is using code volume as the signal. A four-thousand-line refactor that moves logic between classes inside one service may change nothing about who can reach what. A three-line edit to an ingress rule, a cloud trust policy or a queue's access control can hand a new actor a path to data they never had. So the question a trigger asks is not "did the code change a lot" but "did the answer to *who can reach what, and what would they gain* change". ## Four trigger classes worth writing down **A new component or service.** A new process, a new data store and new flows between them are new places for something to go wrong, and new flows are where trust boundaries usually land. **A new trust boundary.** This is the trigger teams miss most, because a boundary can appear with no new code. A previously single-tenant analytics product that signs its first external customer now has a boundary between tenants: a paying customer is a legitimate actor with credentials, and other customers' data is an asset that nothing in the original design was built to protect. The same shape appears when an internal-only service is opened to a partner network, when an operator group gains standing access, or when a workload starts running under an identity another team also controls. **A new class of data.** New data changes what an attacker gains, which changes which threats matter. A payroll platform that adds employee bank details to an HR service which previously held names and job titles has created a money asset where there was only a privacy asset. The plausible adversary shifts too: the realistic threat is a malicious insider in HR operations who already has legitimate read access and could redirect a salary payment, not an anonymous stranger on the internet. A model written before that data class arrived will not have considered integrity of payment details at all. **A security incident.** An incident is evidence that an assumption the design leaned on was false. Suppose a regional electricity utility finds that a stolen field technician's laptop held a shared meter-provisioning credential. Two design assumptions just died: that technician devices are trustworthy custody, and that provisioning identity is per-person and revocable. The consequence class here is the safety and availability of a physical process, not data theft. The value of the post-incident model is not documenting the incident — that belongs to the response record — it is finding every other place resting on the same assumption. ## What should not fire a trigger Dependency upgrades, cosmetic UI work, internal refactoring, adding capacity, and bug fixes that restore intended behaviour do not on their own change the threat picture. They earn a model only when they alter exposure, privilege or the data held. Keeping this list explicit is what stops a trigger policy from degenerating into "model everything". ## Making triggers operational A trigger only works if it sits where the change is described, not in a policy document nobody opens. In practice that means a short set of yes/no prompts on the design-doc or change template: does this add a component, a caller, a data class, or change who can reach an existing one? Keep it to a handful of questions — a long form gets auto-answered "no". Pair it with a named owner, because the third failure mode, after model-once and model-everything, is the trigger that everybody agrees with and nobody owns, so security hears about the new boundary after launch.
- Can a change that adds no code at all still require a threat model?Yes, and those are the ones teams miss. Signing the first external tenant onto a single-tenant product, opening an internal service to a partner network, granting an operator group standing access, or changing which identity a workload runs as all create or move a trust boundary with no application code involved. The trigger question is whether the set of actors or their reach changed, not whether a repository changed.
- Does upgrading a dependency trigger a model?Usually not. A version bump that keeps the same interfaces and the same reach does not change who can reach what. It becomes a trigger when the upgrade changes the trust picture — the library starts making outbound calls, adds a callback or plugin surface, requires broader privileges, or pulls in a new service the system now depends on at runtime.
- After an incident, do you re-model only the system that failed?Start there, but the payoff is elsewhere. Write down the assumption the incident disproved — for example that field devices hold no reusable credentials — then look for every other design resting on it. Re-modeling only the broken system fixes one instance; treating the falsified assumption as the trigger finds the siblings before someone else does.
A building inspector is called back for a new doorway into the vault or a new tenant on the floor, not for a repaint. Threat-model triggers work the same way: openings and occupants, not cosmetics.
saying these in an interview costs you the question
- Only new code triggers a threat model
- Access-policy and identity changes are not design changes
- One model at kickoff covers the whole project
- Only internet-facing systems ever need modeling
- A large refactor always deserves a fresh model