18 November 2026

Security Design Review: What It Is and How to Run One

Reza Khosravi

Table of Contents

Security Design Review: What It Is and How to Run One

Your team is planning a new login flow. The ticket looks straightforward, a coding assistant can generate most of the implementation, and everyone wants to start building. Then someone asks what stops an attacker from trying passwords repeatedly, and the team realizes nobody specified rate limiting.

That's the value of a security design review: catching a missing decision while you can still change the plan. But the approval can't be the end of the work. When developers and coding agents keep changing the system, security needs to follow those changes into tickets, pull requests, and deployments.

What a Security Design Review Is and Why Timing Matters

Say the login team catches that missing rate limit during a short design discussion, before anyone writes code. The engineers can agree on abuse controls, recovery behavior, and verification tests without undoing an implementation.

A security design review is a documented assessment of a system's architecture, security requirements, risk model, and proposed mitigations before implementation is finished. Think of an architect checking structural plans before the foundation is poured. You're examining whether the proposed structure is safe, not just whether someone built it neatly.

Review the decisions before they become dependencies

NIST's Secure Software Development Framework places design review within its Produce Well-Secured Software practice group, calling for security requirements, design-stage risk analysis, and verification that the design addresses identified risks. It also calls for documented findings and corrections when requirements aren't met.

A threat model supports that assessment by describing what could go wrong. The review adds the decision: whether the proposed controls are adequate, what must change, and who owns any remaining risk.

A diagram explaining the importance of conducting security design reviews early to reduce costs and risks.

Understand what late discovery changes

An IBM security presentation citing NIST and the Ponemon Institute reproduces historical remediation estimates of approximately $80 per defect during development, $240 during build, $960 during QA/testing, and $7,600 in production.

Those figures aren't a current pricing model. Recalibrate them against your labor costs and release process rather than treating them as a guaranteed saving.

The useful lesson is the mechanism. Before implementation, a team can change an interface on a diagram. After release, the same finding might require database changes, API redesign, migration planning, regression testing, emergency releases, and customer communication.

Practical rule: Run a review whenever a change alters trust boundaries, data stores, or authentication, even if the feature looks small.

Early review doesn't mean waiting for perfect documentation. Bring enough architecture detail to identify consequential decisions, mark unknowns explicitly, and assign someone to resolve them before those assumptions become difficult to reverse.

Traditional Reviews Versus Continuous In-Workflow Reviews

In a traditional review, an architect writes a document, the team discusses it, and someone signs off. Developers then adapt the implementation as requirements change. Unless someone updates the document, the approved design gradually stops describing the actual system.

That's design drift, not necessarily careless engineering. A new queue, service account, or external integration can invalidate an earlier assumption without looking like a major architectural change.

Microsoft's Security Development Lifecycle guidance requires threat models during design, including components, interactions, data flows, and prioritized threats translated into security requirements. It also requires maintaining those models as software changes.

Compare the operating models

Traditional review versus continuous in-workflow review

DimensionTraditional reviewContinuous in-workflow review
TimingOnce, before build startsRepeated as tickets, repos, and services change
ArtifactPoint-in-time document or slide deckLiving threat model tied to repos and tickets
Feedback channelScheduled meeting and sign-offComments in Jira, Google Docs, GitHub, or the IDE
Drift handlingOften found at audit or incidentFlagged when design and code diverge
EvidenceMeeting notes and a signatureTraceable link from each decision to code

The continuous model resembles a navigation app rather than a paper map surveyed once. Teams refresh security context from tickets, design documents, repositories, and service metadata, then surface relevant feedback where developers already work.

For financial-services teams deciding how broadly to assess a change, Glentorion's change risk guidance for FCA-regulated firms offers useful context for connecting technical changes with wider operational impact.

Keep collaboration where it adds value

Continuous review doesn't mean sending every edit to a security engineer. Tools should identify meaningful changes, preserve their context, and route unresolved questions to the right person. Otherwise, teams replace meeting overload with notification overload.

