A B2B SaaS company is two months away from signing its largest customer, a regional bank. The bank’s vendor risk team sends a questionnaire and asks for an independent penetration test before contract signature. The test report arrives a week later with one critical finding: by changing a tenant identifier in an API call, a user of one customer can read another customer’s records. It is not one endpoint. It is every endpoint that reads tenant data, because the architecture assumed the API gateway enforced tenant isolation and the services behind it trusted whatever reached them. The fix is not a patch. It is a redesign of the data access layer, and the bank deal slips by a quarter.

Then everyone opens the development contract with the outsourced team that built the platform. The security section has one sentence: “The Supplier shall follow industry security best practices, including the OWASP Top 10.” The vendor says it did: the gateway validates tokens. The client says cross-tenant access is an obvious defect. Both have a point, and nothing in the contract decides who pays for three sprints of rework.

This article is for CTOs and CISOs who commission software from external teams. The argument is this: you cannot buy security by design with a vendor’s declaration or with a pentest at the end of the project. You buy it as evidence, meaning specific artifacts delivered every sprint and written into the contract as acceptance conditions. And the first sprint has to produce three decisions: a threat model, an OWASP ASVS requirements level and an identity architecture built on zero trust principles. If they are not made in sprint zero, they will not be made later, because every feature that follows hardens whatever trust assumptions were already in place.

Why does a “the vendor follows security best practices” clause mean nothing?

Because nobody can verify it, either during the project or at acceptance. “Best practices” have no list, no version and no pass criteria. A vendor that reviews code and runs a dependency scanner follows some practices. A vendor that also models threats and verifies requirements from a named standard follows different ones. Under that clause, both comply.

Pointing to the OWASP Top 10 sounds more precise but does not fix the problem. The Top 10 is an awareness document: a list of the most common risk categories in web applications, useful for training and for briefing executives. It is not a set of requirements you can tick off at acceptance. The category “broken access control” does not tell you whether every request for an object must check that the caller owns that object, or whether checking that the caller is logged in is enough. That difference cost the SaaS company in the opening example a quarter of revenue.

The second trap is certification. A vendor’s ISO/IEC 27001 certificate says the company runs an information security management system. That matters when you assess how the vendor protects your data and access to your systems. It says nothing about how the application it builds for you is designed. The certificate covers the organization, not the product. The same applies to a SOC 2 report: it describes controls at the service organization, not the architecture of the code it hands over.

The third trap is the security questionnaire filled in during vendor selection. Questions like “do you follow a secure software development lifecycle?” collect “yes” answers, because nobody answers otherwise. A questionnaire is useful when it asks for evidence: “show us an anonymized threat model from a recent project”, “how do you record an exception to a security requirement?”. Then it becomes a test rather than paperwork.

The conclusion for the contract is simple. A security clause must say what the vendor will deliver, when, and against which acceptance criterion. Everything else is a declaration.

How is security by design different from security testing at the end?

Security testing checks whether a finished system contains flaws. Security by design decides which flaws can exist at all. It is the difference between detection and prevention, and also between two kinds of defect.

An implementation defect is a mistake in code: missing input validation on one form, a database query built from concatenated strings, a forgotten header. Scanners, code reviews and penetration tests find these, and they can usually be fixed in one place. A design defect is a wrong assumption: internal services trust each other, permissions are checked only at the edge, all tenants share one database with no enforced isolation, secrets live in configuration files. Those cannot be fixed in one place, because they are present wherever the assumption was applied. OWASP introduced a separate category for them, “Insecure Design”, in its 2021 Top 10, precisely to distinguish them from implementation flaws. A perfect implementation will not rescue a bad design.

NIST says the same thing in the Secure Software Development Framework (SSDF, SP 800-218, version 1.1, February 2022). Practice PW.1 reads: design software to meet security requirements and mitigate security risks. The description states that addressing requirements and risks during design, “secure by design”, is key to improving software security and also helps development efficiency. The tasks are concrete: use risk modeling such as threat modeling, attack modeling or attack surface mapping (PW.1.1), track the software’s security requirements, risks and design decisions (PW.1.2), and build on standardized security features for identity, access control and logging instead of proprietary ones (PW.1.3).

