Skip to main content
Security guideReviewed

Dependency security and software composition analysis: what your site runs, and what to update first

Every package your site installs brings code your team did not write, and each of those packages can bring more.

This guide covers the routine side of dependency security: listing direct and transitive dependencies, keeping installs tied to the lockfile, reading an advisory against how your code uses the package, choosing what to update first, and proving the update took. It comes with a triage worksheet, a worked decision for a vulnerable function the code does not call, and a lockfile lab that runs offline.

Dependency update triage worksheet, worked decision and offline lockfile lab

A worksheet with one row per advisory and installed copy, covering paths, lockfile provenance, reachability, fixed versions and exploit evidence, with the source behind each column. A worked decision for an invented advisory follows, including a not_affected record for a vulnerable function that the code loading it does not import, then an offline Node.js lab whose files and outputs were copied in from a real run.

dependency-security.txt

Introduction3 lines

DEPENDENCY UPDATE TRIAGE WORKSHEET, WORKED DECISION AND OFFLINE LOCKFILE LAB ILLUSTRATION AND TEMPLATE. Part A is a blank worksheet to copy into a ticket or spreadsheet. Part B fills it in for an invented project, lab-storefront, and an invented advisory, LAB-2026-0001. Part C is the offline lab that produced the evidence Part B relies on. Every package name in Parts B and C sits under the invented scope @lab-invented, both hosts (registry.lab.test and packages.unexpected.example) are invented, and the advisory describes no real flaw. Nothing here is a real package, registry, vulnerability or client, and nothing in the lab opens a network connection.

What software composition analysis is

Software composition analysis (SCA) is the work of listing the third-party components an application is built from and checking each one against what is known about it.

OWASP treats it as a narrower case of component analysis, which its Component Analysis page defines as the process of identifying potential areas of risk from the use of third-party and open-source software and hardware components. A software-only subset with limited scope, the page says, is commonly referred to as Software Composition Analysis.

It also names the starting point: an accurate inventory of all third-party and open source components, without which the other factors become impractical to determine with high confidence.

OWASP Top 10:2025 covers the same work under A03 Software Supply Chain Failures. Its prevention list includes tracking not just your direct dependencies but their transitive dependencies, continuously monitoring sources like CVE, NVD and OSV for vulnerabilities in the components you use, and using software composition analysis, software supply chain or security-focused SBOM tools to automate the process.

Listing and matching are the half of the job a tool can do. Deciding what a match means for your site is the other half. Yarn's documentation for its audit command puts it plainly: the reports it pulls from the npm registry may or may not be relevant to your actual program, because not all vulnerabilities affect all code paths.

This guide is about that second half: reading each match against how your own code uses the package, and keeping a record of the answer.

Two neighbouring subjects have their own guides. A deliberately malicious release, a look-alike package or an install script that runs on your build machine is a supply chain attack, and the supply chain attacks guide covers how those reach a site and what to do first. The software bill of materials (SBOM), the formal inventory format, has its own planned guide; this page works from the lockfile you already have.

Direct and transitive dependencies

A dependency is any package your application needs in order to build or run.

The ones your team chose are named in package.json, and those are your direct dependencies. Each of them has its own package.json with its own list, and the packages on those lists are transitive dependencies of your application: installed because something you chose asked for them, and so on down.

OWASP's Component Analysis page defines a transitive dependency as the case where an application depends directly on a component and that component depends on another, and notes that each transitive dependency's risk is inherited by every component and application that relies on it. OWASP's A03 lists not carefully tracking the versions of all components, including nested (transitive) dependencies, among the signs that you are likely vulnerable.

A site built on a framework runs the framework, the libraries it installs and the libraries those install, with your own code on top. OWASP's Component Analysis page states the consequence: by using open source components, organisations ultimately take responsibility for code they did not write. You can see the scale for your own project by comparing the dependencies named in package.json with the number of entries in package-lock.json.

Two npm commands show the structure. npm ls prints installed versions as a tree, and given a package name it limits the output to the paths that lead to that package; npm's documentation notes that this is the logical dependency tree, not the physical layout of node_modules. npm explain answers the reverse question by printing the chain of dependencies causing a given package to be installed.

The same package can be installed more than once at different versions, and npm's documentation suggests passing npm explain a folder path to find out exactly why a dependency is being duplicated to satisfy conflicting version requirements.

