Updated November 2026 · Written and maintained by the Progression Agency strategy team
Secure software development is the set of habits that keeps vulnerabilities out of released code and gets the ones that slip through fixed quickly: written security requirements, threat modeling, reviewed and tested code, protected builds and a plan for reports after launch. NIST’s framework for this work, SP 800-218, names 19 such practices, and OWASP adds a maturity model, a requirement standard and a list of the risks that matter most. This page takes each one in turn and shows the record a team should be able to hand a customer who asks. Progression’s developers are based in New York and build web, mobile and SaaS software for companies across the US.
On this page · 17 sections
- A security questionnaire the team could not answer
- What secure software development covers
- SP 800-218 practice by practice, with the record each leaves
- Threat modeling before the first line of code
- OWASP SAMM: measuring how mature the program is
- OWASP ASVS: the requirement list for one application
- The OWASP Top 10:2025, read as design decisions
- Software bills of materials and the supply chain
- Release integrity: hashes, signing and archived builds
- Safe defaults and protected build environments
- Code review, testing and the tools behind them
- After release: disclosure, triage and root causes
- Securing SaaS products: tenants, sign in and data
- Software development security best practices, as one checklist
- What secure development work costs
- How Progression’s team builds security into client software
- Related services
Looking for the life cycle?This page is about the practices and the proof. For where security work sits inside planning, design, build, test and release, see our software development life cycle guide.
Examples marked “Illustrative example.” are hypothetical, and no real company, product or customer is shown.
A security questionnaire the team could not answer
Illustrative example. A hypothetical SaaS company is close to its largest contract when the buyer sends a security questionnaire. It asks for a software bill of materials, the vulnerability disclosure policy, a way to check that a release has not been altered and the record of the last design review.
The team had scanners running and reviewed every pull request, but none of the four items existed on paper. Two weeks went to writing down work that was partly done. That is the gap this page is about: security practices that leave a record a customer can read. No real company, buyer or contract is shown here.
What secure software development covers
Secure software development means building security into how software is specified, designed, written, tested, released and maintained, rather than auditing it once at the end. NIST’s SSDF project page describes the framework’s practices as outcome based: they say what a team should achieve and leave the tools and methods to the team.
Security in software development rests on three kinds of reference. A framework says what to do across the whole operation (NIST SP 800-218). A maturity model measures how well a team does it (OWASP SAMM). A requirement standard says what one application must do (OWASP ASVS). The OWASP Top 10 sits beside all three as the shortlist of risks worth designing out.
Is software development and security one job or two?
One. Software development and security share the same backlog, the same pull requests and the same release, so the developers who write a feature also write its security requirements and tests, with specialists reviewing the riskiest parts.
Who asks to see this work?
Enterprise buyers, insurers, auditors and regulators in fields such as health and finance. SP 800-218 itself notes that purchasers can use its common vocabulary when talking to suppliers.
SP 800-218 practice by practice, with the record each leaves
Version 1.1 of the framework, published by NIST in February 2022 as SP 800-218, sorts 19 practices into four categories. Each practice has tasks and notional examples; NIST says no example is required and the listed ones are not the only options. The table gives each practice its NIST name, a plain reading and the record that proves it happened.
| ID | The practice, in NIST’s words | What it asks for in plain terms | The record a team keeps |
|---|---|---|---|
| PO.1 | Define Security Requirements for Software Development | Know the security rules that apply, including what third party component suppliers must meet | A requirements list, and the clauses sent to suppliers |
| PO.2 | Implement Roles and Responsibilities | Everyone involved, inside or outside the company, knows their security duties | Named roles and training records |
| PO.3 | Implement Supporting Toolchains | Automate security checks so they are repeatable and leave evidence | Pipeline configuration and tool logs |
| PO.4 | Define and Use Criteria for Software Security Checks | Decide what a pass looks like before checking | Written release criteria |
| PO.5 | Implement and Maintain Secure Environments for Software Development | Separate and protect development, build, test and distribution systems | Access rules, sign in policy, network separation |
| PS.1 | Protect All Forms of Code from Unauthorized Access and Tampering | Lock down who can change code | Repository permissions and branch rules |
| PS.2 | Provide a Mechanism for Verifying Software Release Integrity | Let customers confirm a release is genuine | Published hashes or code signatures |
| PS.3 | Archive and Protect Each Software Release | Keep every release and its provenance data | Archived builds and an SBOM per release |
| PW.1 | Design Software to Meet Security Requirements and Mitigate Security Risks | Design with the risks in view | Threat model and design notes |
| PW.2 | Review the Software Design to Verify Compliance with Security Requirements and Risk Information | Have someone outside the design, or automation, check it | Design review record |
| PW.4 | Reuse Existing, Well-Secured Software When Feasible Instead of Duplicating Functionality | Prefer proven, maintained components over new code | Approved component list |
| PW.5 | Create Source Code by Adhering to Secure Coding Practices | Write code to a known secure standard | Coding standard and review notes |
| PW.6 | Configure the Compilation, Interpreter, and Build Processes to Improve Executable Security | Turn on the build and compiler protections | Build settings under version control |
| PW.7 | Review and/or Analyze Human-Readable Code to Identify Vulnerabilities and Verify Compliance with Security Requirements | Code review, code analysis or both | Review approvals and analysis results |
| PW.8 | Test Executable Code to Identify Vulnerabilities and Verify Compliance with Security Requirements | Test the running software, record and triage findings | Test results in the issue tracker |
| PW.9 | Configure Software to Have Secure Settings by Default | Ship with safe settings switched on | A documented secure baseline |
| RV.1 | Identify and Confirm Vulnerabilities on an Ongoing Basis | Watch for new issues and have a disclosure policy | Disclosure policy and intake log |
| RV.2 | Assess, Prioritize, and Remediate Vulnerabilities | Fix by risk, not by arrival order | Risk notes and fix plan per issue |
| RV.3 | Analyze Vulnerabilities to Identify Their Root Causes | Fix the pattern, not only the bug | Root cause and lessons learned notes |
Before any code: people, tools and environments
The PO practices are about the company rather than one product. PO.1.3 asks that security requirements be sent to third parties who supply components, and PO.5.1 asks that each environment be separated and protected, with multi-factor sign in and network separation among NIST’s examples.
Guarding the code and every release
The PS practices protect what has been built. PS.2.1 suggests posting cryptographic hashes for release files on a well secured website and code signing through an established certificate authority; PS.3.2 asks for provenance data on every component, for example in an SBOM.
Writing and checking the software itself
The PW practices cover design, components, code, build settings, review, testing and defaults. PW.2.1 wants the design checked by a qualified person who was not involved in it, by automation in the toolchain, or both.
After release: finding and fixing
The RV practices start with RV.1.3, a policy for vulnerability disclosure and remediation, and end with RV.3.1, finding the root cause of each issue so the same mistake stops recurring.
Why is there no PW.3 in the current version?
It was merged. Version 1.1 moved PW.3, on third party software, into PW.4 and PO.1.3, which is why the numbering jumps from PW.2 to PW.4.
Threat modeling before the first line of code
Threat modeling is analyzing a picture of the system to find security and privacy concerns. The Threat Modeling Manifesto frames it as four questions, and its answer to who should do it is anyone concerned about the privacy, safety and security of the system.
OWASP’s threat modeling page lists what a model usually holds: a description of the subject, assumptions that can be challenged later, potential threats, actions to reduce each one and a way to validate the model. The output feeds design, development, testing and work after deployment, which is why SSDF task PW.1.1 names threat modeling among the ways to assess risk.
- Draw the system, including third party services and where data crosses a trust boundary.
- List threats per component and per data flow.
- Decide fix, control or accept for each, and name an owner.
- Turn each fix into a ticket and each control into a test.
- Repeat when the design changes, not once a year.
How small can a first threat model be?
One feature, one diagram and the people who designed it. Start with the feature that handles sign in, payments or personal data, then work outward one area at a time.
OWASP SAMM: measuring how mature the program is
OWASP’s Software Assurance Maturity Model measures the program rather than one application. The SAMM model defines five business functions with three security practices each, fifteen in all, and each practice holds activities in two streams across three maturity levels.
| Business function | Its three security practices |
|---|---|
| Governance | Strategy and Metrics; Policy and Compliance; Education and 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 |
SAMM is built to be measurable and does not expect every company to reach the top level everywhere. Each organization picks a target maturity for each practice, assesses where it stands and closes the gaps in planned rounds.
Which SAMM level should a small team aim for?
The one that matches its risk, practice by practice. A small product team often starts at level one across the board and moves to level two first in Threat Assessment, Security Requirements and Security Testing, where the payoff shows soonest.
A security questionnaire on your desk?Send the questions your buyer asked. You get a free proposal covering the practices, records and code changes behind each answer.
Get a free proposalTell us about a project you’d like help with.
OWASP ASVS: the requirement list for one application
The Application Security Verification Standard gives developers a list of requirements for secure development and testers a basis for checking them. Version 5.0.0 was published on May 30, 2025, and the ASVS project page links the full standard in PDF, Word and spreadsheet form.
The standard holds about 350 requirements across 17 chapters, from Encoding and Sanitization through Authentication, Authorization, OAuth and OIDC, Cryptography and Configuration to Security Logging and Error Handling. OWASP’s own example: an early stage startup holding little sensitive data might aim for Level 1, while a bank would struggle to justify less than Level 3 for online banking.
- Pick a level per application, based on the data it holds and what users expect.
- Drop chapters that do not apply, such as WebRTC when the product has no calls.
- Cite requirements with the version, for example v5.0.0-1.2.5, because numbers change between releases.
- Write the chosen level into contracts; OWASP names procurement as one of its uses.
Which ASVS level fits a SaaS product?
Level 2 for most. ASVS says most applications should be striving for it, and it covers about 70% of the requirements once Level 1 is included.
The OWASP Top 10:2025, read as design decisions
The OWASP Top 10:2025 is an awareness document that reflects broad agreement on the most critical risks to web applications. Each risk maps to a decision a team makes in design or code.
| OWASP Top 10:2025 risk | The design decision that answers it |
|---|---|
| A01 Broken Access Control | Check permissions on the server for every request, deny by default |
| A02 Security Misconfiguration | A documented secure baseline, applied the same way in every environment |
| A03 Software Supply Chain Failures | Approved components, pinned versions and an SBOM per release |
| A04 Cryptographic Failures | Proven libraries, current protocols and keys kept out of code |
| A05 Injection | Parameterized queries and encoding at every output |
| A06 Insecure Design | A threat model before building and a design review before release |
| A07 Authentication Failures | Multi-factor sign in and rate limits on login and reset |
| A08 Software or Data Integrity Failures | Signed releases and checks on updates and serialized data |
| A09 Security Logging and Alerting Failures | Logs for sign in, permission and admin events, with alerts someone reads |
| A10 Mishandling of Exceptional Conditions | Errors that fail safely and never leak internals |
The list is a floor, not a test plan. ASVS turns these risks into checkable requirements, and the threat model shows which ones matter most for a given product.
Software bills of materials and the supply chain
An SBOM is a formal record of the components used to build software and how they relate, as NTIA’s minimum elements report of July 12, 2021 defines it. Software supply chain failures sit third on the OWASP Top 10:2025, and SSDF task PS.3.2 asks for provenance data on every component of a release.
- Supplier name.
- Component name.
- Version of the component.
- Other unique identifiers.
- Dependency relationship.
- Author of the SBOM data.
- Timestamp.
NTIA sorts the minimum elements into three areas: those data fields, automation support so SBOMs are generated and read by machines, and practices covering how often they are made, how deep they go, known unknowns, delivery, access control and correcting mistakes.
Which SBOM format should we use?
SPDX or CycloneDX, both named by NTIA along with SWID tags. SPDX is recognized as the international standard ISO/IEC 5962:2021; CycloneDX, developed by OWASP and Ecma International, is at version 1.7 and standardized as ECMA-424. Pick the one your buyers and tools read, and generate it in the build.
Release integrity: hashes, signing and archived builds
A customer should be able to tell that the file they installed is the one you built. SSDF practice PS.2 exists for that, and its examples are concrete: publish cryptographic hashes for release files on a well secured website, and sign code through an established certificate authority so operating systems can check signatures.
- Build releases in the pipeline, never on a laptop.
- Publish a hash for every release file.
- Sign installers, packages and container images.
- Review the signing process and protect the signing keys.
- Archive each release with its build data and SBOM, as PS.3 asks.
Why archive old releases?
When a vulnerability turns up after launch, the team needs the exact files and components that shipped to judge who is affected. PS.3 asks for that archive for this reason.
Safe defaults and protected build environments
SSDF practice PW.9.1 asks for a secure baseline: every setting that affects security is configured so the defaults are safe and do not weaken the protections the platform provides. Testing the defaults belongs in the release checks.
PW.6 turns on the protections compilers, interpreters and build tools offer, and PO.5 protects the environments where software is built. NIST’s examples include multi-factor, risk based sign in for each environment and network separation between development, build, test and production.
- Ship with the most protective settings on, and let customers relax them knowingly.
- Keep build settings in version control.
- Separate production credentials from every other environment.
- Require multi-factor sign in for repositories, pipelines and cloud consoles.
Code review, testing and the tools behind them
SSDF practice PW.7 lets each organization decide when to use code review, a person reading the code, and code analysis, tools finding issues alone or with a person. PW.8 asks that testing be scoped and its results recorded and triaged in the team’s issue tracker.
| Kind of check | What it looks at | When it runs | SSDF practice |
|---|---|---|---|
| Peer code review | Logic, permissions and anything a tool cannot judge | Every pull request | PW.7 |
| Static analysis | Source code patterns that lead to vulnerabilities | Every commit or pull request | PW.7 |
| Dependency scanning | Known issues in third party components | Every build, and daily on released code | PW.4, RV.1 |
| Secret scanning | Keys and passwords committed by mistake | Every commit | PS.1, PO.5 |
| Dynamic testing | The running application, from the outside | Before release, against a test environment | PW.8 |
| Penetration testing | What a skilled attacker could chain together | Before major releases and on a schedule | PW.8 |
Can automated scanning replace a code review?
It cannot judge intent. Scanners are fast and consistent on known patterns; a reviewer catches broken permission logic and business rules a tool has no way to read, so most teams need both. Our quality assurance testing services cover the functional side.
Scanning belongs in the pipeline so every change is checked the same way; our DevOps services set that up, and website security services cover audits and penetration tests of what is already live.
After release: disclosure, triage and root causes
No release is free of flaws, so the response matters as much as the build. SSDF task RV.1.3 asks for a policy on vulnerability disclosure and remediation, with a program that makes it easy for security researchers to report, and, as a further example, a product security incident response team.
RV.2.1 asks that each vulnerability be analyzed for risk before planning the fix, and RV.3.1 that its root cause be recorded, so the team fixes the pattern across the code rather than one instance.
Does a small company need a disclosure policy?
Yes. A short page saying where to report, what to include and how quickly you reply costs little, and it gives researchers a better option than posting a flaw in public.
Securing SaaS products: tenants, sign in and data
Securing SaaS adds problems a single customer app never has. Many customers share one system, so a single missing check can expose one tenant’s data to another, which is why broken access control leads the OWASP list.
- Scope every query and every file path to the tenant on the server.
- Offer single sign on and multi-factor sign in, and test both against ASVS chapters on authentication, sessions, authorization and OAuth.
- Keep audit logs customers can read for sign in, permission and admin events.
- Encrypt data in transit and at rest, and keep keys out of code.
- Write the security requirements enterprise buyers ask about into the backlog early.
Our SaaS development work covers these features, and products holding health data follow the safeguards on our HIPAA compliant software development page.
What changes for app development security on phones?
The app runs on a device you do not control. Secure app development keeps secrets off the device, checks every request on the server, stores tokens in the platform’s protected storage and treats anything the app sends as untrusted input.
Software development security best practices, as one checklist
These are the best practices for secure software development we would set up first on any product, each tied to the standard it comes from.
- Write security requirements and choose an ASVS level (PO.1).
- Threat model each major feature before building it (PW.1).
- Have the design reviewed by someone who did not design it (PW.2).
- Prefer maintained components and scan them on every build (PW.4).
- Follow a secure coding standard and review every change (PW.5, PW.7).
- Test the running application and triage findings in the tracker (PW.8).
- Ship with safe defaults (PW.9).
- Protect repositories, pipelines and environments with multi-factor sign in (PS.1, PO.5).
- Publish hashes or sign releases, and archive them with an SBOM (PS.2, PS.3).
- Publish a disclosure policy and record root causes (RV.1, RV.3).
Building something new?Tell us what the product does and whose data it holds. The free proposal sets out the threat model, the ASVS level and the build.
Get a free proposalTell us about a project you’d like help with.
What secure development work costs
Pricing depends on scope, is subject to change and is set in the written proposal. The bands below are market figures, typical low to published high, for the security work most often added to a build.
| Type of work | Typical low to published high |
|---|---|
| Web application security review | $5,000 to $25,000 per project |
| CI/CD pipeline setup | $5,000 to $20,000 per project |
| Enterprise SaaS features (SSO, audit, SOC 2 prep) | $50,000 to $150,000 per project |
| US development rate | $100 to $200 an hour |
The cost of security for software development is mostly time inside the build: requirements, reviews and tests sit in the same sprints as the features. For wider project figures, see custom software development and app development cost.
Pricing depends on scope and is confirmed in a written proposal. Published prices are subject to change.
How Progression’s team builds security into client software
Our developers, designers and strategists are based in New York and build web applications, mobile apps, APIs and SaaS products for companies across the US. The security work our team can take on includes:
- Security requirements and an ASVS level agreed at the start.
- Threat models for the product and for each major feature.
- Design and code review, with scanning in the pipeline.
- SBOMs, release hashes or signing, and archived builds.
- A disclosure policy and response plan ready for launch.
- The records buyers ask for, ready before the questionnaire arrives.
Can you take over security work on software another team built?
Yes. We start from the code, the pipeline and any past findings, run a threat model and a review, and set out the fixes in order of risk.
Related services
Each page below covers one part of building and running software safely.
- Software development life cycle for the phases these practices sit in.
- AI in software development for reviewing and securing code written with AI.
- Software development company and software consulting for the wider build.
- Web app development and API development for the services most exposed to attack.
- iOS app development and Android app development for mobile apps.
- Healthcare software development and fintech software development for regulated data.
- Cloud migration and cloud hosting for the environments software runs in.
- Hire AI developers and AI diagnostics software development for AI products.
- MVP development for first releases that still need the basics.
- Agile software development for how the work is planned in sprints.
What this page leaves out: the Progression Method, proprietary and reserved for clients. Reach out to learn more
Getting found in search
AI, AEO and what is changing
Paid media and lead generation
Websites and design
Choosing and working with an agency
Software and app development
Website design by industry and type
Web development, platforms and hosting
Social, content and brand
By industry and by situation
Frequently asked questions
Which habits make up secure software development?
What is the NIST Secure Software Development Framework?
How many practices does the SSDF contain?
Does the SSDF require particular tools?
What are the four questions of threat modeling?
What is OWASP SAMM?
How is OWASP SAMM different from OWASP ASVS?
Which ASVS level should our application meet?
How many requirements does ASVS 5.0 have?
What is on the OWASP Top 10:2025?
What is a software bill of materials?
What must an SBOM include at minimum?
Which formats are used for SBOMs?
How can customers check that a release has not been altered?
What is a vulnerability disclosure program?
Should code review be manual or automated?
What are the best practices for secure software development?
How is securing SaaS different from securing other software?
Who should own software development and security in a small company?
How much does security work on a software project cost?
Can Progression build our software around the SSDF and ASVS?
A security questionnaire on your desk?Send the questions your buyer asked. You get a free proposal covering the practices, records and code changes behind each answer.
Get a free proposalTell us about a project you’d like help with.
Get a free marketing proposal
Tell us what you are trying to grow and we will come back with a plan, not a pitch deck. Same-day reply on weekdays.