It is worth setting aside a popular argument while we are here. Slide decks often show a chart claiming a defect fixed in production costs a hundred times more than one fixed in design. The provenance of that specific multiplier is poorly documented and it is not a sound basis for a business case. NIST’s formulation is more careful and sufficient: the earlier security is addressed in the lifecycle, the less effort and cost it takes to reach the same level of security. The opening example is a better argument than any multiplier. Changing the tenant isolation assumption in sprint zero is a few hours of discussion. In sprint twelve it is rework across every data endpoint plus a retest, with a customer waiting.

None of this makes penetration testing pointless. Its role changes. In a project run on security by design principles, a pentest is independent verification that the design and implementation behave as intended. In a project without them, the pentest is the only control and the first moment anyone looks at the system through an attacker’s eyes. Then every critical finding arrives too late.

What do NIST SSDF, CISA Secure by Design, the CRA and NIS2 say, and what follows for the contract?

These four sources have very different legal status, but they point the same way: responsibility for software security lies with whoever produces the software, and it has to be demonstrable.

NIST SSDF (SP 800-218). A set of practices in four groups: prepare the organization (PO), protect the software from tampering and unauthorized access (PS), produce well-secured software (PW) and respond to vulnerabilities (RV). For a buyer the key practice is PO.1.3: communicate requirements to all third parties who provide software components. The implementation examples describe defining a core set of security requirements and including it in acquisition documents, software contracts and other agreements, defining security criteria for selecting suppliers (including their vulnerability disclosure program) and requiring suppliers to attest that they meet the requirements. The SSDF is deliberately not a checklist: NIST stresses that it describes outcomes, not tools. That makes it a good frame for a contract and a poor acceptance criterion for an individual feature. In December 2025 NIST published a draft of version 1.2 (SP 800-218 Rev. 1) for comment. For now, a contract is safer citing version 1.1 or “the version in force on the date of signature”.

In the US the SSDF also has formal weight. CISA and OMB built the Secure Software Development Attestation Form on it, released in March 2024 under Executive Order 14028 and OMB memoranda M-22-18 and M-23-16. Software producers selling to federal agencies have to confirm specific secure development practices on it. If you are not a federal buyer the form does not bind you, but it is a useful template for what to ask your vendor to attest.

CISA Secure by Design. Guidance published in April 2023 and updated in October 2023 by CISA and 17 US and international partners rests on three principles: take ownership of customer security outcomes, embrace radical transparency and accountability, and lead from the top. In May 2024 CISA launched the voluntary Secure by Design Pledge, signed by 68 companies at launch and, according to CISA, by hundreds since. Signatories commit to show measurable progress within a year on seven goals: multi-factor authentication, eliminating default passwords, reducing entire classes of vulnerability, increasing customer installation of security patches, publishing a vulnerability disclosure policy, CVE transparency and giving customers the ability to gather evidence of intrusions. The pledge is not legally binding and targets product manufacturers rather than development agencies, but those seven goals make a ready-made requirements list for your own application.

EU Cyber Resilience Act (Regulation (EU) 2024/2847). In force since December 10, 2024. Since September 11, 2026, manufacturers must report actively exploited vulnerabilities and severe incidents: an early warning within 24 hours, a notification within 72 hours and a final report later. The remaining obligations apply from December 11, 2027. Annex I requires, among other things, that products are designed and produced to ensure an appropriate level of cybersecurity based on the risks, are delivered with a secure by default configuration and are protected from unauthorized access through authentication, identity or access management. Manufacturers must carry out and document a cybersecurity risk assessment, exercise due diligence when integrating third-party components, draw up an SBOM covering at least top-level dependencies and provide a support period that is, as a rule, at least five years. We covered the SBOM side in detail in our article on why SBOMs are becoming mandatory.