The lab on this page shows that case. Its invented storefront depends on a text library directly, and also through a form library and a CMS client. npm explain reports one copy at 2.3.0 serving the storefront and the form library, and a second copy at 1.8.4 nested under the CMS client, which asks for ~1.8.0.

An advisory against that library is therefore two questions, one for each copy. The planned Node.js security guide covers the runtime itself, including which release lines are supported.

The npm behaviour this page quotes comes from npm's documentation for CLI version 12.2.2, which the documentation marked as the latest version when it was read. The lab on this page ran on npm 11.12.1, the version installed on the machine that ran it.

What a lockfile fixes in place, and why installs should follow it

package.json can name version ranges rather than exact versions. npm's documentation on semantic versioning lists the update types a package can accept from its dependencies, each with several ways to write it: patch releases (1.0, 1.0.x or ~1.0.4), minor releases (1, 1.x or ^1.0.4) and major releases (* or x).

The lockfile records what those ranges resolved to. npm's documentation says package-lock.json describes the exact tree that was generated, so that subsequent installs can generate identical trees regardless of intermediate dependency updates, and that it is intended to be committed.

For a package fetched from the registry, its entry records the version, a resolved field giving the place the package was actually resolved from (a URL to a tarball) and an integrity field holding a sha512 or sha1 Subresource Integrity string for the artifact unpacked there.

An entry flagged as a link carries no other fields, because the link target has its own entry. The same documentation gives lockfileVersion 3 as the format used by npm v9 and above.

A lockfile protects only the installs that follow it. npm's documentation for npm install says that when it is run without arguments, it uses the exact versions in package-lock.json while they satisfy the ranges in package.json, and resolves new versions and updates the lockfile when they do not. npm's documentation says npm ci is meant to be used in automated environments such as test platforms, continuous integration and deployment, or any situation where you want to make sure you are doing a clean install of your dependencies.

It needs an existing lockfile, exits with an error instead of updating it when the dependencies in the lockfile do not match package.json, and never writes to either file. pnpm has a frozen-lockfile install, which its documentation makes the default in CI when a lockfile is present.

Read the lockfile for where code came from, not only for versions. Two checks are cheap to automate, and both are this page's own advice: every resolved address should point at a registry host on a short allow-list, and every entry fetched from a registry should carry an integrity value.

The regression test in the lab fails on either fault. One detail from npm's documentation matters here: it calls registry.npmjs.org in a lockfile a magic value meaning the currently configured registry.

This page reads that as a caution: the host written in the file is not always where npm fetches from, so your registry configuration is part of the evidence.

Other package managers have their own form of this control. pip's hash-checking mode uses hashes embedded in a requirements file to protect against remote tampering and network issues. Its documentation says that by default, when at least one requirement has hashes, hashes become required for all requirements, and that in this mode hashes are required for all dependencies too.

Since version 26.2, a --no-require-hashes flag disables that mechanism, and hashes are then verified only for requirements where they are provided.

Reading lockfile changes for signs of a deliberate compromise, such as a new install script, belongs to the supply chain attacks guide, and hardening the pipeline that runs the install belongs to the CI/CD security guide.

Dependency confusion is a configuration problem

pip's documentation describes dependency confusion as a class of security issue in which an attacker publishes a package with the same name as your private package to a public index, which may then be chosen instead of yours. npm's threats page describes the same pattern, says npm is not able to detect dependency confusion attacks, and strongly encourages scoped packages.

Whether it can happen to you comes down to configuration: how each package manager is told where each name lives.

In npm, the control is the scope. npm's scope documentation says each npm user or organisation has its own scope and only you can add packages in your scope. A scope can be associated with a separate registry, at login or with npm config, after which any npm install for a package with that scope requests it from that registry instead, and a scope only ever points to one registry.

This page's advice follows from that: publish private packages under a scope you own, map that scope to your private registry, and leave no private package under an unscoped name.

pip works differently. Its install documentation says it looks for packages on the package index, in the local file system and in any additional repositories given with --find-links or --extra-index-url, with no priority between them: all are checked and the best match by version number is selected.

The same page warns that using --extra-index-url to search for packages which are not in the main repository, such as private packages, is unsafe.

Composer 2 takes the opposite default. Its documentation on repository priorities says Composer looks a package up in the topmost repository and moves to the next only if that one does not contain it, and that all repositories are canonical in this way by default in Composer 2.x.