A meeting still suits a new, high-risk system when engineers need to reason together about unfamiliar dependencies or competing controls. The difference is what happens afterward: the decision remains connected to implementation instead of disappearing into meeting notes.

Review Areas Every Design Should Cover

A useful finding explains a route to harm, not just a missing control. Record the asset or function, attack precondition, design weakness, consequence, mitigating requirement, verification method, and residual risk.

NIST SP 800-160 directs teams to select security-modeling techniques and analyze system states or conditions that could lead to loss. Apply that engineering approach to trust boundaries, authorization, security protocols, cryptographic mechanisms, and failure states, using explicit assumptions about attackers and impact.

Ask questions that produce evidence

Review areas, the question each one answers and the evidence to keep

Review areaQuestion to askEvidence to keep
Trust boundariesWhere does data cross from a less trusted zone to a more trusted one?Data-flow diagram
Authentication and authorizationWho can act on what, and is it enforced on the server?Access matrix
Data handlingWhat sensitive data is stored, logged, or sent to third parties?Data classification record
Token and session lifecycleHow are tokens issued, rotated, and revoked?Lifecycle specification
Failure behaviorWhat happens when a dependency fails or times out?Failure-mode notes
Abuse controlsHow are rate limits and misuse detected?Control list with thresholds
Third-party dependenciesWhat is added, including transitive packages, and was it reviewed?Dependency review record

A checklist is a prompt for analysis, not proof that the system is safe. An access matrix, for example, becomes useful when it distinguishes ordinary users, administrators, service identities, and access across customer accounts.

Apply the questions to password reset

For a password-reset flow, draw the boundary between the browser and identity service. Treat browser-supplied account identifiers as untrusted, and specify which server-side checks bind the request to the intended account.

Next, examine reset-code guessing and repeated email requests. Define rate-limiting behavior, token expiry, single-use enforcement, and invalidation after successful recovery. Keep reset tokens out of application logs and third-party telemetry.

Then ask what happens when the email provider times out. A retry mustn't accidentally reactivate an invalid token or produce contradictory recovery states. Record how the system handles duplicate requests and delayed delivery.

A control isn't verified because its name appears in a document. Specify the observable behavior that would prove it works.

For example, a test should attempt to reuse a consumed reset token and confirm rejection. Finish the review only when every high-risk threat has a named verification test and a residual-risk owner, with unresolved implementation work tracked explicitly.

Roles, Triggers and Sign-Offs

Trigger review when a change introduces:

  • Identity changes: A new authentication or authorization flow.
  • External connections: An integration or third-party dependency.
  • Sensitive storage: A new category or location of sensitive data.
  • Public exposure: A new public API.
  • Boundary changes: A different trust relationship between components.
  • Agent privileges: An AI agent gaining write access to code or infrastructure.

Review roles and what each one contributes

RoleContribution
Feature ownerDescribes the change and the data it touches
Engineering leadExplains the architecture and trade-offs
Product security engineerRuns the threat analysis and signs off high-risk items
DevelopersAnswer questions and supply implementation evidence
Compliance ownerKeeps artifacts for SOC 2 or ISO 27001 audits

Allocate depth rather than adding gates

In a 2026 Linux Foundation survey of 308 cybersecurity practitioners, 58% said teams release code faster than security reviews can keep up, while 60% said AI coding tools caused their organizations to add more external dependencies.

Adding mandatory meetings can lengthen the queue without improving coverage. Instead, let routine changes follow automated policy checks with recorded evidence, while product security engineers examine consequential boundary changes and unresolved architectural risks.

Every tier needs a decision record, but not every tier needs manual approval. Record the approving person or authorized policy, the decision, supporting evidence, and any exception's owner and expiry.

Separate security advice from business risk acceptance. The engineering owner commits to implementation work; an accountable business or data owner accepts consequences the organization chooses to retain.

A team introducing payment-card storage should receive a full review. A purely presentational CSS change that doesn't affect data, permissions, or security behavior shouldn't enter that queue.