The key point for the vendor relationship: under the CRA, a manufacturer also includes anyone who has a product designed or developed and markets it under its own name. If you commission an application that you sell or provide to customers under your brand, the obligations are yours, and your vendor must give you what you need for the technical documentation. A risk assessment, an SBOM and a vulnerability handling process cannot be produced after the fact.

NIS2 (Directive (EU) 2022/2555). If your organization is an essential or important entity, Article 21 requires measures covering supply chain security and security in network and information systems acquisition, development and maintenance, including vulnerability handling and disclosure. Article 21(3) adds that, when assessing the supply chain, entities must consider the overall quality of their suppliers’ cybersecurity practices, including their secure development procedures. In plain terms, a regulator can ask how you checked that your software vendor develops securely, and “they had a certificate” will be a weak answer. Financial entities also have DORA, which we covered in our piece on choosing a vendor for financial software.

What follows for the contract? Security terms should map onto the outcomes these frameworks expect: a documented risk assessment, requirements communicated to the vendor, evidence that they were met, SBOMs, a vulnerability handling process with deadlines and a defined support period.

What does zero trust mean in a software project rather than a corporate network?

Zero trust is usually associated with network products: VPN replacement, microsegmentation, access brokers. That is one area, but not the one you decide on when you commission an application. NIST SP 800-207, published in August 2020, defines zero trust as a set of principles that move defenses from static network perimeters to users, assets and resources. Access is not implicitly trusted because a request came from inside the network. Authentication and authorization are discrete steps performed before access to each resource.

The seven tenets of SP 800-207 translate directly into application requirements. All communication is secured regardless of network location, so traffic between services is encrypted and authenticated too. Access to a resource is granted per session with least privilege, and authenticating to one resource does not automatically grant access to another. Access is determined by dynamic policy based on identity, device state and context. Authentication and authorization are enforced before access, every time. The organization collects information about asset state and traffic to improve its security posture.

NIST SP 800-207A, published in September 2023, applies these principles to cloud-native applications in multi-cloud environments. The central shift is from controls based on network segmentation to controls based on identity: applications and services carry their own identities, and authentication and authorization policies refer to those identities rather than IP addresses or subnets. The document lists the platform components that make this possible: API gateways, sidecar proxies and application identity infrastructure such as SPIFFE.

In project terms, this means a handful of decisions made early that are hard to reverse later:

  • Where authorization happens. Does the service that returns a record check that the caller may see that specific record, or does it trust that the gateway checked? Zero trust requires the former.
  • How services authenticate to each other. Mutual TLS with workload identities and short-lived tokens, or “we trust it because it is on the internal network”.
  • How tenant data is isolated in a multi-tenant system: separate databases, separate schemas or a filter in every query, and what guarantees the filter is always applied.
  • Where secrets live and how long they are valid. A secrets manager, rotation, no keys in the repository.
  • What gets logged, so that after an incident you can reconstruct who accessed what, and when.

These are not product purchases. They are architecture. If the vendor makes them alone, under the time pressure of the first sprints, it will usually choose the simplest option, which is network-based trust. Not out of bad faith, but because nobody wrote down a different requirement.

Which three decisions must be made in sprint zero?

Sprint zero, discovery, inception: whatever it is called, it is when the team settles architecture, environments and the initial backlog. It is also the only point at which security decisions are cheap. Make three of them explicit deliverables of that phase.

Decision one: threat model version 1. It does not need to be exhaustive. It must answer the four questions the Threat Modeling Manifesto puts at the center: what are we working on, what can go wrong, what are we going to do about it, and did we do a good enough job. The output is a data flow diagram with trust boundaries, a list of threats with a rating, and a list of decisions: which threats are mitigated in the architecture, which in code, which are accepted, and who accepted them.

Decision two: the ASVS level and its scope map. Client and vendor choose an OWASP ASVS level for the system or for parts of it (an admin console may warrant a higher level than a public catalog) and record which chapters are in scope and which do not apply. The output is a table of requirements mapped to components, with how each will be verified.

