4 Steps, Repeat: threat modeling is a dance

Sean Juroviesky

CypherCon 9.0 (2026)

Overview

In his engaging CypherCon talk, "4 Steps, Repeat: threat modeling is a dance," Sean Juroviesky, a security engineer and BurbSec organizer, demystifies the often-intimidating process of threat modeling. Juroviesky argues that rather than being an esoteric, complex endeavor, threat modeling can be boiled down to a simple, iterative four-step process, making it accessible and actionable for any development team. Through a series of humorous yet alarmingly realistic scenarios, he illustrates how these fundamental steps can uncover critical vulnerabilities in modern applications, from basic API design flaws to the complex security implications of Artificial Intelligence (AI) and monolithic repository (monorepo) architectures.

Watch on YouTube

Visual summary for 4 Steps, Repeat: threat modeling is a dance by Sean Juroviesky
Visual summary for 4 Steps, Repeat: threat modeling is a dance by Sean Juroviesky

Key moments

  1. 3:19 The four easy steps of threat modeling
  2. 6:55 Adding loyalty program, exposing user reset tokens
  3. 12:20 Why monorepos are a security nightmare
  4. 18:15 AI stylist, social media data, and GDPR concerns
  5. 23:20 The critical need for API traffic monitoring
  6. 27:40 OASP and other resources for API DevSecOps

4 Steps, Repeat: threat modeling is a dance

Speakers: Sean Juroviesky, Security Engineer

Conference: CypherCon

YouTube: https://www.youtube.com/watch?v=xFEmAWieDY8

Overview

In his engaging CypherCon talk, "4 Steps, Repeat: threat modeling is a dance," Sean Juroviesky, a security engineer and BurbSec organizer, demystifies the often-intimidating process of threat modeling. Juroviesky argues that rather than being an esoteric, complex endeavor, threat modeling can be boiled down to a simple, iterative four-step process, making it accessible and actionable for any development team. Through a series of humorous yet alarmingly realistic scenarios, he illustrates how these fundamental steps can uncover critical vulnerabilities in modern applications, from basic API design flaws to the complex security implications of Artificial Intelligence (AI) and monolithic repository (monorepo) architectures.

The core message of the talk is that effective security is not about a single, exhaustive review, but a continuous "dance" of building, questioning, mitigating, and validating. Juroviesky's presentation serves as a crucial reminder for organizations to integrate security early and often into their development lifecycle, challenging the prevalent "vibe coding" culture where features are rapidly deployed without adequate security consideration. This iterative approach is particularly vital in today's fast-paced development environments, where new functionalities, third-party integrations, and emerging technologies like AI constantly introduce novel attack surfaces.

The talk resonates deeply with security professionals grappling with evolving threats and the challenges of embedding security practices within agile development teams. By simplifying threat modeling into a repeatable framework, Juroviesky empowers attendees to proactively identify and address risks, emphasizing practical strategies for API security, data privacy, and architectural decisions. His lighthearted yet pointed delivery underscores the critical need for vigilance and a structured security mindset, ultimately aiming to prevent the kind of "sanity point" depletion that security engineers often experience.

Background

▶ Watch: The four easy steps of threat modeling (3:19)

The perception of threat modeling as a daunting, time-consuming exercise often deters its consistent application in many organizations. Historically, threat modeling has been seen as a specialized task, typically performed late in the development cycle, if at all, leading to reactive security postures. This challenge is exacerbated by the rapid pace of modern software development, characterized by continuous integration/continuous deployment (CI/CD) pipelines and a culture of "vibe coding," where developers quickly implement features, sometimes without rigorous testing or security review.

