Product security
Product security: what it covers, who does it and how to start
Product security is the work of keeping the things a company sells secure, from the first design review to the last supported release. It is not the same job as securing the company's laptops, and it is wider than securing one web application. This guide explains the difference, what a product security program and a product security engineer do, how to start with no dedicated people, and which numbers show it is working.
Updated
What is product security?
Product security is the discipline of making the products a company builds and sells secure throughout their life: designing them with security requirements, building and releasing them from a trustworthy pipeline, and handling the vulnerabilities found in them after they ship, until support ends. The product can be software, firmware, a device, a cloud service or all of them together.
What sets it apart is who carries the risk. When a vulnerability is found in a product, the people exposed are the customers running it. For software and devices that customers install, the vendor cannot patch the problem itself: it has to find out which versions are affected, ship a fix, and tell customers clearly enough that they install it. That obligation outlasts the release by years, which is why product security covers the whole lifecycle and not only the code.
Product security vs application security vs IT security
The three terms overlap, and in a small SaaS company one person may do all three. They still answer different questions, and mixing them up is how gaps appear: IT security assumes product security has the shipped firmware covered, application security assumes someone else answers customers, and nobody owns the support period.
| Product security | Application security (AppSec) | Corporate or IT security | |
|---|---|---|---|
| Protects | Everything the company sells: software, firmware, devices, services, and their components | The code of an application, usually one the company builds and runs | The company itself: staff, endpoints, networks, cloud accounts, data |
| Who is exposed | Customers running the product | The company and its users | The company |
| Time span | Design to end of support, often years after release | The development cycle, release by release | Continuous operations |
| Typical work | Security requirements, threat modeling, supply chain and build security, SBOMs, vulnerability handling, disclosure and advisories, support periods | Code review, SAST and dependency scanning, penetration tests, security in the development workflow | Identity and access, endpoint protection, monitoring, incident response for the company, compliance such as ISO 27001 |
| After a vulnerability | Find affected product versions, ship a fix, publish an advisory, notify customers and, where regulation applies, authorities | Fix the code and redeploy | Patch, contain and investigate inside the company |
| Incident team | PSIRT | Often the PSIRT or the engineering team | CSIRT or SOC; see PSIRT vs CSIRT |
Application security is best read as a part of product security. If you only run a web service, the two are nearly the same thing, because you deploy every fix yourself. The difference grows as soon as customers run your code: an on-premises edition, a mobile app, an agent, a library, a device. Then the work after the fix (which versions, which customers, what to tell them) becomes most of the job.
One vulnerability, three teams: a worked example
A critical CVE is published for a compression library. A company that makes network gateways uses it in three places: the gateway firmware, its cloud management service, and a build tool on its engineers' laptops.
- IT security finds the vulnerable tool on the laptops through its endpoint inventory and pushes the update. The job ends there.
- Application security confirms the cloud service pulls in the library as a transitive dependency, bumps it, and the service is redeployed the same day. The job ends there too.
- Product security has the long tail. Which firmware versions contain the library, and which of those are still supported? Is the vulnerable function reachable in the gateway's configuration? If not, a VEX statement saying so saves every customer the analysis. If it is, the fix goes into a firmware release, a security advisory tells customers which versions to install, and, if the vulnerability is being actively exploited and the product is sold in the EU, the Cyber Resilience Act requires the manufacturer to report it.
The first question decides how fast the rest goes. A team that can list the shipped versions containing the library in minutes spends its time on the fix. A team that has to ask every engineering lead spends days on archaeology. Are we affected by this CVE? walks through that question step by step.
What a product security program covers
A product security program is the set of practices, owners and records that apply security at each stage of a product's life. Frameworks slice it differently: NIST's Secure Software Development Framework (SSDF) has four groups (prepare the organization, protect the software, produce well-secured software, respond to vulnerabilities); OWASP SAMM has five business functions (governance, design, implementation, verification, operations); and IEC 62443-4-1 has eight practices for industrial products. They cover the same ground. Organized by lifecycle stage:
| Stage | What the program does | What it leaves behind |
|---|---|---|
| Design | Security requirements per product; threat modeling for new features, interfaces and trust boundaries; secure defaults; choosing components with a maintenance record | Threat models, requirements, design decisions |
| Build | Code review and SAST and SCA; dependency rules; a hardened CI/CD pipeline; controls on what the build may download; an SBOM for every build (see software supply chain security) | Review records, scan results, an SBOM per build and release |
| Verify and release | Security testing and penetration tests scaled to risk; release criteria that block known critical vulnerabilities; hardening guidance for customers | Test reports, release decisions, hardening guides |
| Support | Monitoring shipped components for new vulnerabilities; receiving reports through coordinated vulnerability disclosure; triage with CVSS and exploitation signals; fixes; advisories, VEX and CSAF | A vulnerability record per product version, advisories, update releases |
| End of support | A declared support period per product; end-of-life notices; a plan for the last security update | Published support dates, EOL announcements |
The support stage is where the PSIRT sits. Its process follows ISO/IEC 30111 and ISO/IEC 29147, the standards for handling vulnerabilities internally and disclosing them, and is covered step by step in the vulnerability management lifecycle. Product security is the wider program the PSIRT belongs to.
Why companies build one: customers first, regulation second
The everyday driver is customers: security questionnaires, requests for SBOMs and advisories, and contracts that ask how fast critical vulnerabilities are fixed. Regulation turns the same practices into obligations:
- The EU Cyber Resilience Act makes manufacturers handle vulnerabilities in their products, including components, for the support period, which Article 13(8) sets to reflect how long the product is expected to be in use and, as a rule, at least five years. Reporting of actively exploited vulnerabilities applies from 11 September 2026.
- IEC 62443-4-1 asks suppliers of industrial automation products for a secure development lifecycle, including security issue management and security update management.
- NIS2 (Article 21) lists supply chain security and vulnerability handling and disclosure among the measures essential and important entities must take, so their suppliers get asked about both.
A program built only to pass an audit tends to produce documents. One built to answer customers quickly produces the records the audit wants as a side effect.
What does a product security engineer do?
A product security engineer works with the teams that build a product to make it secure, and stays with it after release. Product security engineering is the hands-on side of the program: the reviews, tooling and fixes, as opposed to policy. A typical week mixes:
- design reviews and threat models for new features and interfaces;
- reviewing security-sensitive code, such as authentication, parsing, cryptography and update mechanisms;
- tuning SAST and dependency scanning so findings are worth reading, and fixing the build pipeline's weak points;
- triaging vulnerability reports and scanner findings, scoring them and deciding which product versions they affect;
- pairing with the owning team on the fix and checking it actually closes the issue;
- drafting advisories and VEX statements, and answering customer security questions;
- keeping SBOMs, support dates and the vulnerability record for each product current.
The title overlaps with others. Many companies use "application security engineer" for the same job; a PSIRT engineer is a product security engineer who specializes in the post-release work; and in device makers the role often includes embedded topics such as secure boot and update signing. The PSIRT role page covers the incident side in more depth.
Product security engineer skills
| Skill | Why it matters |
|---|---|
| Reading and writing code in the product's languages | Reviews, proofs of concept and fixes all need it. A product security engineer who cannot open a pull request is a ticket router. |
| Threat modeling and secure design | The cheapest vulnerability is the one designed out. This is where trust boundaries, authentication flows and defaults are decided. |
| Common vulnerability classes | Injection, memory safety, deserialization, access control, cryptographic misuse: recognizing them in review and judging exploitability. |
| Dependencies, builds and CI/CD | Most vulnerabilities arrive in components. Knowing package managers, lockfiles, transitive dependencies and how the pipeline fetches them is now core, not a specialty. |
| Vulnerability scoring and disclosure | CVSS, exploitation data, VEX and advisories; how coordinated disclosure and CVE assignment work. |
| Clear writing | Advisories, threat models and fix requests are read by customers and engineers under time pressure. |
| Influence without authority | The engineer rarely owns the backlog. Getting a fix scheduled means explaining the risk in the product team's terms. |
For device and industrial products, add embedded and hardware knowledge (boot chains, firmware update, debug interfaces) and familiarity with the sector's standards. For SaaS, add cloud and identity.
How to start a product security program in a small company
Small companies cannot do everything in the frameworks at once, and should not try. The order that works is: first be able to answer for what you have shipped, then be reachable, then reduce what you will ship next. The post-release duties arrive whether or not you prepared; design work pays off later. A staged rule by headcount:
No dedicated people: one owner, five basics
Security is a part-time role for an engineering lead or the CTO. Do these and nothing else yet:
- Name an owner and a backup for product security decisions, in writing.
-
Be reachable: a security contact, a
security.txtfile and a one-page disclosure policy. The CVD guide has a template. - Know what you ship: an SBOM for every release, generated by the build, kept with the release. This is what makes "are we affected?" a lookup instead of a project.
- Stop the obvious: dependency alerts on every repository and a build rule that blocks known critical vulnerabilities from shipping.
- Write down the support period of each product, even if the answer is "the latest version only".
Skip for now: a bug bounty, threat modeling every feature, a machine-readable advisory feed.
One dedicated person: a product security engineer
The first hire keeps the basics running and adds:
- threat modeling for the changes that move trust boundaries (new interfaces, authentication, update paths);
- a triage workflow with severity scoring and fix targets per severity, agreed with engineering;
- an advisory template and the first published advisory, plus VEX for the vulnerabilities customers keep asking about;
- a hardened CI/CD pipeline and tuned SAST, so findings are trusted;
- a security contact in each product team who receives findings and schedules fixes.
Hire this person when customers start sending security questionnaires and SBOM requests faster than the part-time owner can answer, or before you enter a regulated market.
Several people: split the work
With three or more, specialize along the lifecycle rather than by product:
- Design and assurance: threat models, reviews, penetration test scoping, embedded security.
- PSIRT: intake, triage, coordination, advisories, CSAF and VEX, possibly becoming a CVE Numbering Authority. See how to scale a PSIRT.
- Platform and supply chain: the build pipeline, SBOMs, dependency policy, release signing.
At this size, measure maturity against a framework: the FIRST PSIRT Maturity Document for the support stage, OWASP SAMM or the SSDF for the rest, and IEC 62443-4-1 certification if industrial customers ask for it.
Product security metrics worth tracking
Good metrics measure outcomes for customers, not activity. A rising count of scanner findings says more about the scanner than about the product.
| Metric | What it tells you | Watch out for |
|---|---|---|
| Time to answer "are we affected?" | How fast you can list the shipped versions containing a newly published vulnerable component | Measure it on real events, not a drill with a known answer |
| Time to acknowledge an external report | Whether researchers and customers can rely on you | An automatic reply is not an acknowledgement |
| Time to a released fix, by severity | Exposure for customers | Count to the release customers can install, not to the merged pull request |
| Open vulnerabilities in supported versions, by age | The backlog that matters | Exclude findings closed with a justified VEX status, and say so |
| Share of releases with a complete SBOM | Whether the inventory behind every other answer can be trusted | An SBOM that misses components looks complete until a CVE lands in one |
| Share of significant changes with a threat model | Whether design work happens before code | Define "significant" once, or the number drifts |
| Found internally vs reported from outside | Whether your own testing finds problems before others do | Read the trend, not a single quarter |
| Advisories published, and corrections | Transparency and accuracy | Corrections are a sign of honesty, but frequent ones point to rushed triage |
Where CRACI fits
CRACI is the evidence layer for the build and vulnerability handling stages. It runs GitHub Actions builds on its own runners and records the packages each job actually fetched, including transitive dependencies and packages restored from caches. Each SBOM carries a completeness state and exports as CycloneDX or SPDX.
- Affected versions: each package shows its advisories (CVE, GHSA and other IDs) with severity, and build history shows which past builds contained a vulnerable dependency, direct or transitive, so you know the period you were affected, within your retention period.
- Triage and routing: security teams triage discovered vulnerabilities and send them to the teams that own the fix. CRACI supports VEX, and notifies the relevant people of a vulnerability and its severity.
- Release rules: policy gates can block a build, including builds that contain a specific CVE.
- Regulatory reporting: CRACI prepares the content of the CRA notifications (early warning, notification and final report); a person at the manufacturer submits them through the Single Reporting Platform.
See SBOM generation and vulnerability tracking.
When CRACI is not the answer
- Design work: threat modeling, security requirements and design reviews need people and their own tools.
- Source code scanning: CRACI does not do SAST or secrets scanning, by design. Use a SAST tool alongside it.
- Report intake and advisories: CRACI does not take in external vulnerability reports, track them as cases, or write or publish security advisories. A PSIRT still needs an intake channel and an advisory process.
- Program metrics: CRACI does not report time-to-fix, remediation deadlines or backlog trends.
- Other CI systems: CRACI supports GitHub Actions. GitLab CI and Jenkins are on the roadmap.
Product security: frequently asked questions
What is product security?
Product security is the discipline of keeping the products a company sells secure across their whole life: security requirements and threat modeling at design, a trustworthy build and supply chain, and handling vulnerabilities found after release until support ends. It protects the customers who run the product, which is what separates it from IT security.
What is the difference between product security and application security?
Application security secures the code of an application, mostly during development. Product security covers everything the company sells, including firmware, devices and the components inside them, and continues after release: finding affected versions, shipping fixes, publishing advisories and supporting the product for a declared period. For a company that only runs a web service the two are nearly the same.
What is the difference between product security and IT security?
IT or corporate security protects the company: its staff, endpoints, networks and data. Product security protects customers from vulnerabilities in what the company ships. Their incident teams differ too: a CSIRT or SOC for the company, a PSIRT for the products. See PSIRT vs CSIRT.
What does a product security engineer do?
A product security engineer works with product teams to make a product secure and keeps it secure after release: design reviews and threat models, reviews of security-sensitive code, tuning scanners and hardening the build pipeline, triaging vulnerabilities, helping fix them, and drafting advisories and VEX statements.
What skills does a product security engineer need?
Coding in the product's languages, threat modeling and secure design, knowledge of common vulnerability classes, an understanding of dependencies, builds and CI/CD, vulnerability scoring and disclosure, clear writing, and the ability to get fixes scheduled without owning the backlog. Device makers add embedded topics such as secure boot and firmware updates.
Is product security the same as a PSIRT?
No. A PSIRT handles vulnerabilities in products after they ship: intake, triage, fixes, disclosure. Product security is the wider program that also covers design and build. In small companies the same people often do both.
When should a startup hire its first product security engineer?
When customer security questionnaires and SBOM requests arrive faster than a part-time owner can answer them, or before entering a regulated market such as industrial, medical or EU products covered by the Cyber Resilience Act. Until then, an engineering lead can own the basics: a security contact, an SBOM per release, dependency alerts, a build rule against known critical vulnerabilities, and a declared support period.
Which metrics should a product security program track?
Outcome metrics: time to answer whether you are affected by a new vulnerability, time to acknowledge external reports, time to a released fix by severity, open vulnerabilities in supported versions by age, share of releases with a complete SBOM, and vulnerabilities found internally versus reported from outside.
Answer "are we affected?" from the build record
Book a demo to see which of your GitHub Actions builds contained a vulnerable package, and route it to the team that owns the fix.
Book a demo