Decision three: identity and access architecture. Who authenticates and how (end users, administrators, services, partner integrations), where authorization is enforced, which permission model applies (roles, attributes, relationships), how tenant data is isolated and where secrets are stored. The output is a short architecture decision record that can be checked in review.

Add data classification: what data the system processes and which of it is sensitive. The SSDF lists it among the implementation examples for PW.1.1, because without it you cannot judge which threats matter.

Does this slow the start? A little. In a typical discovery phase, which in ARDURA’s custom software development projects takes one to two weeks, these three outputs take a few days of an architect’s and a security specialist’s time plus a few hours of workshops with your team. The alternative is making the same decisions implicitly, in code, by whoever happens to implement login.

How do you commission threat modeling so it does not end as one diagram?

The usual fate of a threat model: it is produced in a sprint zero workshop, lands in the wiki and nobody opens it again. Six months later the system has three new integrations and a second user type, and the model describes a version that no longer exists. To avoid this, commission threat modeling as a process with triggers, not as a document.

A clause in the contract or the statement of work might read: “The Supplier maintains a threat model of the system. The model is updated before implementation of any change that adds a new entry point, a new integration with an external system, a new category of sensitive data, or modifies authentication or authorization. The update is a condition of the user story being done.” Triggers matter more than a calendar, because a quarterly review misses the change that shipped in week two.

The method matters less than people think. STRIDE (spoofing, tampering, repudiation, information disclosure, denial of service, elevation of privilege) works well as a question list for each element of the diagram. Attack trees help with a single critical scenario such as account takeover. LINDDUN helps where the main risk is privacy. Do not impose a method if the vendor has one it knows well. Impose the output: a diagram with trust boundaries, rated threats and decisions with owners.

Signs that a threat model is actually working:

  • Threats are linked to the backlog. Every threat chosen for mitigation has a corresponding story, acceptance criterion or ASVS requirement. Without that link the model is a description, not a plan.
  • Risk acceptance has a name on it. SSDF practice PW.1.2 calls for recording the response to each risk and the rationale for approved exceptions. The vendor cannot accept risk in your system on its own. Your product owner or CISO does.
  • Someone outside the project team reviews it. SSDF practice PW.2.1 calls for design review by a qualified person not involved in the design, or by an automated process. That can be a vendor security specialist from outside the project, your own architect or an independent firm.
  • The model is short. Twenty threats with decisions are worth more than two hundred without.

Your side has to take part. The vendor knows the technology, but only you know which data is critical to the business, what fraud happened in the old system and who might realistically want to attack it. A modeling workshop without a business representative and without someone from your security function produces a threat model of a generic application, not of yours.

How do you use OWASP ASVS as a specification rather than a wish list?

OWASP’s Application Security Verification Standard version 5.0, released on May 30, 2025, contains roughly 350 requirements across 17 chapters and keeps three levels. Level 1 is the entry point, Level 2 covers standard practice for most applications, and Level 3 is meant for systems with high assurance needs, such as those handling money, health data or critical infrastructure. OWASP explicitly lists procurement as one of the standard’s purposes: ASVS is intended as a basis for specifying application security verification requirements in contracts.

Version 5.0 has another property that matters to buyers: requirements are phrased around what to prevent rather than which technology to use, and new requirements cover documenting key security decisions. That makes it easier to tailor the standard to a specific system and to settle disputes later.

The mistake that turns ASVS into a wish list is writing “the application shall comply with OWASP ASVS Level 2” into the contract. It sounds rigorous, but at acceptance nobody verifies several hundred requirements at once, and when pricing, the vendor does not know which of them even apply. The result is usually one of two outcomes: the clause stays dead, or it triggers a dispute at the first pentest finding.

A better path has four steps:

  1. Choose the level from the threat model and data classification, not from ambition. For most business applications that process personal data, Level 2 is a sensible baseline, with Level 3 for selected areas such as payments or the admin console.
  2. Map the scope. Which chapters and requirements apply and which do not (for example, requirements for features the system does not have). The map is a contract annex or the first deliverable of sprint zero.
  3. Assign requirements to the backlog. Authentication requirements become acceptance criteria on login stories, logging requirements go to audit stories, and so on. Some become part of the definition of done for every story.
  4. Define how each requirement is verified. An automated test, a scanner rule, a code review, a configuration review or a manual test. A requirement without a verification method is a declaration.

