A structured analysis of potential threats
A threat model is a structured account of what could go wrong with a system on purpose, produced by reasoning about it before an attacker does. It turns security from a reactive scramble into a design activity: you map the system, enumerate how it could be abused, and decide what to do, all while the design is still cheap to change. The hard part is honesty, because a threat model is only as good as the team's willingness to imagine its own work failing.
The structured version of this thinking arrived with STRIDE, created by Loren Kohnfelder and Praerit Garg at Microsoft. On 1 April 1999 they circulated an internal paper, "The ThreatsThreatSecurityA specific security threatView reference → to Our Products," proposing six categories an analyst should walk through for each part of a system: Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege. Each category names a security property under attack, authentication, integrity, non-repudiation, confidentiality, availability, and authorisation, so STRIDE doubles as a checklist of what you are trying to protect. Microsoft folded it into its Security Development Lifecycle, and it remains the most widely taught threat classification in the field. Analysts typically drive it over a data flowData FlowEngineeringA data flow between systemsView reference → diagram, tracing how information crosses trust boundaries.
The framing matured under Adam Shostack, whose book Threat Modeling: Designing for Security (2014) reduced the practice to four questions: what are we working on, what can go wrong, what are we going to do about it, and did we do a good jobJobUserJob To Be Done: what the user is trying to accomplishView reference →. The phrasing is deliberate. "Working on" rather than "building" keeps the practice usable at any stage of a system's life, and the fourth question turns threat modelling into something you can improve rather than a box ticked once. Other structured methods sit alongside it, including attack trees, which decompose a single attacker goal into the steps that would achieve it.
A team is adding file uploads to a customer portal. They draw a data flow diagram: browser, upload service, virus scanner, object store. Then they walk STRIDE per element. Spoofing: can someone upload as another user? They find the signed URL does not check the caller's identity, so they add it. Tampering: can a file be swapped between scan and storage? Information disclosure: can a user guess another user's file URL? The object keys are sequential integers, so yes, and they switch to unguessable identifiers. Denial of service: a 5 GB upload could exhaust the scanner, so they cap size and add a queue. Each finding becomes a concrete change made in the design review, long before the featureFeatureProduct SpecificationA product capability or featureView reference → reaches users, where the same fixes would cost ten times as much.
In the Unified Product Graph, Threat ModelSecurityA threat model for the system anchors the security region as the activity that connects a product to its risksRiskComplianceA risk to the product or businessView reference →. A product runs one through threat_modelProductmodels threats withThreat Modelhierarchy. From the model, two distinct edges fan out: product_models_threats_with_threat_modelThreat ModelidentifiesThreathierarchy records the abuses imagined, and threat_model_identifies_threatThreat ModelsurfacesVulnerabilityhierarchy records the concrete weaknesses found, holding the design-time and discovered concerns apart. Governance closes the loop through threat_model_surfaces_vulnerabilitySecurity PolicyrequiresThreat Modelhierarchy, which encodes the rule that a system of a given sensitivity must be modelled before it ships. The structure mirrors Shostack's four questions: the model is the work, the connected threats and vulnerabilities are what could go wrong, and the controls hanging off them are the response.security_policy_requires_threat_model
Type-specific fields on BaseNode
methodologystringMethodology. `stride` = Spoofing, Tampering, Repudiation, Information Disclosure, DoS, Elevation of Privilege (OWASP standard). `dread` = Damage, Reproducibility, Exploitability, Affected users, Discoverability (numeric scoring). `pasta` = Process for Attack Simulation and Threat Analysis (7-stage). `attack_tree` = hierarchical tree of attack paths. @example "stride" is the most widely used methodology for web applications
scopestringWhat system, feature, or data flow is being analysed. @example "user authentication", "payment processing", "admin API"
last_reviewedstringISO date last reviewed. Models become stale as systems evolve. @example "2026-03-01"
participantsstringParticipants in the exercise. @example "Alice Chen (security lead), Bob Park (backend engineer), Carol Liu (architect)"
threat_countnumberThreats identified. Key metric for scope and completeness. @example 12
idstringrequiredUnique identifier (UUID)
typeNodeTyperequiredDiscriminator for the entity type
titlestringrequiredDisplay name
descriptionstringOptional detailed description
statusstringLifecycle status
tagsstring[]Freeform tags for filtering
5 phases — initial: proposed · template: APPROVAL
4 edge types connected to this entity.
product_models_threats_with_threat_modelsecurity_policy_requires_threat_modelthreat_model_identifies_threatthreat_model_surfaces_vulnerability