Its own example is a private repository that is not canonical: if someone publishes foo/bar 2.999 to packagist.org, Composer picks it over a private 2.4.3 because the version is higher. Composer 1.x treated all repositories as non-canonical.

ASVS 5.0 sets the expectation as requirement 15.2.4, at Level 3: third-party components and all of their transitive dependencies are included from the expected repository, whether internally owned or an external source, with no risk of a dependency confusion attack. GitHub says the malware advisories in its Advisory Database are mostly about this kind of substitution, and that users whose dependencies are appropriately scoped should not be affected.

The lockfile shows whether the configuration held: a resolved address on an unexpected host is what the lab's lockfile-paths.mjs and regression test report.

One more setting cuts the other way. npm's audit documentation says that for its bulk advisory request, npm sends the name and list of versions of each package in the tree to the default configured registry, and that npm versions 5 and 6 scrubbed packages with a slash in their name to avoid leaking the names of potentially private packages, a behaviour removed as of version 7.

If your private package names are sensitive in themselves, check which registry npm audit talks to. The tokens a build uses to reach a private registry are secrets like any other, and the secrets exposure guide covers finding and rotating exposed ones. What a substituted package does once it runs is a matter for the supply chain attacks guide.

How to read an advisory against your own use of the package

An advisory is a statement about versions, and sometimes about functions.

GitHub's Advisory Database documentation says its advisories are published as JSON files in the Open Source Vulnerability (OSV) format, and that a vulnerability advisory contains the range of released package versions where the problem exists and the earliest version where it was fixed. An advisory may include the description, severity, affected package, package ecosystem, affected versions and patched versions, impact, and optional information such as references, workarounds and credits.

In the OSV schema, affected versions are a timeline of events of four types: introduced, fixed, last_affected and limit. The schema says limit events, which set an upper limit on a range, are typically not necessary for describing numbered (linear) version ranges and should not be used for them.

The schema strongly recommends fixed over last_affected where possible: fixed identifies the version that contains the fix, while last_affected opens up the possibility of false negatives. It leaves two fields for others to define: ecosystem_specific, defined by the package ecosystem, and database_specific, defined by the database the record came from.

Its example is the Go ecosystem, which records in ecosystem_specific the affected functions, the modules the packages were found in, and a severity on the Go project's own scale.

Read each advisory in four passes. Together they fill columns A5 and A7 to A9 of the worksheet, and the order is this page's advice:

  • The affected range and the fixed version, taken from the version fields rather than from the summary text. Check every installed copy against the range, not only the first one npm ls prints.
  • The affected function or feature, where the advisory names one. Where it names none, treat the whole package as in use until you know otherwise.
  • Severity as published: the CVSS version, the vector and the score. FIRST's CVSS specifications say the vector string should be displayed with the score. Copy both, as this page's advice.
  • Exploit evidence: whether the advisory reports exploitation, whether it carries a CVE ID that CISA's KEV catalogue could list, and any EPSS score.

What npm audit reports

npm's audit command submits a description of your project's dependencies to the default registry and asks for a report of known vulnerabilities. npm's page on audit reports lists the fields as severity, description, package, patched in, dependency of, path and more info, and defines severity as determined by the impact and exploitability of the vulnerability in its most common use case.

Your use may not be the most common one, which is why the severity column is never the whole row.

npm also reports what it calls meta-vulnerabilities: a dependency that is vulnerable by virtue of depending on vulnerable versions of another package. By npm's own example, if foo is vulnerable in the range >=1.0.2 <2.0.0 and bar depends on foo@^1.1.0, then that version of bar can only be installed by installing a vulnerable version of foo.

In the lab, the CMS client asks for ~1.8.0 of a library whose whole 1.x line from 1.5.0 is affected, so it fits that definition.

Why severity alone does not set the order of work

Severity describes the flaw in general; priority depends on how you use it.

FIRST's CVSS v3.1 specification says the Base Score reflects a vulnerability's intrinsic characteristics and assumes the reasonable worst-case impact across different deployed environments, and that consumers should supplement it with Temporal and Environmental scores specific to their use of the vulnerable product.

Version 4.0 asks consumers to enrich Base metrics with Threat and Environmental values in the same way, notes that product maintainers and the NVD typically provide only Base scores, labelled CVSS-B, and says that for prioritisation, a score's usefulness is directly proportional to the CVSS metrics used to generate it.