A map prepared this way has a further benefit: it gives the penetration tester a defined scope. Instead of “test the application”, you commission verification of selected ASVS requirements and the scenarios from the threat model. Quotes become comparable and the test is easier to sign off. We covered typical price ranges for different test types in our article on penetration testing costs.

Which zero trust requirements belong in the backlog?

Zero trust principles become enforceable only when they turn into stories and acceptance criteria. Below is a starting set for a typical web application with an API, several services and some integrations. It is not exhaustive. Your threat model will add items specific to your system.

Object-level authorization on every request. Acceptance criterion: every endpoint that returns or modifies a resource checks the caller’s right to that specific resource, and an automated test confirms that user A cannot read or modify user B’s resource, and tenant A cannot reach tenant B’s data. This is exactly the flaw this article opened with, and one of the most frequent findings in API testing.

Deny by default. A new endpoint without an explicitly defined access policy is unreachable, not open. This is far easier to build into the application skeleton in sprint zero than to retrofit.

Service identity and service-to-service authentication. Services communicate with mutual authentication, and each service holds only the permissions to other services it needs. Being on the internal network is not a reason for trust.

Multi-factor authentication, phishing-resistant where possible, at least for administrators and high-risk operations. It is the first of the seven goals in the CISA Secure by Design Pledge.

No default passwords and secure defaults. A new installation or environment never starts with an “admin/admin” account, and security settings are on from day one. This is both a CISA pledge goal and a CRA Annex I requirement.

Short-lived credentials and secrets outside the code. Short-lived access tokens, key rotation, secrets in a secrets manager, a secrets scanner in the pipeline.

Tenant isolation. In a multi-tenant system, isolation of customer data is enforced in one tested place, not left to every individual query.

Logs that let you reconstruct an incident. Authentication events, permission changes, access to sensitive data and administrative actions are logged in a tamper-evident way, with a retention period agreed with your security team. The seventh goal of the CISA pledge is precisely about letting customers gather evidence of intrusions.

These requirements have two layers. Some are one-off stories in sprint zero (the authorization skeleton, workload identity setup, the secrets manager). Others are permanent definition-of-done items that apply to every new feature (an object authorization test, no secrets in code, event logging). The second layer matters more, because it is what protects the system from the slow erosion of principles over later sprints. If you want to automate the technical checks in the pipeline, our DevSecOps implementation checklist walks through it stage by stage.

What should the vendor deliver every sprint as evidence?

If security is going to be accepted rather than declared, you need a list of artifacts with timing and acceptance criteria. The table below is a starting proposal. The reference column shows which practice or requirement each artifact supports, which makes it easier to demonstrate alignment with the SSDF, NIS2 or the CRA later.

ArtifactWhenAcceptance criterionReference
Threat model with decisionsSprint zero, then on every triggerDiagram with trust boundaries, rated threats, decisions with owners, linked to backlogSSDF PW.1.1, PW.1.2; CRA risk assessment
ASVS requirements mapSprint zero, updated on scope changeChosen level, requirements in and out of scope, verification method for eachASVS 5.0; SSDF PO.1.3
Identity and access architecture decisionsSprint zeroUser and service authentication, where authorization is enforced, data isolation, secrets handlingNIST SP 800-207, 800-207A; CRA Annex I
SAST, SCA and secrets scan resultsEvery sprint, automated in the pipelineNo open critical or high findings without an approved exceptionSSDF PW.7, PW.8
Object authorization testsEvery story that adds an endpointAutomated “user A cannot see resource B” test in the pipelineASVS authorization chapter
SBOMEvery releaseMachine-readable format (SPDX or CycloneDX), at least top-level dependenciesCRA Annex I Part II
Vulnerability and exception registerReviewed every sprintStatus, deadline, owner, exception rationale approved by the clientSSDF RV.1, RV.2; NIS2 Art. 21
Design review by someone outside the teamSprint zero and before major changesNote with findings and how they were closedSSDF PW.2.1
Independent security testBefore first production release, then periodicallyScope taken from the ASVS map and threat model, findings closed or acceptedSSDF PW.8; ASVS

