Securing the Software Development Lifecycle with NIST SSDF, Zero Trust, and Policy-Based Access Control
Software development environments are becoming increasingly complex, with organizations relying on cloud infrastructure, third-party components, automated tools, and distributed development teams. As software supply chains expand, securing applications requires more than addressing vulnerabilities before release. Organizations must integrate security throughout the software development lifecycle (SDLC), from initial planning and development to deployment and ongoing maintenance.
The National Institute of Standards and Technology (NIST) Secure Software Development Framework (SSDF) provides a foundation for building security into development processes. By combining SSDF practices with Zero Trust principles and Policy-Based Access Control (PBAC), organizations can strengthen security across development environments while maintaining the flexibility and speed needed for modern software delivery.
To explore these approaches, Alper Kerman and Michael Ogata join the NextLabs Expert Series to discuss NIST’s Software Supply Chain and DevSecOps Security Practices project. Kerman, Principal Investigator for Zero Trust, Secure Software Development, and AI projects at the National Cybersecurity Center of Excellence (NCCoE) at NIST, brings more than 30 years of experience in IT, including software engineering and application security. Ogata is a Computer Scientist in NIST’s Information Technology Laboratory, where he has contributed to digital forensics and cybersecurity since 2005.
Together, they share how the project translates NIST recommendations into practical DevSecOps implementations, addresses security challenges throughout the development lifecycle, and demonstrates how Zero Trust, AI, and policy-based access control can strengthen software security.
What Is NIST's Software Supply Chain and DevSecOps Security Practices Project, and What Motivated Its Launch?
Software supply chain security has become a growing priority for organizations. Through its Software Supply Chain and DevSecOps Security Practices project, NIST’s National Cybersecurity Center of Excellence (NCCoE) aims to help organizations build security into software development from the ground up.
The project focuses on developing practical demonstration DevSecOps environments that put the recommendations of the NIST Secure Software Development Framework into practice. According to Ogata, four primary factors motivated the initiative.
First, the project builds on positive community feedback surrounding the SSDF. NIST saw an opportunity to expand on that interest by helping organizations translate the framework’s recommendations into practical development processes. This also addresses the gap between theoretical security guidance and the everyday realities of software engineering, allowing organizations to better understand how to implement and continuously refine secure development practices.
Another motivation is demonstrating how organizations can meet SSDF recommendations using commercially available tools. By showing how different technologies can work together, the project illustrates how organizations can coordinate the various components of a secure software development environment. Finally, the initiative supports broader national cybersecurity goals by helping strengthen the security of software and its supply chains.
Because software development environments vary widely, the project intentionally focuses on a representative medium-to-large enterprise environment. These demonstration environments include core network infrastructure, cloud resources, and software-as-a-service solutions, reflecting the real-world need to protect intellectual property, critical assets, and organizational reputation.
The project’s findings are documented in a live resource available through the NIST project page. It provides step-by-step information about the composition, configuration, and behavior of each example implementation, giving organizations a reference they can adapt to their own software development pipelines. It also explains how the demonstrated technologies support individual SSDF practices and tasks.
How Does the Project Demonstrate the NIST Secure Software Development Framework in Real-World DevSecOps Environments?
To demonstrate the SSDF in practice, NIST first needed a model to guide the construction of a minimally viable software development environment. Working closely with industry partners, the team developed what it calls the Notional Reference Model.
The model expands on the traditional DevSecOps infinity diagram by describing the essential phases, components, activities, and workflows within a DevSecOps environment. It provides a blueprint for understanding how the different elements of a software development pipeline fit together and how they contribute to secure development.
With this reference model established, the project team mapped its components and activities to the goals and tasks outlined in the SSDF. The model then served as the foundation for building and documenting the demonstration environments.
The project’s documentation connects these elements through several resources. The Notional Reference Model describes the overall environment, while its mapping to the SSDF shows how the model aligns with the framework’s recommended practices. The Example Implementations section documents the composition of each environment, and the Functional Demonstrations section provides evidence of how the implementations perform against their intended outcomes.
Together, these resources establish a connection between the SSDF’s recommended tasks and the commercially available technologies that can support them. The project’s live documentation currently includes the results of two completed example implementations, offering organizations practical insight into how the framework can be applied within their own development environments.
What Are the Biggest Security Challenges Organizations Face Throughout the Software Development Lifecycle, and How Does the SSDF Help Address Them?
Organizations developing software face two major security objectives: delivering a secure final product and protecting the ecosystem used to create it. Both introduce challenges that must be addressed throughout the development process.
The SSDF provides a practical roadmap for implementing foundational security measures across the software development lifecycle. Its recommendations are organized into four practice areas: Prepare the Organization, Protect the Software, Produce Well-Secured Software, and Respond to Vulnerabilities.
These areas help organizations prepare their people, processes, and technologies for secure development; protect software components against tampering and unauthorized access; produce software with fewer security vulnerabilities; and establish processes for identifying and addressing vulnerabilities that emerge over time.
Each practice area includes specific tasks that organizations can use to address common security risks.
One challenge is that security is often treated as an afterthought because development teams are under pressure to release new features quickly. The SSDF addresses this through its Prepare the Organization practice area. For example, practice PO.1 recommends identifying, documenting, and maintaining security requirements from the beginning of the development process. These requirements apply not only to the software itself but also to the infrastructure used to develop it.
Third-party software components introduce another significant risk. Modern applications rarely consist entirely of code written from scratch. Instead, development teams depend heavily on open-source libraries and external components. If one of these components is compromised, it can introduce vulnerabilities into the larger application.
The SSDF addresses this through practices such as PO.1.3 and PW.4.4, which support establishing security requirements for acquired software and managing the risks associated with external components. Maintaining a Software Bill of Materials (SBOM) is also important. An SBOM provides an inventory of the components included in a software product, helping organizations understand what their applications contain and identify potentially risky components before they reach production.
Security testing presents another challenge, particularly when organizations wait until the end of the development cycle to scan for vulnerabilities. By that point, deadlines may be approaching, and discovering a significant flaw can require developers to rework substantial portions of the application.
The SSDF addresses this through practice PW.7, which emphasizes continuous security testing. Integrating automated security checks into everyday development workflows allows teams to identify and resolve vulnerabilities earlier rather than waiting until the final stages of development. This helps reduce bottlenecks and makes security testing a regular part of the development process.
Security responsibilities also continue after software is released. No application is completely immune to vulnerabilities, and new threats can emerge over time. Organizations therefore need processes for receiving vulnerability reports, evaluating risks, and distributing patches.
The SSDF’s Respond to Vulnerabilities practice area addresses this need through recommendations such as RV.1 and RV.2. These practices encourage organizations to establish vulnerability disclosure processes, receive and assess reports from external researchers, and respond appropriately to identified risks.
Underlying these recommendations is the principle of shifting left: introducing security earlier in the software development lifecycle rather than waiting until testing or deployment. Discovering vulnerabilities late in development or after release can be significantly more expensive and disruptive. By incorporating security into initial design decisions, threat modeling, and automated coding checks, organizations can identify potential problems before they become more difficult to resolve.
This shifts software security from a reactive process focused on fixing problems after they occur to a proactive approach that helps prevent vulnerabilities from being introduced in the first place.
How Is the Project Incorporating Emerging Technologies Like Zero Trust and AI, and Why Are They Important Complements to SSDF Practices?
As software development increasingly moves to cloud-based environments, development teams can collaborate and access resources from virtually anywhere. While this flexibility improves productivity, it also expands the potential attack surface. An environment that can be accessed from anywhere may also be targeted from anywhere.
This makes Zero Trust an important foundation for modern software security. Built around the principle of “never trust, always verify,” Zero Trust treats every access request as potentially malicious until it has been properly verified.
Through its project, NIST demonstrates how Zero Trust principles can be applied directly to the DevSecOps pipeline and mapped to SSDF practices. This includes authenticating code commits, securing cryptographic signatures, enforcing continuous monitoring, and maintaining artifact integrity throughout the development process. These measures help reduce opportunities for attackers to compromise software or manipulate development workflows.
Artificial intelligence is also changing how organizations develop and secure software. AI-powered tools can automate coding tasks, perform complex security analysis, and help identify and remediate vulnerabilities. These capabilities can improve software quality while allowing development teams to work more efficiently.
However, AI also introduces new security and privacy challenges. The reliability of AI-generated output depends heavily on the quality of its training data. If that data is incomplete or unverified, the resulting output may be flawed or insecure.
There are also risks associated with how developers use AI-generated recommendations. Developers may become overly reliant on AI suggestions and incorporate insecure code into repositories without adequately reviewing it. Additionally, organizations may struggle to maintain visibility into where AI is being used, particularly when third-party code sources and autonomous AI agents are involved.
To address these concerns, Kerman emphasizes the importance of keeping humans involved in the development process. While AI can generate code and assist with security tasks, human oversight remains essential for reviewing, verifying, and validating its output.
Ultimately, Zero Trust and AI are not replacements for the SSDF. Instead, they complement its practices. By combining responsible AI use, Zero Trust security measures, and a structured secure development framework, organizations can improve development efficiency while strengthening the security of the software they produce.
What Role Does Policy-Based Access Control Play in Securing DevSecOps Environments?
Access control is another essential component of securing modern software development environments. Traditional approaches often rely on usernames, passwords, and predefined roles to determine who can access specific resources. However, these methods can be insufficient in complex DevSecOps environments where organizations must protect sensitive assets such as source code, production data, and cloud infrastructure.
Modern development also involves fast-paced collaboration and automation. Developers, security analysts, and operations teams frequently work in parallel from remote or hybrid locations. At the same time, organizations increasingly rely on hybrid cloud environments, introducing additional complexity when enforcing consistent security policies across distributed infrastructure.
Policy-Based Access Control addresses these challenges by separating access logic from individual applications. Traditionally, access rules may be hard-coded directly into application software, meaning changes to permissions can require modifications to the underlying code. With PBAC, access logic is instead defined and managed through a centralized policy repository.
This approach provides three important advantages: uniformity, dynamic authorization, and agility.
First, centralized policies help establish consistent access rules across an organization’s hybrid cloud environment. Rather than managing separate access rules within individual applications, organizations can apply standardized policies across their infrastructure.
Second, PBAC enables dynamic, context-aware access decisions. Policies can evaluate real-time attributes such as a user’s location, device health, and time of day before granting access. This allows authorization decisions to account for the circumstances surrounding each request rather than relying solely on predefined permissions.
Third, centralized policy management makes access controls more adaptable. When the threat landscape changes or new security requirements emerge, organizations can update their policies without rewriting application code. The broader environment can then adapt to those changes through the updated policies.
These capabilities make PBAC a natural complement to Zero Trust. Zero Trust requires continuous evaluation of risk and strict enforcement of least-privilege access. PBAC provides a mechanism for making context-aware authorization decisions so that users and automated processes receive only the permissions they need at a particular moment.
Within the NIST project, Zero Trust and PBAC work together as an overarching security model for the demonstrated DevSecOps environment. By incorporating Zero Trust orchestration and policy-based verification and authorization throughout the development ecosystem, the project demonstrates how organizations can support rapid, automated deployment while maintaining strong security controls.
What Should Organizations Take Away from This Project?
Software development is not a one-size-fits-all process. Organizations use different technology stacks, cloud environments, development workflows, and regulatory models. For that reason, NIST’s project is not intended to prescribe a single approach to DevSecOps. Instead, it provides open, adaptable reference implementations built around the SSDF that organizations can use to inform their own security practices.
Kerman highlights three important takeaways for organizations reviewing the project’s practice guide.
First, organizations should focus on security outcomes rather than specific tools. While the guide uses particular technologies to demonstrate secure continuous integration and deployment, the objective is to illustrate the security results those tools help achieve. For example, an organization does not need to use the same automated scanning tool featured in the guide. What matters is ensuring that vulnerability checks occur at the appropriate stages of its development pipeline.
Second, the project provides a practical way to map real-world DevSecOps workflows to established security standards. Organizations can examine the example pipeline implementations to understand how their own processes align with SSDF practices. Areas such as secrets management, artifact signing, and generating Software Bills of Materials provide useful benchmarks for evaluating existing development environments and identifying security gaps.
Third, the project looks ahead to emerging DevSecOps challenges by incorporating guidance on Zero Trust principles and the management of new technologies throughout the software development lifecycle. As development environments continue to evolve, organizations need security practices that can adapt alongside them.
Ultimately, NIST hopes organizations will use the guide as a starting point for conversations between their security, development, and operations teams. By working together to evaluate existing processes and identify opportunities for improvement, these teams can build more secure and resilient software development environments.
Strengthening Software Security Through Secure Development Practices
Securing the software development lifecycle requires a comprehensive approach that addresses risks from initial planning through deployment and ongoing maintenance. NIST’s SSDF provides organizations with a structured foundation for implementing secure development practices, while Zero Trust and Policy-Based Access Control help strengthen verification, authorization, and security across increasingly complex environments.
Thank you to Alper Kerman and Michael Ogata for sharing their expertise and insights into NIST’s Software Supply Chain and DevSecOps Security Practices project.
To learn more, explore NIST’s work on secure software development and DevSecOps practices, and discover more educational discussions with cybersecurity experts through the NextLabs Expert Series.
Discover more from NextLabs’ Expert Series, featuring industry experts in educational and thought-provoking conversations on Data-Centric Security, Zero Trust Architecture, Safeguarding AI, and more.
To comment on this post
Login to NextLabs Community
NextLabs seeks to provide helpful resources and easy to digest information on data-centric security related topics. To discuss and share insights on this resource with peers in the data security field, join the NextLabs community.
Don't have a NextLabs ID? Create an account.