GitHub's Advisory Database supports both versions, and where GitHub obtains a CVE it uses the CVSS version the maintainer assigned.

Exploit evidence answers a different question. CISA adds a vulnerability to its KEV catalogue on three criteria: an assigned CVE ID, reliable evidence that it has been actively exploited in the wild, and a clear remediation action such as a vendor-provided update.

CISA is explicit that exploitability, meaning how easily an attacker could take advantage of a flaw, is not a criterion for inclusion, and that the public availability of a proof of concept does not automatically indicate the vulnerability has been or will be exploited.

Because a CVE ID is the first criterion, an advisory without one cannot be in the catalogue, so the absence of a KEV listing on such an advisory tells you nothing about exploitation.

EPSS, from FIRST, estimates the probability that a published CVE will be exploited in the wild in the next 30 days, and GitHub shows EPSS scores for advisories containing CVEs that have EPSS data. FIRST's guidance on using EPSS says the score is not a severity score and not a complete risk score, and that EPSS does not know what is in your environment.

It warns against treating a low score as a declaration that a vulnerability is safe to ignore, and against multiplying an EPSS score by a CVSS score to produce a combined risk score, which it says has no interpretable meaning.

As a general rule of thumb, it says to treat a vulnerability on the KEV list as actively exploited and prioritise it accordingly, regardless of its EPSS score.

FIRST describes three checks that turn a population-level EPSS score into something specific to your organisation: presence, reachability and consequence. In FIRST's words, a vulnerability present in your environment is only exploitable if the conditions for exploitation exist and are achievable by an attacker, and network exposure, authentication requirements and compensating controls already in place all determine whether a high score translates into real exposure.

This page uses a narrower reading of its own for dependencies: presence is the lockfile entry for each copy, reachability is whether code that loads that copy calls the affected function, and consequence is what that code handles.

A function that is called may still be out of an attacker's reach, so the narrower check answers only part of FIRST's question.

The worksheet has a column for the first two; the third is your judgement about your own site. The vulnerability assessment guide covers CVSS, KEV and EPSS for findings in general.

Deciding what to update first

Start with deadlines.

ASVS 5.0 requirement 15.1.1, at Level 1, asks for application documentation that defines risk-based remediation time frames for third-party component versions with vulnerabilities and for updating libraries in general, and requirement 15.2.1, also Level 1, asks that the application only contains components which have not breached those time frames. With the time frames written down, the order below, which is this page's advice, decides what comes first within them:

  • Any affected copy whose vulnerability is on the KEV list, or whose advisory reports exploitation, where the affected function is reached or reach is unknown.
  • Any affected copy whose function is reached, or whose reach is unknown, in code that handles input from outside: requests, uploads, webhooks or content from a CMS.
  • Any affected copy whose fixed version already sits inside every range on its path. These updates are cheap, so batch them into the same change rather than ranking them.
  • Everything else, inside the documented time frames, with a written decision for anything that will wait.

Two cautions from OWASP

OWASP's A03 lists not fixing or upgrading the underlying platform, frameworks and dependencies in a risk-based, timely fashion among the signs you are likely vulnerable, and says this commonly happens where patching is a monthly or quarterly task under change control.

The same list includes developers not testing the compatibility of updated, upgraded or patched libraries. An update that breaks checkout is not a fix, so the order assumes your tests run on every dependency change.

Letting a tool open the pull requests

GitHub's documentation says Dependabot security updates check whether a vulnerable dependency can be upgraded to a fixed version without disrupting the dependency graph, then raise a pull request to update it to the minimum version that includes the patch. Dependabot shows an alert for every vulnerable dependency in the full dependency graph, but triggers security updates only for dependencies specified in a manifest or lock file, and GitHub's Advisory Database documentation adds that Dependabot does not create alerts for unreviewed advisories.

Renovate's documentation says it can read GitHub's vulnerability alerts and raise fix pull requests, and that its vulnerabilityFixStrategy defaults to the lowest version with a fix. Whichever tool opens the pull request, the reachability column and the decision stay with your team.

Updating a vulnerable package several levels down

When the affected copy is a transitive dependency, the fix has to fit every range between your package.json and that copy.

Work through the options in order of how much they change, starting with the smallest.

Inside the existing ranges