The list looks long, but after sprint zero most of it is produced automatically. The pipeline generates scanner results, the build tool creates the SBOM, and authorization tests are ordinary tests in the repository. Manual effort goes into the threat model, the ASVS map and the exception register, which are exactly the places where a human decision is needed.

The report you receive can fit on one page per sprint: changes to the threat model, new and closed findings by severity, new exceptions awaiting approval and a link to the release SBOM. If a vendor cannot produce that page, it is a sign the data is not being collected.

Which contract terms put responsibility where it belongs?

The artifact table describes what the vendor does. The contract also has to settle what happens when something goes wrong. The terms below are worth discussing with counsel. Specific values are negotiating proposals, not a market standard.

Security in the definition of done. A story is not done until it passes the required checks: authorization tests, scans without open critical findings, a threat model update when a trigger applies. This is the simplest and most effective clause, because it ties security to acceptance and payment.

Remediation deadlines by severity. For example: critical within a few days, high within a few weeks, medium in the next planned release, with an obligation to apply an immediate mitigation when the fix takes longer. Actively exploited vulnerabilities, such as those listed in CISA’s Known Exploited Vulnerabilities catalog, are worth treating as critical regardless of their CVSS score. Where a defect stems from failing to implement an agreed requirement, the vendor bears the cost of the fix.

Distinguishing a defect from a change. If a requirement was agreed in the threat model and ASVS map and the system does not meet it, that is a defect. If the requirement appeared later, it is a change in scope. Without that map, every pentest finding becomes an argument about whether “it was in scope”. In the opening example, such a map would have settled the dispute in five minutes.

Notification of vulnerabilities and incidents. The vendor informs you of a vulnerability in delivered code or its dependencies within a defined time of discovery. If you are a manufacturer under the CRA, the contract timeline must leave you room for the 24-hour early warning. A contract that gives the vendor a week to tell you makes your statutory deadline impossible.

Support period and security updates. How long the vendor delivers security fixes and on what terms. For products within the CRA the support period is, as a rule, at least five years, so a one-year maintenance agreement is not enough unless you take over maintenance yourself.

Subcontractors and components. Consent for subcontracting, flow-down of security requirements to subcontractors and rules for admitting new open source libraries. The CRA requires due diligence when integrating third-party components, and NIS2 requires you to assess supplier practices.

Right to independent verification. You may commission a code review, penetration test or process audit from an independent firm, and the vendor provides the repository, a test environment and documentation. Without this clause the vendor can make verification difficult, and you pay for extra negotiation.

Access to your systems. Vendor team accounts with least privilege, multi-factor authentication and revocation within an agreed time after someone leaves the project. Zero trust applies to the vendor too.

A practical note on fixed-price contracts: a vendor asked to price a system without knowing the ASVS level or the threat model scope will price the cheapest interpretation or add a hidden contingency. If the contract is fixed-price, security requirements must be known before pricing. That is a strong argument for running discovery, with the three decisions described above, as a separate engagement before the main one.

What does security by design cost, and how do you fit it into the budget?

There is no reliable market ratio that tells you what share of a project budget should go to security. Any such number depends on the ASVS level, data sensitivity, the number of integrations and the maturity of the team. It is more honest to build a parametric estimate and show the assumptions.

An illustrative example for a five-month project in two-week sprints, roughly ten sprints. Assumptions: in sprint zero a security specialist spends four to five days on the threat model, the ASVS map and the review of architecture decisions, and in each later sprint one to two days on reviews, model updates and finding triage. ARDURA’s software testing services page puts security specialist rates at about EUR 300-560 per day. Sprint zero then costs roughly EUR 1,200-2,800 and the remaining nine sprints roughly EUR 2,700-10,100, for a total of about EUR 3,900-12,900. On top of that comes development time for the backlog requirements and an independent test before launch.