Juroviesky grounds his approach in the foundational work of Adam Shostack, distilling threat modeling into four core questions:

  1. What did you build? (Understanding the system's architecture and components)
  2. What can go wrong? (Identifying potential threats and vulnerabilities)
  3. How do we stop that or slash respond to that? (Designing and implementing countermeasures)
  4. Did we do a good enough job? (Validating the effectiveness of the mitigations)

These questions form the bedrock of an iterative security process, designed to be applied repeatedly as a system evolves. The speaker illustrates this through the fictional company "Boxes Stuff," which continually adds new features, forcing an ongoing re-evaluation of its security posture. This narrative structure effectively highlights why threat modeling cannot be a one-time event but must be a continuous "dance" reflecting the dynamic nature of software development. The talk implicitly addresses the tension between business demands for speed and the critical need for robust security, a tension that often results in overlooked vulnerabilities and increased risk.

Key Findings

▶ Watch: Why monorepos are a security nightmare (12:20)

Sean Juroviesky's talk distills several key findings regarding effective threat modeling and common pitfalls in modern software development:

  • Threat Modeling is Iterative and Accessible: The central finding is that threat modeling doesn't need to be complex. By breaking it down into Adam Shostack's four questions and applying them iteratively ("4 Steps, Repeat"), organizations can embed security into their development lifecycle effectively. This approach makes threat modeling a continuous "dance" rather than a one-off, overwhelming task.
  • "Vibe Coding" is a Major Security Risk: The practice of rapidly developing and deploying features without adequate security review or testing—dubbed "vibe coding"—is a recurring theme and a significant source of vulnerabilities. This often results in exposed internal APIs, verbose error messages, and insufficient authentication mechanisms.
  • API Security is Paramount: APIs are highlighted as critical attack surfaces. Key vulnerabilities include verbose responses (returning excessive data like full user objects or reset tokens), exposed internal APIs (endpoints meant for internal use being publicly accessible, as seen in the Microsoft Midnight Blizzard example where tens of thousands were removed), and lack of robust authentication and authorization (open APIs, improper permissions for new features).
  • Monorepos Introduce Significant Security Challenges: While offering perceived development efficiencies, monorepos inherently complicate security by hindering the enforcement of least privilege and creating single points of failure in CI/CD pipelines. They make it difficult to segment permissions, can break security scanners (like SAST and DAST) due to complexity, and amplify the impact of compromised open-source libraries or CI/CD runners across the entire tech stack.
  • Data Privacy and Consent are Non-Negotiable, Especially with AI: The introduction of an "AI stylist" demonstrates the severe privacy implications of collecting and processing user data (e.g., social media scraping) without explicit consent, clear data retention policies, and adherence to regulations like GDPR's Right to Explain. The speaker emphasizes the importance of Data Processing Addendums (DPAs) for managing third-party data handling.
  • Proactive Monitoring and Guardrails are Essential: Beyond initial mitigations, continuous monitoring of API traffic for suspicious spikes and calls is crucial for early detection of attacks. Establishing governance boards and building guardrails for new technologies (especially AI) and use cases helps to contain risks from the outset.
  • Leverage Community Resources: Organizations like the Open Web Application Security Project (OWASP) provide invaluable tools and educational materials (e.g., OWASP Juice Shop, Cornucopia, Malware Monsters) for learning and implementing secure development practices.

Technical Deep Dive

▶ Watch: AI stylist, social media data, and GDPR concerns (18:15)

Juroviesky's talk provides a practical, scenario-based technical deep dive into common security challenges, framed within the four iterative steps of threat modeling.

Step 1: What did you build? (Data Flow Diagram - DFD)

The foundation of threat modeling begins with understanding the system. Using the fictional "Boxes Stuff" company, Juroviesky illustrates a basic Data Flow Diagram (DFD): customers order items, interacting with an order system, user database, order database, logistics service, and payment gateway. This visual representation clarifies data movement and system boundaries, which is crucial for identifying potential points of failure.

Step 2: What can go wrong? (Identifying Threats)

This step involves scrutinizing the DFD for vulnerabilities. Juroviesky highlights several common attack vectors:

  • Data Minimization and Third-Party Risk: The initial DFD shows sensitive data (like PII and PCI data) flowing to external services. The risk here is non-compliance and data exposure. For PCI DSS compliance, payment data should ideally be offloaded to specialized third-party payment gateways to minimize scope. For PII, establishing a Data Processing Addendum (DPA) with third parties and ensuring data minimization are critical.
  • API Vulnerabilities - Verbose Responses and Exposed Endpoints:
  • Loyalty Program Example: A new loyalty service is added, but an exposed endpoint returns the full user object, including a reset token, without requiring authentication. This is a classic example of a verbose response vulnerability, providing attackers with sensitive information. Juroviesky cites a real-world example where McKinsey was breached because an AI service inadvertently included a token in its response.
  • Internal API Exposure: Many organizations expose internal APIs to the public web unnecessarily. Juroviesky references Microsoft's response to the Midnight Blizzard attack, where they removed "tens of thousands" of internal API endpoints after realizing they were only called internally. Publicly exposed internal APIs are "yummy tokens to be eaten by your Pac-Man" if not properly secured.
  • Lack of Authentication and Authorization: The talk emphasizes that any API endpoint, especially those exposing sensitive data or functionality, must require authentication upfront. Open APIs are susceptible to data scraping and DDoS attacks. Furthermore, new features added to existing API endpoints often inherit broad permissions, leading to Role-Based Access Control (RBAC) issues. New features should ideally use discrete endpoints with specific, granular permissions.
  • Monolithic Repository (Monorepo) Security Risks:
  • Lack of Least Privilege: A monorepo, by its nature, struggles with least privilege. If a developer can contribute to the repo, they often have access to the entire codebase, making it impossible to segment permissions for different teams (e.g., SEO engineers contributing to critical backend services).
  • Single Point of Failure for CI/CD: A single CI/CD pipeline for a monorepo means a failure or compromise (e.g., malicious pre-build, compromised runner) can affect the entire tech stack.
  • Security Scanner Limitations: Complex monorepos can overwhelm SAST and DAST tools, causing them to time out or only report a fraction of potential issues.
  • Open-Source Poisoning: With "top 10 npm libraries" frequently compromised, a monorepo significantly increases exposure to supply chain attacks.
  • Proposed mitigations like Virtual File Systems (VFS) or isolated pipelines for monorepos are met with skepticism by Juroviesky, who views them as "GitHub with more steps," questioning the core benefit of a monorepo if such complex permission management is required.
  • AI and Data Privacy: The "AI stylist" scenario brings GDPR and privacy to the forefront. Collecting user social media data for personalization raises concerns about consent, data retention periods, and the Right to Explain (the legal obligation to justify data processing). This highlights the need for a governance board and strict guardrails for AI deployments.

Step 3: How do we stop that or slash respond to that? (Mitigation)

Juroviesky outlines practical mitigations for each identified threat:

  • API Security: Don't fork code; return the minimum amount of information necessary in API responses; require authentication for all queries; use discrete endpoints for new features with appropriate permissions; and don't expose internal APIs to the web.
  • Data Privacy: Implement DPAs for third-party data processing; minimize data shared; ensure clear consent mechanisms and data retention policies.
  • Monorepo: While critical of the concept, Juroviesky mentions potential mitigations like VFS for creating "mini repos" with strict read/write controls and isolating pipelines at the folder level. However, he emphasizes that these often negate the perceived benefits of a monorepo.

Step 4: Did we do a good enough job? (Validation)

This step involves reviewing the effectiveness of the mitigations and identifying what might have been missed. This iterative loop is crucial, as new features or architectural changes can introduce new risks, necessitating a return to Step 1. The talk concludes with the ongoing "sanity point" depletion of the security engineer, underscoring the continuous nature of this challenge.

Demo / Proof of Concept

▶ Watch: The critical need for API traffic monitoring (23:20)

While Sean Juroviesky's talk did not feature a live code demonstration or a traditional "proof of concept" in the sense of exploiting a vulnerability in real-time, the entire presentation served as an extended, narrative-driven demonstration of the threat modeling process.

The "Boxes Stuff" company, with its evolving product line, acted as the primary case study. Juroviesky iteratively walked the audience through the four threat modeling steps as the company introduced new features:

  1. Initial E-commerce Platform: Demonstrated the basic DFD and initial concerns around PCI and PII data with third-party logistics.
  2. Loyalty Program: Introduced an API vulnerability where a publicly exposed endpoint returned sensitive user data and reset tokens, illustrating the dangers of "vibe coding" and verbose responses.
  3. Monorepo Adoption: Highlighted the architectural and permission control challenges introduced by moving to a monorepo, including issues with least privilege and CI/CD security.
  4. AI Stylist: Explored the complex ethical and legal implications of AI-driven data collection (e.g., social media scraping), focusing on consent, data retention, and GDPR's Right to Explain.

Through these scenarios, Juroviesky effectively demonstrated how to apply the four-step threat modeling methodology, what specific vulnerabilities and architectural risks to look for, and why this process needs to be continuous. The "demo" was less about showing a hack and more about showing the thought process and the practical application of security principles in a dynamic development environment. This narrative approach made the complex topic relatable and provided concrete examples of security challenges faced by real-world organizations.

Defensive Implications

▶ Watch: OASP and other resources for API DevSecOps (27:40)

The insights from "4 Steps, Repeat" offer critical defensive implications for organizations aiming to strengthen their security posture:

  • Embrace Iterative Threat Modeling: Integrate Adam Shostack's four questions ("What did you build?", "What can go wrong?", "How do we stop/respond?", "Did we do a good enough job?") as a standard, recurring practice throughout the Software Development Life Cycle (SDLC). This shifts threat modeling from a one-time gate to a continuous, evolving process, enabling proactive risk identification rather than reactive incident response.
  • Implement Robust API Security Best Practices:
  • Strict Authentication and Authorization: Mandate authentication for all API endpoints, especially those exposed externally. Enforce least privilege principle, ensuring users and services only have access to what is strictly necessary.
  • Data Minimization: APIs should return only the absolute minimum amount of information required for the intended function. Avoid verbose responses that leak sensitive data like full user objects, reset tokens, or unnecessary PII.
  • Dedicated Endpoints: For new features, create discrete API endpoints with specific, tailored permissions rather than extending existing ones, which often inherit overly broad access controls.
  • Internal API Protection: Audit and restrict access to internal APIs. If an API is only called internally, it should not be publicly exposed.
  • API Key Management: Require users to sign terms and conditions and obtain specific API keys for access, preventing anonymous data scraping and abuse.
  • API Monitoring: Implement comprehensive monitoring for API traffic. Set up dashboards and alerts for suspicious activity, unusual traffic spikes (e.g., at midnight), or abnormal error rates. Timely alerts are crucial to prevent prolonged breaches, as highlighted by the example of organizations discovering issues only after receiving increased AWS bills.
  • Address Monorepo Security Challenges: If a monorepo architecture is adopted, organizations must actively mitigate its inherent security risks. This includes exploring solutions like Virtual File Systems (VFS) to create logical "mini repos" with granular read/write controls, and isolating CI/CD pipelines at the folder level to prevent a single compromise from affecting the entire codebase. However, a critical evaluation of whether these mitigations negate the benefits of a monorepo is essential. Ideally, segmenting into smaller, domain-specific repositories provides better security isolation.
  • Prioritize Data Privacy and Consent: For any feature involving user data collection, particularly with emerging technologies like AI, prioritize explicit user consent. Establish clear data retention policies and ensure compliance with regulations such as GDPR, including the Right to Explain data processing decisions. Implement Data Processing Addendums (DPAs) with all third-party vendors handling sensitive data.
  • Combat "Vibe Coding" with Guardrails and Governance: Establish a governance board for reviewing new feature requests and use cases, especially those involving AI or significant data handling. Develop and enforce guardrails (e.g., secure coding standards, automated security checks) early in the development process to guide developers and prevent security shortcuts. Require actual software developers to implement critical features, even if initial "vibe coding" prototypes are used with non-production data.
  • Leverage Open-Source Security Resources: Encourage security teams and developers to utilize and contribute to projects from the Open Web Application Security Project (OWASP). Resources like OWASP Juice Shop provide hands-on learning, while projects like Cornucopia and Malware Monsters offer frameworks for interactive security training and incident response simulations.

Key Takeaways

  • Threat modeling is an iterative "dance," not a one-time chore. Apply the four questions (What did you build? What can go wrong? How do we stop/respond? Did we do a good enough job?) continuously throughout the development lifecycle.
  • APIs are critical attack surfaces that demand rigorous security. Implement strong authentication and authorization, minimize data in responses, use discrete endpoints for new features, and actively monitor API traffic for anomalies.
  • "Vibe coding" and rapid feature deployment without security review are major sources of vulnerabilities. Establish guardrails, governance boards, and ensure proper testing to prevent insecure code from reaching production.
  • Monorepos introduce significant security challenges, especially regarding least privilege and CI/CD integrity. Carefully weigh the trade-offs and implement robust mitigation strategies like VFS or isolated pipelines, or consider alternative architectural patterns.
  • Data privacy, consent, and GDPR compliance are paramount, particularly with AI and external data harvesting. Ensure explicit consent, clear data retention policies, and transparency (Right to Explain) in all data processing activities.
  • Leverage community resources like OWASP for continuous learning and practical tools. Projects like Juice Shop, Cornucopia, and Malware Monsters provide invaluable frameworks for improving security knowledge and practices.

About the Speaker(s)

Sean Juroviesky is a security engineer who champions practical and accessible security practices. He is also a prominent organizer for BurbSec, a community-driven security conference, which he credits with significantly impacting his career. Juroviesky is a parent to two twins and maintains a humorous, self-deprecating demeanor, often referencing his dwindling "sanity points" in the face of common development challenges, a nod to the Cthulhu mythos. His presentation style is engaging and analytical, blending technical insights with relatable anecdotes and a clear passion for making security understandable and actionable.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Juroviesky repackages Adam Shostack's foundational four questions into a narrative walkthrough for developers who still don't get basic threat modeling. It's a competent, accessible primer on why 'vibe coding' and monolithic CI/CD pipelines are a nightmare for least privilege. If you're building an AppSec program from scratch, it's a decent baseline, but there is zero novel research here for practitioners.

Heather Calloway (CISO) — SOLID

A competent, practical refresher for engineering teams on applying Shostack’s four-question threat modeling framework to modern development problems like 'vibe coding' and AI integrations. It won't reshape your security strategy, but it’s exactly the kind of baseline operational discipline our development leads need to be enforcing.

→ Top-rated talks at CypherCon 9.0 (2026)

All talks from CypherCon 9.0 (2026)