Secure SDLC for a small team: which security check belongs at each stage, and what it leaves behind
A secure software development lifecycle puts a security activity at each stage of delivery and keeps the evidence that it happened.
This guide sets out, for a team of a handful of people shipping a web application, what belongs at requirements, design, build, review, test, release and after release, what has to be true before work moves on, and who decides when it is not. It comes with a stage-gate map, a release checklist, a worked example and a small script that checks a release record for missing evidence.
In this guide
Secure delivery stage-gate map, release checklist and release-evidence check
An illustration written for this page, not a client's process. A seven-stage map for a small team that links each stage to the artefact it leaves, where that artefact is kept, a pass and a fail condition, who decides and the source behind the row.
How to use itHide the instructions
It comes with a fourteen-question release checklist, one invented feature carried through every gate, and a release record with a script and tests that check it for missing evidence. The script needs Node.js only, and it checks that evidence was recorded, not that the work was done well.
secure-sdlc.txt
ILLUSTRATION ONLY. The stage-gate map and the checklist are this page's advice for a team of a handful of people shipping one web application. The swim school, its parent portal, the feature, the roles, the dates, the issue and run numbers and every result in the worked example and the release record are invented for this page. They are not a client's process or a client's results. The release-evidence check is a small script written for this page. It checks that evidence was recorded, not that the work behind it was done well.
HOW TO USE THIS
1. Read the map with the people who ship your application, and mark what you already do under another name.
2. Copy the secure release checklist to wherever your team approves releases.
3. Read the worked example to see what each artefact holds once it is filled in.
4. Run the release-evidence check on the example record, then keep a record of the same shape for your own releases.
==== PART 1: THE STAGE-GATE MAP ====
One block per stage. Each block says what is done, the artefact the stage leaves, where that artefact is kept, the check that lets work move on, who decides, what happens on a fail, and the source behind the row.
Source key. SSDF is NIST SP 800-218, the Secure Software Development Framework, version 1.1, dated February 2022; an identifier such as PW.7.2 is one of its tasks, given here with NIST's wording in Australian spelling and this page's punctuation, so NIST's brackets, dashes, item numbers and "e.g." are written out as plain clauses. ASVS is the OWASP Application Security Verification Standard 5.0.0, cited by requirement number and level. NIST says the order of the practices and tasks in its table is not intended to imply the sequence of implementation. Placing tasks at stages is this page's arrangement, and the pass and fail conditions, the roles and the "on a fail" steps are this page's advice.
STAGE 1: REQUIREMENTS
What is done: For each feature, write down what must not be possible once it ships. Give every such requirement an acceptance criterion that a test or a reviewer can decide.
Artefact: A requirements list with security acceptance criteria.
Kept in: The repository beside the code, such as one file per feature under docs/security/requirements/, or the feature's ticket, so it can be read as it stood at the release commit.
Pass when: Every requirement that touches sign-in, permissions, personal data, money or messages sent to people has at least one acceptance criterion that names who acts, what they attempt and what the application does in reply.
Fail when: A requirement states a goal with no check, such as "invitations are safe", or its criterion has no way to fail.
Who decides: The product owner.
On a fail: Work on that part of the feature does not start. The requirement is rewritten, or the feature is narrowed until what is left can be checked.
Source: SSDF PO.1.2 (identify and document all security requirements for organisation-developed software to meet, and maintain the requirements over time) and PW.1.2 (track and maintain the software's security requirements, risks and design decisions). ASVS 8.1.1 (Level 1) asks for authorisation documentation that defines rules for restricting function-level and data-specific access, and 2.1.3 (Level 2) for documented expectations for business logic limits and validations.
STAGE 2: DESIGN, WITH THE THREAT MODEL
What is done: Sketch how data moves through the change, list what could go wrong where it crosses from one level of trust to another, and record a response to each risk. Someone who did not write the design then reads it against the requirements.
Artefact: A threat register, one for the application with rows added for each feature, and the design note or sketch it refers to.
Kept in: The repository, such as docs/security/threat-register.md, versioned with the code.
Pass when: Every row added for the feature has a response that names the requirement that mitigates it or the exception that accepts it, and a person who did not write the design has recorded that they reviewed it.
Fail when: A risk has no response, a mitigation names no requirement, or the only reviewer is the designer.
Who decides: The technical lead. When the technical lead wrote the design, the developer who reviewed it decides.
On a fail: The design returns to its author. If a requirement cannot be met, the design or the response to the risk changes, and the change is recorded.
Source: SSDF PW.1.1 (use forms of risk modelling, such as threat modelling, attack modelling or attack surface mapping, to help assess the security risk for the software), PW.1.2, and PW.2.1 (have a qualified person or people who were not involved with the design, and/or automated processes instantiated in the toolchain, review the software design to confirm and enforce that it meets all of the security requirements and satisfactorily addresses the identified risk information).
STAGE 3: BUILD
What is done: Write the code against the requirements. Decide on every third-party component the change adds or upgrades before it is merged.
Artefact: A dependency decision record: one row for each component added or upgraded, with why it is needed, the version pinned in the lockfile, the date known advisories were checked and what was found, and who decided.
Kept in: The repository beside the lockfile, such as docs/security/dependency-decisions.md.
Pass when: Every direct dependency the release adds or upgrades has a row, and no component is past the remediation time frame the team has written down.
Fail when: A package appears in the lockfile with no row, or a component with a published vulnerability is past the time frame with no accepted exception.
Who decides: The technical lead.
On a fail: The merge waits. The component is removed, replaced or updated, or the decision goes to the release approver as an exception.
Source: SSDF PW.4.1 (acquire and maintain well-secured software components, such as software libraries, modules, middleware and frameworks, from commercial, open-source and other third-party developers for use by the organisation's software) and PW.4.4 (verify that acquired commercial, open-source and all other third-party software components comply with the requirements, as defined by the organisation, throughout their life cycles). ASVS 15.1.1 (Level 1) asks for the time frames to be documented and 15.2.1 (Level 1) for components to stay inside them.
STAGE 4: REVIEW
What is done: Someone other than the author reads the change with the requirements list and the threat register open. Results from any code analysis tool run on the same commit are triaged alongside.
Artefact: A review record: who reviewed which change, what they found and what happened to each finding.
Kept in: The pull request or merge request in the code host, linked from the release record.
Pass when: Each change has an approval from someone who did not write it, and every finding is either fixed or recorded in the issue tracker with an owner.
Fail when: The author is the only approver, or a finding was dismissed with no reason written down.
Who decides: The reviewer.
On a fail: The change returns to its author. A dismissal stands only once a second person has read its reason against the code.
Source: SSDF PW.7.1 (determine whether code review, where a person looks directly at the code to find issues, and/or code analysis, where tools are used to find issues in code, either in a fully automated way or in conjunction with a person, should be used, as defined by the organisation) and PW.7.2 (perform the code review and/or code analysis based on the organisation's secure coding standards, and record and triage all discovered issues and recommended remediations in the development team's workflow or issue tracking system).
STAGE 5: TEST
What is done: Turn each acceptance criterion into a test that runs against a build of the release commit, and run it. Dynamic scanning of a staging build belongs at this stage too.
Artefact: Test results: the run, the commit it ran on and a result for each acceptance criterion.
Kept in: The CI system's record of the run, with the run number copied into the release record.
Pass when: Every acceptance criterion has a result from the release commit, and each result is a pass, or a fail with a recorded decision.
Fail when: A criterion has no test, the results come from another commit, or a failed result has no decision.
Who decides: The technical lead.
On a fail: Fix and run again, or take the failed criterion to the release approver as an exception.
Source: SSDF PW.8.1 (determine whether executable code testing should be performed to find vulnerabilities not identified by previous reviews, analysis or testing and, if so, which types of testing should be used) and PW.8.2 (scope the testing, design the tests, perform the testing, and document the results, including recording and triaging all discovered issues and recommended remediations in the development team's workflow or issue tracking system).
STAGE 6: RELEASE
What is done: One person reads the release record and decides whether the release goes out.
Artefact: A release approval: who approved, in what role, on what date and for which commit, with the list of accepted exceptions.
Kept in: The release record, one file per release in the repository, such as releases/2026.10.1.json, with the release commit tagged.
Pass when: Every earlier gate has an artefact the approver could open, every failed result has a decision, every accepted exception has an owner and an expiry date, and the approval names the commit being deployed.
Fail when: An artefact cannot be opened, the approval names another commit, or an exception has no owner or no expiry date.
Who decides: The release approver: one named person, such as the product owner or the business owner, who did not write the change.
On a fail: The release waits. Only the release approver can let it go with something missing, by recording an exception in their own name.
Source: SSDF PO.4.1 (define criteria for software security checks and track throughout the SDLC), whose fifth notional example is to record security check approvals, rejections and exception requests as part of the workflow and tracking system, and PS.3.1 (securely archive the necessary files and supporting data, such as integrity verification information and provenance data, to be retained for each software release).
STAGE 7: AFTER RELEASE, VULNERABILITY INTAKE AND FIXES
What is done: Receive reports about the application and advisories about its components. Log each one, confirm it, rate it, decide the response, fix it, add a test that fails on the old code, and record the cause. Where a gate should have caught it, change the gate.
Artefact: A vulnerability intake log: one row for each report, with the date received, the owner, the rating, the decision, the fix, the regression test and the root cause.
Kept in: A part of the issue tracker that only the people handling reports can read. The way to send a report is published where a researcher will look for it.
Pass when: To close a row, it has an owner, a rating and a decision, and a fixed row links to the release that carried the fix, a regression test and a root-cause note.
Fail when: A report has no owner or no decision, or a fix shipped with no test.
Who decides: The technical lead closes a row. Leaving a confirmed vulnerability open is the release approver's decision, recorded as an exception.
On a fail: The row stays open and is listed in the next release record, where the release gate asks about it.
Source: SSDF RV.1.1 (gather information from software acquirers, users and public sources on potential vulnerabilities in the software and third-party components that the software uses, and investigate all credible reports), RV.1.3 (have a policy that addresses vulnerability disclosure and remediation, and implement the roles, responsibilities and processes needed to support that policy), RV.2.2 (plan and implement risk responses for vulnerabilities), RV.3.1 (analyse identified vulnerabilities to determine their root causes) and RV.3.4 (review the SDLC process, and update it if appropriate to prevent, or reduce the likelihood of, the root cause recurring in updates to the software or in new software that is created).
==== PART 2: SECURE RELEASE CHECKLIST ====
Fourteen questions drawn from the map. Answer each with yes, no or not applicable, and a link to the artefact. A no is fixed before release, or it becomes an exception with an owner and an expiry date.
Requirements (stage 1)
1. Does every security requirement in this release have an acceptance criterion with a pass and a fail condition?
Design (stage 2)
2. Does every threat register row added for this release have a response that names a requirement or an exception?
3. Did someone who did not write the design review it, and is that review recorded?
Build (stage 3)
4. Does every dependency this release adds or upgrades have a decision row, and is the lockfile committed at the release commit?
5. Is every component inside the remediation time frame the team has written down, or covered by an accepted exception?
Review (stage 4)
6. Was every change approved by someone other than its author?
7. Is every review finding fixed, or in the issue tracker with an owner?
Test (stage 5)
8. Is there a test result for every acceptance criterion, taken from the release commit?
9. Does every failed result have a decision that says who decided and what they decided?
Release (stage 6)
10. Does every accepted exception have an owner, a reason, an interim measure and an expiry date that has not passed?
11. Does the approval name the approver, their role, the date and the commit being deployed?
12. Is the release record saved where it can be opened later, and can it be changed only by the people who should change it?
After release (stage 7)
13. Does a test message sent to the published security contact arrive in the intake log?
14. Is every open row in the intake log listed in this release record with an owner?
==== PART 3: WORKED EXAMPLE, ONE FEATURE THROUGH EVERY GATE ====
The business is an invented swim school. Its parent portal lets a guardian see a child's lessons, book catch-up lessons and pay. Four people ship it: the business owner, who approves releases; a product owner; and two developers, one of whom is the technical lead. The feature is a second guardian invitation: a guardian enters another adult's email address, and that adult can then see and manage the same child's lessons.
Stage 1, requirements. Decided by the product owner on 14 September 2026.
The requirements list held six security requirements, each with one acceptance criterion:
SR-1. Only a guardian already linked to a child can invite a second guardian for that child.
AC-1. Signed in as a guardian of one child, a request to invite a second guardian for another family's child is refused, and no email is sent.
SR-2. An invitation can be accepted only by an account whose verified email address is the invited address.
AC-2. Signed in as any other account, opening a valid invitation link is refused, and the invitation stays pending.
SR-3. An invitation link works once, and stops working when it is revoked or 72 hours after it was sent. The 72 hours is this example's own figure.
AC-3. A used link, a revoked link and a link older than 72 hours are each refused.
SR-4. A second guardian sees only the child named in the invitation.
AC-4. Signed in as the second guardian, requests for a sibling's record and for the billing page are refused.
SR-5. One account can send at most five invitations in a day. The limit of five is this example's own figure.
AC-5. The sixth invitation an account sends in one day is refused.
SR-6. Sending, accepting and revoking an invitation are each written to the audit log.
AC-6. Each of the three actions leaves a log entry that names the acting account and the child record.
Gate result: pass. Six requirements, six criteria, each with a way to fail.
Stage 2, design. Decided by the technical lead on 16 September 2026.
The developer wrote the design and added six rows to the threat register:
T-31. A guardian invites someone to a child who is not theirs. Response: SR-1.
T-32. The invitation email reaches the wrong person, who accepts it. Response: SR-2.
T-33. An old, used or revoked link is sent again. Response: SR-3.
T-34. The second guardian reaches more than the one child, such as a sibling or the billing page. Response: SR-4.
T-35. The invitation form is used to send unwanted email in bulk. Response: SR-5.
T-36. A dispute about who invited or removed whom cannot be settled afterwards. Response: SR-6.
The technical lead, who did not write the design, reviewed it against the requirements and left comments in the feature's issue.
Gate result: pass. Every row had a response, and the review was recorded.
Stage 3, build. Decided by the technical lead.
The feature added one direct dependency, a library that renders the invitation email. Row D-14 of the dependency decision record held why it was needed, the version pinned in the lockfile, the date advisories were checked (23 September 2026) with nothing found against that version, and the technical lead's name. On 29 September the advisory check was run again on the lockfile at the release commit.
Gate result: pass. One component added, one row, nothing past the team's written time frame.
Stage 4, review. Decided by the reviewer, the technical lead.
The developer opened pull request 148. The technical lead reviewed it with the requirements list open and raised three findings. Two of them: the invitation token was being written to the request log, and the invite route trusted the child id in the request without checking the guardian's link to that child, which is SR-1. All three were fixed before the merge on 25 September.
Gate result: pass. Each change approved by someone other than its author, every finding fixed.
Stage 5, test. Decided by the technical lead. This gate failed the first time.
First run, 28 September, CI run 2274: AC-3 failed. The used link and the old link were refused, but the revoked link was accepted, because the accept handler never read the revoked flag. AC-5 failed too: the sixth invitation was sent, because the daily limit had not been built.
What was done about AC-3: the technical lead recorded the decision to fix and run again. The developer fixed the handler in pull request 151, which went back through the review gate and was approved on 29 September.
What was done about AC-5: the technical lead recorded that the limit could not be built before the release date and asked the release approver for an exception.
Second run, 29 September, CI run 2291 on the release commit: AC-1, AC-2, AC-3, AC-4 and AC-6 passed. AC-5 failed again.
Gate result: pass on the second run, because every criterion had a result from the release commit and each failed result had a recorded decision. A gate can pass with a failed criterion only when the failure has gone to the person whose role it is to accept it.
Stage 6, release. Decided by the business owner, as release approver, on 30 September 2026.
The approver opened the five earlier artefacts and read the two failed criteria. AC-3 was fixed. For AC-5 the approver accepted exception EX-1: the reason (the daily limit is not built), the interim measure (each child can have one pending invitation at a time, enforced in the database), the owner (the technical lead) and an expiry date of 30 October 2026. The approval named commit invented-7c1e9a4, which was deployed on 1 October.
Gate result: pass, with one accepted exception.
Stage 7, after release. Rows closed by the technical lead.
On 1 October a test message sent to the published security contact arrived in the intake log as VR-6 and was closed as a test.
On 19 October a parent reported, as VR-7, that an adult whose access they had revoked still received the weekly lesson reminder naming the child and the lesson time. The technical lead took the row, confirmed the report on staging with test accounts and rated it high on the team's own scale. The fix made revocation remove the reminder subscription. It came back into the line at stage 1 as a new requirement and criterion:
SR-7. After access is revoked, the application sends that account nothing further about the child.
AC-7. After revocation, the next reminder run queues no message for the revoked account.
AC-7 failed on the 2026.10.1 code and passed on the fix, which went out as release 2026.10.2 on 21 October with a release record of its own. The parent was told the same day.
Root cause, as recorded: rows T-33 and T-34 dealt with what a second guardian could open in the portal, and no row asked what the application sends out. The threat register template gained a question for every feature that shares data with another person: what does the application send them after their access ends?
Whether a disclosure like this has to be reported to anyone is a legal question this example does not answer.
Exception EX-1 did not reach its expiry date. Release 2026.10.3 shipped the daily limit on 27 October, AC-5 passed, and that release's record closed the exception.
==== PART 4: THE RELEASE-EVIDENCE CHECK ====
WHAT IT IS
The worked example's release record saved as a data file, and a script that reads a release record and reports three kinds of missing evidence:
1. A stage with no gate recorded, or a gate whose artefact has no name or no location.
2. A failed result with no recorded decision. A decision counts as recorded when it says who decided and what they decided.
3. An accepted exception with no owner, or with no expiry date written as year, month and day (YYYY-MM-DD).
The command exits with code 0 when it finds none of these, code 1 when it finds at least one, and code 2 when it is given no path, or a file that cannot be read, is not JSON or has no list of gates.
WHAT IT IS NOT
An illustration, not a product. It reads what the record says and opens nothing the record points to. It cannot tell whether a requirement was the right one, whether a review was careful, whether a test checks what its name claims or whether a decision was wise. It does not compare an expiry date with the release date or with today, and it does not check that a failed criterion later passed. Those are questions for the person deciding each gate.
WHAT IT NEEDS
Node.js, with nothing to install. Apart from each other, the lab's files import only node:fs, node:os, node:path, node:url, node:child_process, node:assert/strict and node:test, and they install no packages. The Node.js documentation marks the test runner stable from version 20.0.0. The outputs below were recorded on Node.js 26.0.0 on macOS. Since Node.js 23.0.0 the test runner's default spec format is also used when its output goes to a file; on earlier versions that output is TAP.
SET-UP
Create an empty folder, such as release-evidence, and save the five files into it under the names shown. Run the commands under RUN IT from that folder.
==== File 1 of 5: release-record.json ====
{
"application": "Parent portal of an invented swim school",
"feature": "Second guardian invitation",
"release": "2026.10.1",
"commit": "invented-7c1e9a4",
"gates": [
{
"stage": "requirements",
"decidedBy": "product owner",
"artefact": {
"name": "Requirements list with security acceptance criteria, SR-1 to SR-6",
"location": "docs/security/requirements/second-guardian-invitation.md at the release commit"
},
"criteria": [
{
"id": "REQ-1",
"check": "Every security requirement has an acceptance criterion with a pass and a fail condition",
"attempts": [
{ "date": "2026-09-14", "result": "pass", "evidence": "6 requirements, 6 acceptance criteria (AC-1 to AC-6)" }
]
}
]
},
{
"stage": "design",
"decidedBy": "technical lead",
"artefact": {
"name": "Threat register rows T-31 to T-36, with the data-flow sketch",
"location": "docs/security/threat-register.md at the release commit"
},
"criteria": [
{
"id": "DESIGN-1",
"check": "Every threat row added for this feature has a response that names a requirement or an exception",
"attempts": [
{ "date": "2026-09-16", "result": "pass", "evidence": "6 rows added, each mitigated by one of SR-1 to SR-6" }
]
},
{
"id": "DESIGN-2",
"check": "Someone who did not write the design has reviewed it against the requirements",
"attempts": [
{ "date": "2026-09-16", "result": "pass", "evidence": "Reviewed by the technical lead, who did not write the design; comments in issue PORTAL-212" }
]
}
]
},
{
"stage": "build",
"decidedBy": "technical lead",
"artefact": {
"name": "Dependency decision record, row D-14",
"location": "docs/security/dependency-decisions.md and the lockfile at the release commit"
},
"criteria": [
{
"id": "BUILD-1",
"check": "Every direct dependency added or upgraded by this release has a decision row",
"attempts": [
{ "date": "2026-09-23", "result": "pass", "evidence": "1 added (an email template library), 0 upgraded, 1 decision row (D-14)" }
]
},
{
"id": "BUILD-2",
"check": "No component is past the remediation time frame the team has written down",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "Advisory check on the lockfile at the release commit: 0 components past the time frame" }
]
}
]
},
{
"stage": "review",
"decidedBy": "reviewer (technical lead)",
"artefact": {
"name": "Review record for pull requests 148 and 151",
"location": "Pull requests 148 (the feature) and 151 (the fix for AC-3) in the code host"
},
"criteria": [
{
"id": "REVIEW-1",
"check": "Each change was approved by someone other than its author",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "148 approved on 2026-09-25 and 151 on 2026-09-29 by the technical lead; the developer wrote both" }
]
},
{
"id": "REVIEW-2",
"check": "Every review finding is fixed or recorded in the issue tracker",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "3 findings on 148, 3 fixed before merge; 0 findings on 151" }
]
}
]
},
{
"stage": "test",
"decidedBy": "technical lead",
"artefact": {
"name": "Test results for acceptance criteria AC-1 to AC-6",
"location": "CI run 2291 on the release commit"
},
"criteria": [
{
"id": "AC-1",
"check": "A guardian of one child cannot invite a second guardian for another family's child",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "CI run 2291: request refused with status 403, no email queued" }
]
},
{
"id": "AC-2",
"check": "An account whose verified email is not the invited address cannot accept the invitation",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "CI run 2291: request refused, invitation still pending" }
]
},
{
"id": "AC-3",
"check": "A used link, a revoked link and a link older than 72 hours are each refused",
"attempts": [
{
"date": "2026-09-28",
"result": "fail",
"evidence": "CI run 2274 on commit invented-51b20de: the revoked link was accepted",
"decision": {
"by": "technical lead",
"date": "2026-09-28",
"action": "fix and run again",
"note": "The accept handler did not read the revoked flag. Fixed in pull request 151."
}
},
{ "date": "2026-09-29", "result": "pass", "evidence": "CI run 2291: all three links refused" }
]
},
{
"id": "AC-4",
"check": "A second guardian cannot open a sibling's record or the billing page",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "CI run 2291: both requests refused with status 403" }
]
},
{
"id": "AC-5",
"check": "The sixth invitation an account sends in one day is refused",
"attempts": [
{
"date": "2026-09-28",
"result": "fail",
"evidence": "CI run 2274 on commit invented-51b20de: the sixth invitation was sent",
"decision": {
"by": "technical lead",
"date": "2026-09-28",
"action": "ask the release approver for an exception",
"note": "The daily limit cannot be built before the release date."
}
},
{
"date": "2026-09-29",
"result": "fail",
"evidence": "CI run 2291: the sixth invitation was sent",
"decision": {
"by": "release approver (business owner)",
"date": "2026-09-30",
"action": "accept as exception EX-1",
"note": "One pending invitation per child is enforced until the daily limit ships."
}
}
]
},
{
"id": "AC-6",
"check": "Sending, accepting and revoking an invitation each leave an audit log entry naming the account",
"attempts": [
{ "date": "2026-09-29", "result": "pass", "evidence": "CI run 2291: three entries, each with the account id and the child record id" }
]
}
]
},
{
"stage": "release",
"decidedBy": "release approver (business owner)",
"artefact": {
"name": "Release approval for 2026.10.1",
"location": "releases/2026.10.1.json (this file) and the tag on the release commit"
},
"criteria": [
{
"id": "RELEASE-1",
"check": "Every earlier gate has an artefact that the approver could open",
"attempts": [
{ "date": "2026-09-30", "result": "pass", "evidence": "5 of 5 opened" }
]
},
{
"id": "RELEASE-2",
"check": "Every failed result has a decision, and every accepted exception has an owner and an expiry date",
"attempts": [
{ "date": "2026-09-30", "result": "pass", "evidence": "AC-3 failed once, then fixed and run again; AC-5 failed twice and is accepted as EX-1" }
]
},
{
"id": "RELEASE-3",
"check": "The approval names the commit that is deployed",
"attempts": [
{ "date": "2026-09-30", "result": "pass", "evidence": "Approved for invented-7c1e9a4, deployed on 2026-10-01" }
]
}
]
},
{
"stage": "after-release",
"decidedBy": "technical lead",
"artefact": {
"name": "Vulnerability intake log",
"location": "Restricted Security project in the issue tracker; the contact address is published in security.txt"
},
"criteria": [
{
"id": "AFTER-1",
"check": "A test message sent to the published contact address arrived in the intake log",
"attempts": [
{ "date": "2026-10-01", "result": "pass", "evidence": "Test message logged as VR-6 and closed as a test" }
]
},
{
"id": "AFTER-2",
"check": "Every report received against this release has an owner, a rating, a decision and, once fixed, a regression test and a root cause",
"attempts": [
{ "date": "2026-10-21", "result": "pass", "evidence": "1 report (VR-7): release 2026.10.2 carried the fix, with regression test AC-7 and a root-cause note" }
]
}
]
}
],
"exceptions": [
{
"id": "EX-1",
"criterion": "AC-5",
"status": "accepted",
"reason": "The limit on invitations per account per day is not built in this release.",
"interimMeasure": "Each child can have one pending invitation at a time, enforced in the database.",
"owner": "technical lead",
"expires": "2026-10-30",
"approvedBy": "release approver (business owner)",
"approvedOn": "2026-09-30"
}
]
}
==== File 2 of 5: release-evidence.mjs ====
// release-evidence.mjs: three rules that look for missing evidence in a
// release record. They read what the record says. They do not open the
// artefacts it points to, so they cannot tell whether the work was done well.
// The seven stages of the stage-gate map, in delivery order.
export const STAGES = ['requirements', 'design', 'build', 'review', 'test', 'release', 'after-release']
// Four digits, two digits and two digits, joined by hyphens. Only the form is
// checked, not whether the date exists or has passed.
const DATE_FORM = /^\d{4}-\d{2}-\d{2}$/
function hasText(value) {
return typeof value === 'string' && value.trim().length > 0
}
export function findGate(record, stage) {
return (record.gates || []).find((gate) => gate.stage === stage)
}
// Rule 1: every stage has a gate, and the gate's artefact has a name and a location.
function findArtefactGaps(record) {
const gaps = []
for (const stage of STAGES) {
const gate = findGate(record, stage)
const artefact = (gate && gate.artefact) || {}
if (!gate) gaps.push(stage + ': no gate recorded, so no artefact')
else if (!hasText(artefact.name)) gaps.push(stage + ': no artefact named')
else if (!hasText(artefact.location)) gaps.push(stage + ': artefact has no location')
}
return gaps
}
function listFailedResultsInGate(gate) {
const failedResults = []
for (const criterion of gate.criteria || []) {
for (const attempt of criterion.attempts || []) {
if (attempt.result === 'fail') failedResults.push({ stage: gate.stage, criterionId: criterion.id, attempt })
}
}
return failedResults
}
// Returns one entry for every attempt in the record whose result is "fail".
export function listFailedResults(record) {
const failedResults = []
for (const gate of record.gates || []) failedResults.push(...listFailedResultsInGate(gate))
return failedResults
}
// A decision is recorded when it says who decided and what they decided.
export function hasRecordedDecision(attempt) {
const decision = attempt.decision || {}
return hasText(decision.by) && hasText(decision.action)
}
// Rule 2: every failed result carries a recorded decision.
function findDecisionGaps(record) {
const gaps = []
for (const failed of listFailedResults(record)) {
if (hasRecordedDecision(failed.attempt)) continue
gaps.push(failed.stage + ': criterion ' + failed.criterionId + ' failed on ' + failed.attempt.date + ' with no recorded decision')
}
return gaps
}
export function listAcceptedExceptions(record) {
return (record.exceptions || []).filter((exception) => exception.status === 'accepted')
}
export function hasOwner(exception) {
return hasText(exception.owner)
}
export function hasExpiryDate(exception) {
return typeof exception.expires === 'string' && DATE_FORM.test(exception.expires)
}
// Rule 3: every accepted exception has an owner and an expiry date.
function findExceptionGaps(record) {
const gaps = []
for (const exception of listAcceptedExceptions(record)) {
if (!hasOwner(exception)) gaps.push('exception ' + exception.id + ': accepted with no owner')
if (!hasExpiryDate(exception)) gaps.push('exception ' + exception.id + ': accepted with no expiry date')
}
return gaps
}
// Runs the three rules in order and returns each gap as one line of text.
export function findGaps(record) {
return [...findArtefactGaps(record), ...findDecisionGaps(record), ...findExceptionGaps(record)]
}
==== File 3 of 5: check-release-evidence.mjs ====
// check-release-evidence.mjs: reads one release record, prints a summary and
// lists any missing evidence.
// Usage: node check-release-evidence.mjs path/to/release-record.json
// Exit code 0: no gaps. Exit code 1: at least one gap. Exit code 2: no path
// was given, or the file could not be read, is not JSON, or has no list of gates.
import fs from 'node:fs'
import {
STAGES,
findGaps,
findGate,
hasExpiryDate,
hasOwner,
hasRecordedDecision,
listAcceptedExceptions,
listFailedResults,
} from './release-evidence.mjs'
// Returns the parsed record, or null when the file cannot be read, is not
// JSON or has no list of gates.
function readRecord(recordPath) {
try {
const record = JSON.parse(fs.readFileSync(recordPath, 'utf8'))
return Array.isArray(record.gates) ? record : null
} catch {
return null
}
}
function describeStage(record, stage) {
const gate = findGate(record, stage)
if (!gate) return stage.padEnd(15) + '(no gate recorded)'
const criteriaCount = String((gate.criteria || []).length)
const failedCount = String(listFailedResults({ gates: [gate] }).length)
const artefactName = (gate.artefact && gate.artefact.name) || '(none recorded)'
return stage.padEnd(15) + criteriaCount.padEnd(10) + failedCount.padEnd(16) + artefactName
}
function printSummary(record) {
console.log('Release ' + record.release + ': ' + record.feature)
console.log('Commit: ' + record.commit)
console.log('')
console.log('Stage'.padEnd(15) + 'Criteria'.padEnd(10) + 'Failed results'.padEnd(16) + 'Artefact')
for (const stage of STAGES) console.log(describeStage(record, stage))
console.log('')
}
function printCounts(record) {
const failedResults = listFailedResults(record)
const decided = failedResults.filter((failed) => hasRecordedDecision(failed.attempt))
const accepted = listAcceptedExceptions(record)
const complete = accepted.filter((exception) => hasOwner(exception) && hasExpiryDate(exception))
console.log('Failed results with a recorded decision: ' + decided.length + ' of ' + failedResults.length)
console.log('Accepted exceptions with an owner and an expiry date: ' + complete.length + ' of ' + accepted.length)
console.log('')
}
function printGaps(gaps) {
if (gaps.length === 0) {
console.log('No gaps found.')
console.log('This check confirms that evidence was recorded. It does not open the artefacts or judge the work behind them.')
return
}
console.log('Gaps found: ' + gaps.length)
for (const gap of gaps) console.log('- ' + gap)
}
function main() {
const recordPath = process.argv[2]
if (!recordPath) {
console.log('Usage: node check-release-evidence.mjs path/to/release-record.json')
return 2
}
const record = readRecord(recordPath)
if (!record) {
console.log('Not a release record: the file could not be read, is not JSON, or has no list of gates.')
return 2
}
const gaps = findGaps(record)
printSummary(record)
printCounts(record)
printGaps(gaps)
return gaps.length === 0 ? 0 : 1
}
process.exitCode = main()
==== File 4 of 5: seed-gaps.mjs ====
// seed-gaps.mjs: reads release-record.json from the folder it is run in and
// writes release-record-with-gaps.json, a copy with four pieces of evidence
// removed on purpose so the check has something to find.
import fs from 'node:fs'
const record = JSON.parse(fs.readFileSync('release-record.json', 'utf8'))
// 1. The review gate loses its artefact.
const reviewGate = record.gates.find((gate) => gate.stage === 'review')
delete reviewGate.artefact
// 2. The failed result for AC-3 loses its decision.
const testGate = record.gates.find((gate) => gate.stage === 'test')
const linkCriterion = testGate.criteria.find((criterion) => criterion.id === 'AC-3')
const failedAttempt = linkCriterion.attempts.find((attempt) => attempt.result === 'fail')
delete failedAttempt.decision
// 3 and 4. The accepted exception loses its owner and its expiry date.
const exception = record.exceptions.find((item) => item.id === 'EX-1')
delete exception.owner
delete exception.expires
fs.writeFileSync('release-record-with-gaps.json', JSON.stringify(record, null, 2) + '\n')
console.log('Wrote release-record-with-gaps.json with 4 gaps seeded:')
console.log('- review gate: artefact removed')
console.log('- test gate: decision removed from the failed result for AC-3')
console.log('- exception EX-1: owner removed')
console.log('- exception EX-1: expiry date removed')
==== File 5 of 5: check-release-evidence.test.mjs ====
// check-release-evidence.test.mjs: tests for the three rules and for the
// command's exit codes. The first two tests read the complete record as it
// is. Each of the other rule tests changes one thing in a copy of it and
// checks which gaps are reported.
import assert from 'node:assert/strict'
import { spawnSync } from 'node:child_process'
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { test } from 'node:test'
import { fileURLToPath } from 'node:url'
import { findGaps, findGate, listFailedResults } from './release-evidence.mjs'
const LAB_DIR = path.dirname(fileURLToPath(import.meta.url))
const COMPLETE_RECORD_PATH = path.join(LAB_DIR, 'release-record.json')
const CHECK_SCRIPT_PATH = path.join(LAB_DIR, 'check-release-evidence.mjs')
function loadCompleteRecord() {
return JSON.parse(fs.readFileSync(COMPLETE_RECORD_PATH, 'utf8'))
}
// Returns the first failed attempt recorded for a criterion.
function findFailedAttempt(record, criterionId) {
return listFailedResults(record).find((failed) => failed.criterionId === criterionId).attempt
}
// Runs the command on a record file and returns the finished process, which
// holds its exit code (status) and its output (stdout).
function runCheck(recordPath) {
return spawnSync(process.execPath, [CHECK_SCRIPT_PATH, recordPath], { encoding: 'utf8' })
}
// Writes text to record.json in a new temporary folder that is removed when the test ends.
function writeTemporaryFile(testContext, text) {
const folder = fs.mkdtempSync(path.join(os.tmpdir(), 'release-evidence-'))
testContext.after(() => fs.rmSync(folder, { recursive: true, force: true }))
const filePath = path.join(folder, 'record.json')
fs.writeFileSync(filePath, text)
return filePath
}
test('the complete record has no gaps', () => {
assert.deepEqual(findGaps(loadCompleteRecord()), [])
})
test('the complete record holds three failed results', () => {
const failedIds = listFailedResults(loadCompleteRecord()).map((failed) => failed.criterionId)
assert.deepEqual(failedIds, ['AC-3', 'AC-5', 'AC-5'])
})
test('a gate with no artefact is a gap', () => {
const record = loadCompleteRecord()
delete findGate(record, 'review').artefact
assert.deepEqual(findGaps(record), ['review: no artefact named'])
})
test('an artefact with no location is a gap', () => {
const record = loadCompleteRecord()
findGate(record, 'build').artefact.location = ''
assert.deepEqual(findGaps(record), ['build: artefact has no location'])
})
test('a stage with no gate is a gap', () => {
const record = loadCompleteRecord()
record.gates = record.gates.filter((gate) => gate.stage !== 'design')
assert.deepEqual(findGaps(record), ['design: no gate recorded, so no artefact'])
})
test('a failed result with no decision is a gap', () => {
const record = loadCompleteRecord()
delete findFailedAttempt(record, 'AC-3').decision
assert.deepEqual(findGaps(record), ['test: criterion AC-3 failed on 2026-09-28 with no recorded decision'])
})
test('a decision that does not say who decided is a gap', () => {
const record = loadCompleteRecord()
findFailedAttempt(record, 'AC-5').decision.by = ''
assert.deepEqual(findGaps(record), ['test: criterion AC-5 failed on 2026-09-28 with no recorded decision'])
})
test('an accepted exception with no owner is a gap', () => {
const record = loadCompleteRecord()
delete record.exceptions[0].owner
assert.deepEqual(findGaps(record), ['exception EX-1: accepted with no owner'])
})
test('an accepted exception with no expiry date is a gap', () => {
const record = loadCompleteRecord()
delete record.exceptions[0].expires
assert.deepEqual(findGaps(record), ['exception EX-1: accepted with no expiry date'])
})
test('an expiry that is not written as YYYY-MM-DD is a gap', () => {
const record = loadCompleteRecord()
record.exceptions[0].expires = 'next release'
assert.deepEqual(findGaps(record), ['exception EX-1: accepted with no expiry date'])
})
test('an exception that is not accepted is not checked', () => {
const record = loadCompleteRecord()
record.exceptions.push({ id: 'EX-2', criterion: 'AC-6', status: 'proposed' })
assert.deepEqual(findGaps(record), [])
})
test('the command exits with code 0 on the complete record', () => {
const run = runCheck(COMPLETE_RECORD_PATH)
assert.equal(run.status, 0)
assert.match(run.stdout, /No gaps found\./)
})
test('the command exits with code 1 when a gap is found', (testContext) => {
const record = loadCompleteRecord()
delete record.exceptions[0].expires
const run = runCheck(writeTemporaryFile(testContext, JSON.stringify(record)))
assert.equal(run.status, 1)
assert.match(run.stdout, /Gaps found: 1/)
})
test('the command exits with code 2 when the file is not a release record', (testContext) => {
const run = runCheck(writeTemporaryFile(testContext, 'not json'))
assert.equal(run.status, 2)
assert.match(run.stdout, /Not a release record/)
})
==== RUN IT ====
node check-release-evidence.mjs release-record.json
node seed-gaps.mjs
node check-release-evidence.mjs release-record-with-gaps.json
node --test check-release-evidence.test.mjs
==== OUTPUT OF node check-release-evidence.mjs release-record.json (Node.js 26.0.0, macOS) ====
Release 2026.10.1: Second guardian invitation
Commit: invented-7c1e9a4
Stage Criteria Failed results Artefact
requirements 1 0 Requirements list with security acceptance criteria, SR-1 to SR-6
design 2 0 Threat register rows T-31 to T-36, with the data-flow sketch
build 2 0 Dependency decision record, row D-14
review 2 0 Review record for pull requests 148 and 151
test 6 3 Test results for acceptance criteria AC-1 to AC-6
release 3 0 Release approval for 2026.10.1
after-release 2 0 Vulnerability intake log
Failed results with a recorded decision: 3 of 3
Accepted exceptions with an owner and an expiry date: 1 of 1
No gaps found.
This check confirms that evidence was recorded. It does not open the artefacts or judge the work behind them.
The command exited with code 0.
==== OUTPUT OF node seed-gaps.mjs ====
Wrote release-record-with-gaps.json with 4 gaps seeded:
- review gate: artefact removed
- test gate: decision removed from the failed result for AC-3
- exception EX-1: owner removed
- exception EX-1: expiry date removed
The command exited with code 0.
==== OUTPUT OF node check-release-evidence.mjs release-record-with-gaps.json ====
Release 2026.10.1: Second guardian invitation
Commit: invented-7c1e9a4
Stage Criteria Failed results Artefact
requirements 1 0 Requirements list with security acceptance criteria, SR-1 to SR-6
design 2 0 Threat register rows T-31 to T-36, with the data-flow sketch
build 2 0 Dependency decision record, row D-14
review 2 0 (none recorded)
test 6 3 Test results for acceptance criteria AC-1 to AC-6
release 3 0 Release approval for 2026.10.1
after-release 2 0 Vulnerability intake log
Failed results with a recorded decision: 2 of 3
Accepted exceptions with an owner and an expiry date: 0 of 1
Gaps found: 4
- review: no artefact named
- test: criterion AC-3 failed on 2026-09-28 with no recorded decision
- exception EX-1: accepted with no owner
- exception EX-1: accepted with no expiry date
The command exited with code 1.
==== OUTPUT OF node --test check-release-evidence.test.mjs ====
✔ the complete record has no gaps (1.447791ms)
✔ the complete record holds three failed results (0.149417ms)
✔ a gate with no artefact is a gap (0.134166ms)
✔ an artefact with no location is a gap (0.167042ms)
✔ a stage with no gate is a gap (0.12825ms)
✔ a failed result with no decision is a gap (0.114041ms)
✔ a decision that does not say who decided is a gap (0.100541ms)
✔ an accepted exception with no owner is a gap (0.11425ms)
✔ an accepted exception with no expiry date is a gap (0.114667ms)
✔ an expiry that is not written as YYYY-MM-DD is a gap (0.1325ms)
✔ an exception that is not accepted is not checked (0.099666ms)
✔ the command exits with code 0 on the complete record (67.361708ms)
✔ the command exits with code 1 when a gap is found (68.664417ms)
✔ the command exits with code 2 when the file is not a release record (67.479541ms)
ℹ tests 14
ℹ suites 0
ℹ pass 14
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 292.288125
The command exited with code 0.
==== USING IT ON YOUR OWN RELEASES ====
1. Keep one record per release in the repository, in the shape of release-record.json: seven gates, each with the role that decided, an artefact with a name and a location, and criteria with dated attempts.
2. Write every failed attempt into the record with its decision. Do not replace a fail with the later pass: the pair is the evidence that the gate worked.
3. Give every exception a status, a reason, an interim measure, an owner and an expiry date. Keep the exception in later releases' records until it is closed.
4. Run the check before the release approver reads the record, so the approver's time goes to judging the evidence, not to finding that it is missing.
5. Change the stage names in STAGES if your delivery line has different stages, and change the tests with them.What a secure SDLC is
A secure SDLC is an ordinary software development lifecycle with security work placed inside each stage, instead of one check at the end.
NIST defines a software development life cycle (SDLC) as a formal or informal methodology for designing, creating and maintaining software. It says few SDLC models explicitly address software security in detail, so secure software development practices usually need to be added to and integrated into each one. This page treats secure software development lifecycle, secure development lifecycle and secure development process as names for the result.
NIST gives three reasons for integrating those practices throughout the lifecycle, whichever model a team uses: to reduce the number of vulnerabilities in released software, to reduce the potential impact of the exploitation of undetected or unaddressed vulnerabilities, and to address the root causes of vulnerabilities to prevent recurrences.
It counts as vulnerabilities not just bugs caused by coding flaws, but also weaknesses caused by security configuration settings, incorrect trust assumptions and outdated risk analysis.
OWASP makes the lifecycle part of design. Its Top 10:2025 entry on insecure design names three key parts of having a secure design: gathering requirements and resource management, creating a secure design, and having a secure development lifecycle.
It says secure software requires a secure development lifecycle, a secure design pattern, a paved road methodology, a secure component library, appropriate tooling, threat modelling, and incident post-mortems that are used to improve the process.
For a small team the useful version is short. Each stage has one security activity, the activity leaves one artefact that someone can open later, and one named role decides whether work moves on. The rest of this guide is that line, stage by stage.
Why security checks bolted on at the end tend to cost more
NIST's Secure Software Development Framework says most aspects of security can be addressed multiple times within an SDLC, but in general, the earlier in the SDLC that security is addressed, the less effort and cost is ultimately required to achieve the same level of security.
It calls this principle shifting left, and says shifting left minimises any technical debt that would require remediating early security flaws late in development or after the software is in production.
OWASP's insecure design entry separates design flaws from implementation defects because they have different root causes, take place at different times in the development process and have different remediations. It says an insecure design cannot be fixed by a perfect implementation, as the needed security controls were never created to defend against specific attacks. This page takes that as one reason the timing of a check matters.
The rest of this section is this page's reasoning. A check at the end can only report. If a test before release finds that one route never asks who owns a record, the fix is a condition and a test.
If it finds that nobody ever decided who may see that record, the work goes back to the first stage: a requirement is written, the design changes, the code is rewritten and reviewed again, and the tests are written, all against a release date that assumed the feature was finished.
The same gap is smaller at the stage where the missing decision should have been made, because less has been built on top of it.
A late check also leaves little behind. A test report says what was found in one build. It does not tell the next developer what the feature was required to refuse, which is what a written requirement and its test do.
The frameworks that describe a secure development lifecycle
Three publishers describe what a secure development lifecycle contains, a fourth sets out what a buyer can ask a software maker about it, and a fifth document supplies requirements to feed into one.
None is presented here as mandatory: whether a contract, a customer or a regulator asks you for one is a question to check against that document. This page does not rank them.
NIST Special Publication 800-218, the Secure Software Development Framework (SSDF) version 1.1, is dated February 2022. NIST describes it as a core set of high-level secure software development practices that can be integrated into each SDLC implementation. The practices are organised into four groups: Prepare the Organization (PO), Protect the Software (PS), Produce Well-Secured Software (PW) and Respond to Vulnerabilities (RV). Each practice has an identifier, such as PW.7, and one or more tasks, such as PW.7.2.
NIST is specific about what the framework is not. It does not prescribe how to implement each practice: the focus is on the outcomes of the practices rather than on the tools, techniques and mechanisms used to achieve them. Each task comes with notional implementation examples, and NIST says no examples or combination of examples are required and the stated examples are not the only feasible options.
The practices, tasks and examples are not prioritised, any stated frequency for performing practices is notional, and the order of the table is not intended to imply the sequence of implementation.
NIST says the intention of the SSDF is not to create a checklist to follow, but to provide a basis for planning and implementing a risk-based approach to adopting secure software development practices.
It also says the framework can be used by organisations in any sector or community, regardless of size or cybersecurity sophistication, and that not all practices are applicable to all use cases.
Version 1.1 is the version this page cites. As read on 14 November 2026, NIST's publication page for SP 800-218 gives its date published as February 2022, with a document history of a draft on 30 September 2021 and the final on 3 February 2022. A separate NIST page lists SP 800-218 Rev. 1, Secure Software Development Framework (SSDF) Version 1.2, as an Initial Public Draft, with a date published of 17 December 2025 and comments due on 30 January 2026, and marks the public comment period as closed. This page does not cite the draft.
The OWASP Software Assurance Maturity Model (SAMM) is a self-assessment model. Its website describes version 2 of the model, which its FAQ says was released on 31 January 2020, and the project's core repository on GitHub marks v2.2.0 as its latest release. SAMM defines five business functions and fifteen security practices, three to each function:
- Governance: Strategy & Metrics, Policy & Compliance, Education & Guidance.
- Design: Threat Assessment, Security Requirements, Secure Architecture.
- Implementation: Secure Build, Secure Deployment, Defect Management.
- Verification: Architecture Assessment, Requirements-driven Testing, Security Testing.
- Operations: Incident Management, Environment Management, Operational Management.
For each security practice SAMM defines three maturity levels, and says each level has a successively more sophisticated objective with specific activities and more strict success metrics. Its FAQ describes the first level as aiming at an ad-hoc, best effort implementation of a particular activity within a stream, the second as aiming to establish a consistent, repeatable process that can be relied on, and the third as aiming to maximise effectiveness through continuous improvement, based on effective and timely feedback.
SAMM says it does not insist that all organisations achieve the maximum maturity level in every category: each organisation can determine the target maturity level for each security practice that is the best fit.
Microsoft's Security Development Lifecycle (SDL) practices page, as it reads on 14 November 2026, lists what it calls the 10 key security practices of the SDL, and says the practices will be updated as the SDL, learnings, best practices and tooling evolve. The ten are: establish security standards, metrics and governance; require use of proven security features, languages and frameworks; perform security design review and threat modelling; define and use cryptography standards; secure the software supply chain; secure the engineering environment; perform security testing; ensure operational platform security; implement security monitoring and response; and provide security training.
CISA's Secure by Demand Guide is written for organisations buying software. It describes secure by design products as those in which software manufacturers make security a core consideration from the earliest stages of the product development lifecycle, and it lays out questions a buyer can put to a manufacturer.
One of them is whether the manufacturer has published a vulnerability disclosure policy that authorises testing by members of the public on its products.
For a small team that sells software to other businesses, the guide is a preview of what a customer may ask about how the product is built.
OWASP's Application Security Verification Standard (ASVS) 5.0.0, published on 30 May 2025, is a list of requirements, not a lifecycle. It belongs here because of the way it treats decisions. Its chapter What is the ASVS? explains that, for controls such as permissions, input validation and protection around different levels of sensitive data, documentation requirements were included which mandate that the application developer's approach and configuration must be documented, so that it can be reviewed for appropriateness and the actual implementation compared with it.
The same chapter says documentation requirements are always in the first section of a chapter, although not every chapter has them, and always have a related implementation requirement where the decisions that are documented should actually be put into place.
This page does not map one framework onto another. Published mappings exist, and they are the place to look. The table in SP 800-218 has a References column, which the document describes as pointers to one or more established secure development practice documents and their mappings to a particular task.
Its reference list cites OWASP SAMM version 1.5, OWASP ASVS 4.0.3 and Microsoft's Security Development Lifecycle, dated 2017, 2021 and 2021. SAMM 1.5 and ASVS 4.0.3 are earlier versions than the ones described above.
The SAMM project's mappings page says the project maintains a comprehensive mappings spreadsheet covering several standards, and lists mappings for Microsoft SDL, BSIMM 14, IEC 62443-4-1 and the NIST SSDF. It says the SSDF mapping was created in collaboration with NIST using the National Online Informative Reference (OLIR) Program, and links a NIST SSDF mapping spreadsheet for it.
Which security activity belongs at which stage
The frameworks describe practices.
A small team needs them laid along its own delivery line. NIST says the order of its table is not intended to imply the sequence of implementation. The arrangement below is this page's, and the stage each task sits at is a choice made for a team of a handful of people.
Each stage adds one thing and leaves one artefact behind. The full map, with a pass and a fail condition for every gate, is on this page.
This stage adds a list of what the feature must refuse, written before any code. NIST task PO.1.2 is to identify and document all security requirements for organisation-developed software to meet, and to maintain the requirements over time.
OWASP's insecure design entry says to compile the technical requirements, including functional and non-functional security requirements, and lists integrating security language and controls into user stories among its ways to prevent insecure design.
It leaves behind a requirements list in which each security requirement has an acceptance criterion.
This stage adds a look at how the change could be misused. NIST task PW.1.1 is to use forms of risk modelling, such as threat modelling, attack modelling or attack surface mapping, to help assess the security risk for the software. Task PW.2.1 has the design reviewed by a qualified person or people who were not involved with it, by automated processes instantiated in the toolchain, or by both, to confirm and enforce that it meets all of the security requirements and satisfactorily addresses the identified risk information.
It leaves behind a threat register: a row for each risk, with the response to it. The threat modelling guide in this library goes into the method itself.
This stage adds secure coding and a decision on each third-party component. NIST task PW.5.1 is to follow all secure coding practices that are appropriate to the development languages and environment to meet the organisation's requirements. Task PW.4.4 is to verify that acquired commercial, open-source and all other third-party software components comply with the requirements, as defined by the organisation, throughout their life cycles.
It leaves behind a dependency decision record. The pipeline that builds and deploys the code carries risks of its own, which the CI/CD security guide covers.
This stage adds a reader who did not write the change. NIST task PW.7.1 is to determine whether code review, where a person looks directly at the code to find issues, or code analysis, where tools are used to find issues in code, or both should be used, as defined by the organisation.
Task PW.7.2 is to perform it based on the organisation's secure coding standards, and to record and triage all discovered issues and recommended remediations in the development team's workflow or issue tracking system.
It leaves behind a review record. Static analysis, the tool half of this stage, is the subject of the SAST guide, and what a reviewer reads for is the subject of the secure code review page.
This stage adds a demonstration that a running build refuses what the requirements said it must. NIST's guidelines on developer verification, NISTIR 8397, say tests are typically based on specifications or requirements and on process experience. On this page's line, the acceptance criteria written at the first stage are that specification.
NIST task PW.8.2 is to scope the testing, design the tests, perform the testing and document the results, including recording and triaging all discovered issues and recommended remediations in the development team's workflow or issue tracking system.
It leaves behind test results tied to a commit. Scanning the running application is covered in the DAST guide.
This stage adds a decision. NIST task PO.4.1 is to define criteria for software security checks and track throughout the SDLC, and one of its notional examples is to record security check approvals, rejections and exception requests as part of the workflow and tracking system.
An example under task PO.2.3 is to appoint a single leader or leadership team to be responsible for the entire secure software development process, including being accountable for releasing software to production and delegating responsibilities as appropriate.
It leaves behind a release approval that names the approver and the commit.
This stage adds a way for vulnerabilities found later to reach the team and re-enter the line. NIST task RV.1.1 is to gather information from software acquirers, users and public sources on potential vulnerabilities in the software and third-party components that the software uses, and to investigate all credible reports.
It leaves behind a vulnerability intake log.
How to write a security requirement and its security acceptance criteria
A security requirement says what must not be possible.
Its acceptance criterion says how anyone will know. "Invitations must be safe" is neither. "Only a guardian already linked to a child can invite a second guardian for that child" is a requirement. "Signed in as a guardian of one child, a request to invite a second guardian for another family's child is refused, and no email is sent" is a criterion: it names who acts, what they attempt and what the application does in reply, and it can fail.
As this page's advice, a usable criterion has four parts:
- The actor:a role or an account in a stated position, such as a signed-in customer from another organisation, or a visitor with no session.
- The attempt:one request or action, named closely enough that a test can make it.
- The reply:what the application does, such as refusing the request, leaving a record unchanged or sending nothing.
- The check:whether a test decides it or a reviewer does, and at which stage.
Starting from ASVS documentation requirements
ASVS 5.0 is a useful place to find requirements, because some of its requirements ask for this kind of decision to be written down. Its chapter What is the ASVS? says rules such as what kind of file types are allowed to be uploaded, what business controls should be enforced and what the allowed characters are for a particular field will differ for every application, so the standard cannot prescriptively define them, and that without these decisions being documented it will not be possible to perform verification of the requirements that implement them. Four of its documentation requirements, each with its level:
- Requirement 8.1.1 (Level 1): authorisation documentation defines rules for restricting function-level and data-specific access based on consumer permissions and resource attributes.
- Requirement 2.1.3 (Level 2): expectations for business logic limits and validations are documented, including both per-user and globally across the application.
- Requirement 6.1.1 (Level 1): application documentation defines how controls such as rate limiting, anti-automation and adaptive response are used to defend against attacks such as credential stuffing and password brute force, and the documentation must make clear how these controls are configured and prevent malicious account lockout.
- Requirement 15.1.1 (Level 1): application documentation defines risk based remediation time frames for third-party component versions with vulnerabilities and for updating libraries in general, to minimise the risk from these components.
The decision, then the check against it
ASVS says a documentation requirement always has a related implementation requirement. This page reads three requirements in the same chapters as the implementation side of three of the four above, because each names the documentation outright.
Requirement 6.3.1 (Level 1) is that controls to prevent attacks such as credential stuffing and password brute force are implemented according to the application's security documentation. Requirement 2.3.2 (Level 2) is that business logic limits are implemented per the application's documentation to avoid business logic flaws being exploited.
Requirement 15.2.1 (Level 1) is that the application only contains components which have not breached the documented update and remediation time frames.
A requirement and its acceptance criterion have the same shape: the decision is written down first, and a later check compares the application with it.
ASVS also says where the decision may live. Security decisions might be documented in a literal document which developers are expected to refer to, or documented and implemented in a common code library that all developers are mandated to use. As this page's advice for a small team, a short file in the repository beside the code is enough.
Criteria a test cannot decide
Not every criterion can be a test. "The invitation email shows the child's first name and nothing else about them" can be tested. "No other route returns the child's record to a second guardian" is a question for the design review and the code review. Mark each criterion with the stage that checks it, so none is left for a stage that never looks.
What counts as evidence at a gate
NIST's word for it is artefact.
In SP 800-218 an artefact is a piece of evidence, and evidence is grounds for belief or disbelief: data on which to base proof or to establish truth or falsehood. It says artefacts provide records of secure software development practices. Task PO.3.3 is to configure tools to generate artefacts of their support of secure software development practices as defined by the organisation, and one of its examples is to use existing tooling, such as workflow tracking and issue tracking, to create an audit trail of the secure development-related actions that are performed for continuous improvement purposes.
On a small team, evidence is whatever a person who was not there can open later and reach the same conclusion from. This page's test for an artefact has four parts:
- It is tied to a commit or a release, so it is clear which code it speaks for.
- It names who did the work and who decided.
- It lives where the team already works: the repository, the pull request, the CI run or the issue tracker.
- It can still be opened after the people involved have moved on to other work.
What looks like evidence and is not
A ticked box with no link behind it, a screenshot with no commit, a message saying a feature was tested on someone's own machine and a test result from a different build all record that someone believed a check passed. None of them lets anyone else confirm it.
Keeping the evidence as it was
An example under NIST task PO.4.2 is to only allow authorised personnel to access the gathered information, and to prevent any alteration or deletion of the information. This page's reasoning is that a release record kept in the repository does not prevent a change, but it makes one visible, because a change to it is a commit with an author and a date.
What an artefact does not prove
ASVS makes the point about its own documentation requirements: verifying that the documentation is in place and verifying the actual implementation are two separate activities. A requirements list shows that a decision was written down. Only the review and the test show whether the code follows it.
What a gate is on a small team, and who decides
A gate is a short list of things that must exist before work moves to the next stage, and one named role who decides whether they do.
It is not a meeting and not a committee. NIST task PO.2.1 is to create new roles and alter responsibilities for existing roles as needed to encompass all parts of the SDLC, and to periodically review and maintain the defined roles and responsibilities, updating them as needed. Its examples include defining SDLC-related roles and responsibilities for all members of the software development team.
With four or five people, one person holds several roles. As this page's advice, that works while two rules hold. Nobody decides the gate that checks their own work: the author of a change is not its reviewer, and the author of a design does not sign off its review.
And the person who accepts a risk is someone who answers for the business, not the developer whose work fell short. The roles the map uses:
- Product owner: decides the requirements gate.
- Technical lead: decides the design, build and test gates, except where the technical lead wrote the work being checked.
- Reviewer: any developer other than the author. Decides the review gate.
- Release approver: one named person, such as the product owner or the business owner. Decides the release gate, and is the only role that accepts an exception.
A check, not a feeling
Each gate in the map is written as a check with a pass condition and a fail condition, so the decision is whether the condition is met, not whether the work feels finished. When the answer is no, there are three ways on: the work goes back, the scope is narrowed, or the failure is taken to the release approver as an exception.
How often the gates run
As this page's advice, the requirements, design, build, review and test gates run for each feature or change, and the release gate runs once for each release, however many changes it carries. NIST says any frequency it states for performing practices is notional.
Handling an exception without making the gate meaningless
When a release has to go out with something missing, the gate needs a way to say so.
In this page's view, a gate that allows no exception gets bypassed, and a gate that allows one without a record stops meaning anything. NIST's framework has examples that deal with exceptions directly. One of the examples under task PO.1.2 is to establish and follow processes for handling requirement exception requests, including periodic reviews of all approved exceptions.
Task PW.1.2 is to track and maintain the software's security requirements, risks and design decisions, and its three examples all touch exceptions: record the response to each risk, including how mitigations are to be achieved and what the rationales are for any approved exceptions to the security requirements; maintain records of design decisions, risk responses and approved exceptions that can be used for auditing and maintenance purposes throughout the rest of the software life cycle; and periodically re-evaluate all approved exceptions to the security requirements, and implement changes as needed.
This page's advice is that an exception is a record with six fields, and that it is not accepted until all six are filled in:
- The criterion that failed, by its id, with the failed result left in the record.
- The reason, in a sentence someone outside the team could follow.
- The interim measure that limits the risk while the exception stands, and where it is enforced.
- An owner: the person who will close it.
- An expiry date. On that date the exception stops covering the failure, and the gate fails again until the work is done or the approver makes a new decision.
- The approver, who is the release approver and not the owner.
Keeping exceptions from piling up
Three habits help, again as this page's advice. Every release record lists every open exception, including those accepted in earlier releases, so the approver sees the total each time. A renewal is a new decision with a new date, recorded beside the old one, not an edit to the old date.
And an exception renewed more than once is treated as a sign that the requirement or the plan is wrong, and goes back to the requirements stage.
The release-evidence check on this page looks for two of the six fields, the owner and the expiry date.
How reported vulnerabilities come back into the line
Release is not the end of the line.
NIST's fourth group of practices, Respond to Vulnerabilities, covers what happens next. Task RV.1.3 is to have a policy that addresses vulnerability disclosure and remediation, and to implement the roles, responsibilities and processes needed to support that policy. OWASP's Vulnerability Disclosure Cheat Sheet says organisations should provide a clear method for researchers to securely report vulnerabilities, and RFC 9116 defines security.txt, a machine-parsable format to help organisations describe their vulnerability disclosure practices. The vulnerability disclosure policy template in this library covers the policy itself.
A report from a researcher or a customer, an advisory for a component and a finding from a penetration test all enter the same log and take the same steps. The order is this page's, and the tasks are NIST's:
- Log it and give it an owner. One of the examples under task RV.2.1 is to use existing issue tracking software to record each vulnerability.
- Confirm and rate it. Task RV.2.1 is to analyse each vulnerability to gather sufficient information about risk to plan its remediation or other risk response.
- Decide. An example under task RV.2.2 is to make a risk-based decision as to whether each vulnerability will be remediated or if the risk will be addressed through other means, such as risk acceptance or risk transference, and to prioritise any actions to be taken. On this page's map, a decision not to fix is an exception with the same six fields as any other.
- Fix it through the gates. The fix gets a requirement and an acceptance criterion, a review and a test, like any other change. An example under task PW.8.2 is to incorporate tests for previously reported vulnerabilities into the project's test suite to ensure that errors are not reintroduced.
- Find the cause. Task RV.3.1 is to analyse identified vulnerabilities to determine their root causes, and task RV.3.3 is to review the software for similar vulnerabilities to eradicate a class of vulnerabilities, and proactively fix them rather than waiting for external reports.
- Change the line. Task RV.3.4 is to review the SDLC process, and update it if appropriate to prevent, or reduce the likelihood of, the root cause recurring in updates to the software or in new software that is created.
When the fix cannot wait for every gate
An urgent fix may need to ship before every gate has been through its check. As this page's advice, that is an exception like any other: the release approver records which gates are still open, who owns closing them and by when, and the gates are then closed after the release instead of being skipped.
An example under task RV.2.2 covers the case where a permanent mitigation is not yet available: determine how the vulnerability can be temporarily mitigated until the permanent solution is available, and add that temporary remediation to the plan.
The step that makes it a lifecycle
In the worked example, a report after release showed that the threat register asked what a person could open in the portal and never asked what the application sends out. The fix closed one gap. The change to the register template is what gives the next feature a chance of not repeating it.
Starting from no process: which gates to add first
NIST says some of its practices are foundational, while others are more advanced and depend on certain foundational practices already being in place, and that factors such as risk, cost, feasibility and applicability should be considered when deciding which practices to use and how much time and resources to devote to each practice. It also says the practices are not prioritised.
So the order below is this page's advice for a team starting from nothing. Three gates come first:
- The release gate, with a written record. Start a release record even while some of its rows are still empty. An empty row is information: it shows which evidence does not exist yet, and it gives one named person the job of deciding to ship anyway.
- The review gate, for changes that touch sign-in, permissions, personal data, payments or messages sent to people. A second reader needs no new tooling, and the pull request already records the result.
- Vulnerability intake. Publish a way to report a problem, send it a test message and check that the message lands somewhere a person reads. A report can arrive whether or not there is a process to receive it.
What to add next
Add the requirements gate next, for the same kinds of change, because every later gate checks against it. Add the threat register once the team has written enough requirements to see what it keeps missing, and the dependency decision record when the application next takes on a new component. This order is a judgement, not a rule from any framework.
For each gate, begin with a pass condition the team can meet now and tighten it later. In this page's view, a gate nobody can pass teaches people to work around it.
A secure release checklist, drawn from the map
A secure release checklist is the release gate written as questions.
The one on this page has fourteen, grouped by the stage each belongs to, so a no points at the row of the map that says what is missing and who decides. Three rules, all this page's advice, make it worth filling in:
- Every answer carries a link. A yes with no artefact behind it is the answer the checklist exists to prevent.
- Not applicable needs a reason. A release with no new dependencies has nothing to record at the build gate, and saying so takes one line.
- A no has two exits. It is fixed before release, or it becomes an exception with an owner and an expiry date. Leaving the answer blank is not a third.
What the checklist does not ask
The checklist asks whether evidence exists. It does not ask whether the application is free of vulnerabilities, and no checklist can answer that.
Walking through the worked example and the release-evidence check
The worked example on this page is an illustration written for it: an invented swim school, its invented parent portal and an invented feature that lets a guardian invite a second adult to manage a child's lessons.
None of it is a client's process or a client's result. The feature is carried through all seven gates, with what each artefact contained.
The gate that failed the first time
The test gate failed on its first run. Two of the six acceptance criteria failed: a revoked invitation link was still accepted, and a sixth invitation in one day was sent when the requirement allowed five. The two failures ended differently, which is the point of the example.
The revoked link was a defect. The technical lead recorded the decision to fix it and run again, the fix went back through the review gate, and the criterion passed on the second run. The daily limit had not been built and could not be before the release date, so the technical lead took it to the release approver, who accepted it as an exception with a reason, an interim measure, an owner and an expiry date. Each failed result stayed in the record beside its decision.
What the release-evidence check reads
The example's release record is saved as a JSON file that lists each gate's artefact, its criteria and their dated results. A script reads a record and reports three kinds of gap: a stage with no gate recorded or an artefact with no name or no location, a failed result with no recorded decision, and an accepted exception with no owner or no expiry date. It exits with code 0 when it finds none and with code 1 when it finds any.
Run on Node.js 26.0.0 on macOS against the complete record, it listed the seven stages, counted three failed results with three recorded decisions and one accepted exception with an owner and an expiry date, printed "No gaps found." and exited with code 0.
A second script then wrote a copy of the record with four pieces of evidence removed on purpose: the review gate's artefact, the decision on the first failed result, and the exception's owner and expiry date.
On that copy the check reported four gaps, one line for each, and exited with code 1. The check's fourteen tests, written for the Node.js test runner, all passed.
What the check is, exactly
It is an illustration that checks that evidence was recorded, not that the work behind it was done well. It opens none of the artefacts the record points to, so it cannot tell whether a review was careful or whether a test checks what its name says.
It does not compare an expiry date with today's date, and it does not check that a failed criterion later passed. Those judgements belong to the person deciding each gate.
What a process cannot tell you about the application
A complete release record says the team did what it said it would do.
It does not say the application has no vulnerabilities, for three reasons.
- A process checks against the requirements that were written. A risk nobody thought of has no criterion, no test and no row in the record. In the worked example every gate had been passed by release day, and the flaw reported afterwards sat in a question no one had asked.
- Evidence that a check ran is not evidence that the check was good. ASVS treats verifying that a decision is documented and verifying the actual implementation as two separate activities. In this page's view, a record can show the first without the second.
- NIST's framework describes a subset. NIST says the practices in its table are only a subset of what an organisation may need to do.
Why the application still gets tested directly
As this page's advice, the application still needs examining by someone who did not build it and is not working from its requirements list. Among its examples for task PW.8.2, NIST gives penetration testing with a condition attached: if resources are available, use penetration testing to simulate how an attacker might attempt to compromise the software in high-risk scenarios.
On this page's map, what such a test finds is one more input to the stage after release: each finding gets a row in the intake log and takes the same steps as any other report.
What it says to a customer
A process says nothing to a customer on its own. A buyer or an auditor decides what evidence they accept, and this page makes no claim about what any contract, standard or insurer asks of you.
Where a Clever Ops test or review fits in the line
Clever Ops tests custom web applications and their APIs, and reviews code for applications such as Next.js, React and Node with read-only access to the repository.
In the line described on this page, that work sits at the review and test stages and feeds the stage after release. It examines the application. It is not an assessment of a development process against the SSDF or SAMM.
A written scope sets what is tested. For a web application and API penetration test, the scope asks for two test accounts in each role, and accounts in two separate customer organisations if your application serves more than one. Code findings are confirmed against a running build where the scope allows, and the report marks any that rest on the code alone.
If your team keeps a requirements list, send it with the scope: a review checks the code against the rules you state. Each finding in the report comes with a fix and retest criteria your developers can turn into regression tests, so a finding can enter your intake log with its acceptance criterion already written.
You choose who makes the fixes: your own developers, your agency, or a Clever Ops security fix sprint under a separate statement of work. One consolidated retest is included, requested within the window set in your statement of work, and each finding then ends as fixed, partially fixed, still reproducible or not retested.
A report is evidence for your decisions, not a certificate. If Clever Ops built or hosts the application, the work is called a security review rather than an independent test, and the report states who built it and who hosts it.
Frequently asked questions
A secure SDLC is a software development lifecycle with a security activity placed at each stage, from requirements to after release, and a record of each one. NIST says few lifecycle models explicitly address software security in detail, so secure development practices usually need to be added to and integrated into each. In practice it means deciding what the software must refuse before it is built, and being able to show afterwards that this was checked.
A security acceptance criterion is the check that decides whether a security requirement was met. A usable one names who acts, what they attempt and what the application does in reply, and it can fail. For example: signed in as a customer of one organisation, a request for another organisation's invoice is refused. Each criterion becomes a test at the test stage or a question for the reviewer, and its result goes into the release record.
Questions that ask for evidence, grouped by stage: an acceptance criterion for every security requirement, a response for every threat register row, a decision for every new dependency, an approval from someone other than the author, a test result from the release commit, an owner and an expiry date for every exception, a named approver and commit, and a working way to report a vulnerability. The checklist on this page has fourteen questions.
This page presents neither as mandatory, and whether a customer or a contract asks for one is for you to check. NIST says the SSDF can be used by organisations in any sector or community, regardless of size or cybersecurity sophistication, and that not all practices are applicable to all use cases. SAMM says it was defined with flexibility in mind so that small, medium and large organisations can customise and adopt it. On this page's reading, both give a small team a vocabulary and a list of practices to choose from.
As read on 14 November 2026, NIST's publication page for SP 800-218 shows SSDF version 1.1, dated February 2022, with its final version listed on 3 February 2022. NIST also lists SP 800-218 Rev. 1, SSDF Version 1.2, as an Initial Public Draft published on 17 December 2025, with comments due on 30 January 2026 and the public comment period marked closed. Check NIST's pages for the status on the day you rely on a task identifier.
As this page's advice, one named person who did not write the change, such as the product owner or the business owner. NIST gives, as one example, appointing a single leader or leadership team to be responsible for the entire secure software development process, including being accountable for releasing software to production and delegating responsibilities as appropriate. On this page's map, that person is also the only one who accepts an exception.
No. A process checks against the requirements someone wrote, so a risk nobody thought of passes every gate. NIST says following its practices should help software producers reduce the number of vulnerabilities in released software. That is a smaller claim than removing them. NIST also describes the practices in its table as only a subset of what an organisation may need to do. This page's advice is that the application still needs testing by someone who did not build it.
On this page's map, at the test stage, with its findings handled like any report received after release. NIST lists penetration testing among its examples for testing executable code: if resources are available, use it to simulate how an attacker might attempt to compromise the software in high-risk scenarios. Each finding then gets a row in the vulnerability intake log: an owner, a rating, a decision, a fix with a regression test and a root cause.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.