How does that compare with the cost of skipping it? Use your own project rather than industry statistics. Redesigning the authorization layer of a system that already has dozens of endpoints means several weeks of work for the whole team, a delayed launch and a retest. ARDURA’s software development page puts a typical three-person team at about EUR 14,500-28,700 per month; a five-person team for six weeks of rework lands somewhere around EUR 36,000-72,000, several times the security budget in the example above, before counting the deal that slipped.

Incident data shows why a design flaw in an internet-facing application is not a theoretical risk. The 2026 edition of the Verizon Data Breach Investigations Report, covering incidents from November 2024 to October 2025, finds that 31% of breaches start with exploitation of software vulnerabilities, ahead of stolen credentials.

Show security as a separate budget line rather than dissolving it into the team rate, for two reasons. First, when budgets get cut, an invisible line disappears first and nobody notices. Second, a separate line lets you hold the vendor accountable for the artifacts you are paying for.

How do you check a vendor before you sign?

Assessing a vendor’s secure development capability should rest on evidence, not claims. A few questions quickly separate teams that do this from teams that talk about it:

  • “Show us an anonymized threat model from a recent project.” Look for decisions and backlog links, not just a diagram.
  • “How do you record an exception to a security requirement, and who approves it?” A good answer includes a register, a rationale, a review date and client sign-off.
  • “Which requirements standard do you use, and how do you choose the level?” “OWASP Top 10” is a warning sign. ASVS with a scope map is a good sign.
  • “How does service-to-service authorization work in your projects?” Listen for workload identity rather than “it is all on the internal network”.
  • “What runs in your pipeline, and what blocks a release?” Scanners without blocking thresholds produce reports nobody reads.
  • “How do you generate SBOMs, and who receives them?”
  • “How quickly will you tell us about a vulnerability in delivered code, and how is that written into the contract?”

A software manufacturer’s signature on the CISA Secure by Design Pledge is a positive signal for products you buy, but not proof. It is a voluntary commitment, and CISA encourages signatories to report progress publicly. If such reports exist, read them. If not, treat the signature as intent.

If the project extends an existing system, check the state of what already exists before demanding security by design for new features. A threat model for a new module will not compensate for a flaw in the architecture it sits on. ARDURA’s independent technical due diligence and code audit includes a security review of code and dependencies, has a fixed scope, takes one to two weeks for the Code Health Audit and starts from EUR 4,500.

Also watch how the vendor responds to the requirements themselves. A team that answers an ASVS map and a threat modeling clause with questions about detail and a revised estimate understands what you are asking for. A team that signs everything without questions and without changing the price probably does not intend to deliver it.

What are the key takeaways for CTOs and CISOs?

Security by design and zero trust are not qualities a vendor either has or lacks. They are decisions and evidence that can be ordered, written into a contract and accepted. A buyer who settles for a best-practices clause and a pre-launch pentest is buying the risk that the most important flaws surface exactly when they are most expensive to fix.

Remember seven things. First, replace declarations in the contract with a list of artifacts with deadlines and acceptance criteria. Second, require three decisions in sprint zero: a threat model, an OWASP ASVS level and scope map, and an identity and access architecture. Third, treat zero trust as application architecture: authorization on every request and every object, service identities, short-lived credentials and logs that let you reconstruct an incident. Fourth, put security into the definition of done, because it is the only clause that works in every sprint. Fifth, distinguish defects from changes in the contract on the basis of the agreed requirements map. Sixth, if you are a manufacturer under the CRA, set vulnerability notification deadlines so you can meet the 24-hour early warning, and make an SBOM part of every release. Seventh, treat the pentest as independent verification, not the only control.

If you need independent verification of what your vendor is building, see the scope of our application and source code security testing: penetration testing and DAST, static analysis, dependency scanning and secrets detection integrated into CI/CD pipelines. If you are taking over an existing system, start with the code audit described above. We are happy to talk through how to set security requirements for your project.