How to Run a Security Design Review Step by Step

Use a change-scoped procedure rather than attempting to reassess the entire architecture whenever someone opens a ticket. Keep the record beside the work so developers can answer questions without reconstructing context.

  1. Open intake. Start from the ticket or design document. Record the proposed change, owner, affected services, and data it touches.
  2. Assemble the artifacts. Attach an editable data-flow diagram, security requirements, and access matrix. Mark unknowns rather than presenting guesses as facts.
  3. Assign the risk tier. Escalate changes involving trust boundaries, authentication, sensitive data, or an AI agent with write access. Explain the impact behind the tier.
  4. Build threat chains. Connect each high-risk threat to its asset, attack precondition, weakness, consequence, mitigating requirement, verification method, and residual risk. Our threat modeling process guide provides a companion workflow for that analysis.
  5. Check coverage. Walk through every review area and mark it covered, not applicable with justification, or open. Don't treat missing information as a pass.
  6. Make the decision. Approve, require revisions, or accept residual risk through an accountable owner. Give temporary exceptions an expiry and a remediation condition.
  7. Record sign-off. Preserve the approver, decision date, artifact versions, and linked work items. Conditional approval must say what developers can and can't release.
  8. Verify after build. Check approved decisions against code, tests, infrastructure configuration, and deployed behavior. A closed implementation ticket alone isn't evidence.
  9. Reopen for material changes. Reassess affected decisions when repositories, tickets, or services change security-relevant behavior.

Keep intake lightweight: Routine changes need quick routing, not a miniature architecture committee.

The full path belongs to high-risk work. For low-risk changes, reuse established patterns and capture automated evidence, while preserving a clear escalation route when developers encounter something the existing policy doesn't cover.

Tooling, Pull Requests and Policy-as-Code Enforcement

Where a review runs and what each point catches

Where it runsWhat it catchesCan block a merge
IDE with AI assistantInsecure patterns while code is writtenNo
Ticket in JiraMissing security requirements at intakeNo
Design documentUnclear trust boundaries or data flowsNo
Pull requestPolicy violations against approved decisionsYes, if policy requires it
DeploymentDrift between approved design and deployed configurationNot retroactively; can block release if configured

At DevArmor, we bring real-time security design feedback into design docs, Jira, and pull requests. Reviews can start directly from Jira, even when tickets are messy, and every review is traceable to an approved design decision or threat model.

That traceability matters more than the comment's location. A developer should be able to tell which requirement applies, why it exists, and what evidence will satisfy it.

Translate decisions into executable rules

Policy-as-Code turns an approved requirement into a testable rule. For example, a service handling payment data might require encryption at rest, while a public endpoint might require a defined rate-limiting configuration.

Specify scope carefully. A rule that checks whether encryption is enabled doesn't prove that application permissions or key access are correct. Our Policy-as-Code guide explains how executable policy connects requirements with delivery checks.

The workflow below shows where those checks can support prevention rather than retrospective reporting.

A flow chart illustrating how policy-as-code enforcement integrated into development stages blocks insecure software releases.

Introduce blocking gradually

  1. Write a rule from an approved decision, including its scope and expected evidence.
  2. Run it in report-only mode over representative changes.
  3. Review false positives with the owning team, especially inherited configurations and shared infrastructure.
  4. Enable merge blocking only for high-severity rules with dependable checks and clear remediation.
  5. Record exceptions with an owner, justification, expiry, and compensating controls.

Don't confuse a merge gate with a deployment gate. A deployment check can stop a release or flag runtime drift, but it can't undo an earlier merge. Configure each control at the point where the team can still act on its result.

Enforcement at code review makes an architectural decision checkable. Human review remains necessary for requirements that automated checks can't reliably establish.

Reviewing AI-Generated Designs Without Slowing Delivery

Code scanning isn't enough when a coding agent implements the wrong security model correctly. A scanner may find dangerous syntax yet miss that the application trusts a user-supplied account identifier or never revokes a refresh token.