If every parent's range already allows the fixed version, npm update can move it. npm's documentation says npm update respects the semver constraints of both your package and its dependencies, and by default does not update the ranges of direct dependencies in package.json. 1 min read

By updating the parent

If a parent's range blocks the fix, look for a release of that parent whose range allows it. 1 min read

With an override

When no parent release fits yet, the overrides field in your root package.json can replace a version anywhere in the tree. npm's documentation names replacing the version of a dependency with a known security issue as one of its uses, and lets you scope an override to a single parent, such as the text library only where the CMS client asks for it. 1 min read

Other package managers

Each package manager's own documentation describes its tools for this job, and they do not behave the same way. 1 min read

Recording a decision not to update yet

Sometimes the right call is to wait: the fix needs a parent's next major release, the affected function is not reached, or the change needs testing you cannot finish yet.

A decision to wait is still a decision, and it needs the same evidence as an update.

The Vulnerability Exploitability eXchange (VEX) vocabulary gives such decisions a shared form. CISA's Minimum Requirements for VEX, published in April 2023, says a VEX statement conveys a single status for a single vulnerability and one or more products, and limits that status to four values: not_affected, affected, fixed and under_investigation.

A not_affected statement should provide a justification, and must provide an impact statement explaining how or why if it does not. The justifications are Component_not_present, Vulnerable_code_not_present, Vulnerable_code_not_in_execute_path, Vulnerable_code_cannot_be_controlled_by_adversary and Inline_mitigations_already_exist.

The document says it does not represent official CISA policy and does not impose or mandate compliance. The SBOM guide, when it is published, covers VEX documents themselves; this page borrows only the vocabulary.

The justification that fits an unreached function is Vulnerable_code_not_in_execute_path, which the document describes as vulnerable code that cannot be executed due to the way the product uses it, typically because the product includes the vulnerable code but does not call or otherwise use it.

That is a claim about behaviour, so the record has to show how the team knows. The worked decision in the worksheet treats it this way, as this page's advice:

  • The evidence is named: which files were searched, by what method, against which versions, on which date.
  • The limits are written down: a text search misses calls made through computed names, generated or bundled code, and packages it was not pointed at.
  • One named person makes the decision and another approves it.
  • Triggers reopen it: a new version of the parent, a revised advisory, a new CVE alias or KEV listing, a new feature that uses the affected code, or the review date.
  • The update is still planned, as this page's advice. In the VEX document, not_affected means no remediation or mitigation is required for the listed product; taking the fix on the normal release plan anyway gives the decision an end.

While the evidence is still coming in

under_investigation is the honest status while the evidence is gathered; the document expects it to change once the investigation has reached a conclusion. Once a decision is made, package managers let you silence the advisory: pnpm's audit.ignore setting for vulnerabilities that do not affect your project, Yarn's npmAuditIgnoreAdvisories option, and Composer's config.policy.advisories.ignore-id list, which takes advisory IDs and can record a reason for each.

Composer's configuration chapter marks the older audit.ignore key as deprecated in favour of that list, and says audit.ignore is ignored entirely once config.policy.advisories is set. Tie each ignore entry to its written record, so the silence ends when the decision does.

Proving the update took

A merged pull request is a claim that the vulnerable copy is gone.

Four pieces of evidence check it, and each is cheap to collect. Asking for all four is this page's advice:

  • The lockfile diff. npm lists greater visibility of tree changes through readable source control diffs among the lockfile's purposes. The diff should show the affected copy's version, resolved address and integrity value changing, and nothing you did not expect.
  • A clean install that followed the lockfile. npm ci removes any existing node_modules folder before it installs, and exits with an error if the dependencies in the lockfile do not match those in package.json. This page reads a passing npm ci on the build runner as evidence that the committed lockfile is the one being built.
  • The installed version. npm ls or npm explain on the built tree shows which copies are present. Check every copy the worksheet listed: in the lab, the update moved the top-level copy to 2.3.2 and left the copy under the CMS client at 1.8.4.
  • A repeat of the scan that raised the advisory. By default, npm audit exits with a non-zero code if any vulnerability is found, and its documentation says --audit-level does not filter the report output but only changes the failure threshold. Read the report, not just the exit code.

Keep the evidence with the row

Store the four with the worksheet row they close. If the same advisory appears in a later scan, the record shows whether the fix regressed, a second copy was missed, or the advisory itself changed its range.