A 2026 analysis discussed by the FAIR Institute reported vulnerabilities in 26 of 30 pull requests produced by three coding agents, including broken access control, insecure JWT defaults, missing rate limiting, and non-revocable refresh tokens. The recurring failures were attributed to design choices the agents subsequently implemented, not just isolated coding mistakes.

The human reviewer needs to inspect the decisions behind the generated implementation, not only the diff.

A designer reviewing a login flow wireframe with a magnifying glass while a security report displays on laptop.

Review what the agent changed

Apply the same engineering questions to agent output, focusing attention on changed behavior:

  • Boundaries and permissions: Did the agent move enforcement into the browser or grant a service broader access?
  • Data handling: Did it add logging, telemetry, storage, or a third-party data flow?
  • Token lifecycle: Did generation, rotation, expiry, or revocation change?
  • Failure behavior: Does a timeout deny access safely, or trigger an unintended fallback?
  • Abuse controls: Can retries, bulk actions, or repeated requests bypass intended limits?
  • Dependencies: Did the agent introduce packages or external services outside the approved design?

Give the agent approved constraints before generation, not just findings afterward. Our AI threat modeling guide connects that context with threat analysis for AI-assisted development.

Preserve the origin of assumptions

Record whether each consequential assumption came from a human, the agent, or inherited system context. For example, an agent might infer that an internal API is trusted because an existing client omits authentication. That inference needs validation, not silent promotion into a requirement.

Iterative prompting creates another review problem. A request to simplify recovery or reduce database calls can change the approved token lifecycle across sessions.

Compare the final design with the approved baseline, then verify consequential assumptions against code and deployment. Reopen the review when those differences alter a trust boundary or session behavior.

For regulated teams, scanner logs alone don't establish accountable oversight. Preserve named approvers, recorded assumptions, test evidence, and explicit risk decisions so an auditor can reconstruct who authorized the behavior and why.

Measure Coverage and Pick Your First Review Scope

A completed-review count tells you how much process occurred, not whether the team examined the right changes. Measure coverage, decision quality, and queue health together so a faster review path doesn't hide missed risks.

Track:

  • Review latency: Median time from submission to decision, separated by risk tier.
  • Boundary coverage: The share of changed trust boundaries reviewed.
  • Verification readiness: High-risk threats with named verification tests.
  • Exception health: Owners, expiry dates, and overdue remediation.
  • Dependency coverage: Direct and transitive additions assessed.
  • Early findings: Design weaknesses identified before coding.
  • Implementation alignment: Approved decisions verified in deployed code.

Make the evidence reusable

DevArmor provides coverage metrics, drift detection, and per-release attestations, so teams don't have to assemble every reporting view by hand. We also document security architecture and decisions as audit-ready artifacts supporting compliance work such as SOC 2 and ISO 27001.

Those artifacts support an audit; they don't replace effective controls or establish certification on their own. Preserve the underlying evidence so reviewers can distinguish an approved intention from verified behavior.

Start with a bounded change

  1. Select a service with a recent, security-relevant design change and an available engineering owner.
  2. Run the review using the intake procedure and review-area checklist.
  3. Express an approved decision as a report-only policy rule.
  4. Measure review latency and false positives across a representative release cycle.
  5. Expand into another risk tier only when coverage remains credible and engineers can resolve findings without unnecessary handoffs.

Agree on success criteria before the pilot. Look for complete evidence, actionable findings, manageable queues, and clear ownership, rather than treating fewer alerts as an automatic improvement.

Start with a high-risk change this quarter, not the whole portfolio. Choose a scope small enough to finish and important enough to expose whether the review process works under real delivery pressure.


DevArmor connects continuous threat modeling, in-workflow security design reviews, and implementation verification so approved decisions remain linked to delivery. Visit DevArmor to explore how your team can review an upcoming high-risk change and turn its security requirements into traceable checks.

Table of Contents

Subscribe