What ASVS 5.0 and the OWASP Top 10 ask for

Two OWASP documents set out what to expect of the process, each in its own words.

OWASP says that, as a vendor-neutral nonprofit, it does not certify any vendors, verifiers or software. A report against these requirements is evidence for your own decision or a customer's, not a certificate.

  • ASVS 5.0 requirement 15.1.1 (Level 1): application documentation defines risk-based remediation time frames for third-party component versions with vulnerabilities and for updating libraries in general.
  • Requirement 15.1.2 (Level 2): an inventory catalogue, such as a software bill of materials, is maintained of all third-party libraries in use, including verifying that components come from pre-defined, trusted and continually maintained repositories.
  • Requirement 15.1.4 (Level 3): application documentation highlights third-party libraries considered to be risky components. The chapter gives libraries that are poorly maintained, unsupported, at the end-of-life stage or with a history of significant vulnerabilities as examples.
  • Requirement 15.2.1 (Level 1): the application only contains components which have not breached the documented update and remediation time frames.
  • Requirement 15.2.4 (Level 3): third-party components and all of their transitive dependencies are included from the expected repository, with no risk of a dependency confusion attack.
  • OWASP Top 10:2025 A03: its prevention list includes tracking transitive dependencies, removing unused dependencies, continuously monitoring sources like CVE, NVD and OSV for vulnerabilities in the components you use, and only obtaining components from official (trusted) sources over secure links. It also says to deliberately choose which version of a dependency you use and upgrade only when there is need.

Where a security review or test fits

Clever Ops does not monitor dependencies and does not sell a scanning subscription; scans are a step inside a check or test.

The worksheet and lab on this page are for your own team to keep between reviews.

Dependencies come into Clever Ops work as part of reviewing an application. A secure code review reads the lockfile against package.json, checks new packages and versions against published advisories, and reads what runs on its own at install, build or deploy time. A vulnerability assessment confirms a component by its exact version and by whether the affected feature is switched on.

Each report covers the build that was reviewed, on the dates it was reviewed, so a release published afterwards is outside what it can speak to.

Your developers, your agency or a Clever Ops security fix sprint under a separate statement of work can make the updates. If Clever Ops built or hosts the site, the work is a security review rather than an independent test, and the report says who built it and who hosts it.

Frequently asked questions

Software composition analysis lists the third-party components an application is built from and checks each one against what is known about it, such as published advisories. OWASP describes it as the software-only, limited-scope subset of component analysis, which it defines as identifying potential areas of risk from the use of third-party and open-source components. Deciding whether a match matters for your own code is the part the worksheet on this page is for.

A vulnerability in a package your application did not choose directly but installs because one of its dependencies asked for it. npm explain shows the chain from your package.json to that package, with the range each parent asks for. Whether npm update can fix it depends on whether every range on that chain allows the fixed version.

Where the fix fits the existing ranges, npm's documentation says npm audit fix updates the vulnerable packages. Where a chain of meta-vulnerabilities reaches your package.json and cannot be fixed without changing ranges, it needs --force, which can install SemVer-major changes, and npm strongly recommends against --force unless you have a clear idea of what you want to do. Updating the parent or setting an override are the other routes.

Make each private package name resolvable only from your own registry. In npm, publish private packages under a scope you own and associate that scope with your registry; npm says a scope only ever points to one registry. In pip, do not use --extra-index-url for private packages, which pip's documentation calls unsafe. In Composer 2, repositories are canonical by default. Then check the lockfile: every resolved host should be one you expect.

Plan to, but the urgency changes. If the fix fits your existing ranges, update anyway, because it is cheaper than the record. If it needs a parent's major upgrade, a not_affected decision with the justification Vulnerable_code_not_in_execute_path, the evidence behind it and the triggers that reopen it lets the update follow your normal release plan. A text search is evidence, not proof, so the record says what was searched and what it could not see.

It is part of one. It records the exact versions, where each package was resolved from and an integrity value for what was unpacked. It only protects installs that follow it, such as npm ci, which exits with an error rather than rewriting the lockfile when package.json disagrees. A regression test that checks resolved hosts and integrity values turns the file into something a build can fail on.

No. Clever Ops does not monitor dependencies or sell a scanning subscription. A secure code review reads the lockfile against package.json and checks packages and versions against published advisories for the build reviewed. The worksheet on this page is for your team to keep between reviews.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.