GH-500 domain - 18% of the exam

Configure and use supply chain security

Configure and use supply chain security is 18% of the GH-500 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

50
Practice questions
5
Objectives
30
Medium
20
Hard

Where people go wrong

  • Applying a Dependency Review input to the wrong kind of finding

    The wrong answers reach for a nearby input that governs a different kind of finding. fail-on-severity sets the threshold for vulnerability advisories and has no effect on a licence failure. allow-dependencies-licenses exempts a named package from licence checks only, and allow-ghsas exempts a named advisory only. Licence policy is set with allow-licenses or deny-licenses, and a deny list never fails a dependency whose licence is unknown.

    See it in a sample question
  • Crediting one Dependabot feature with another's job

    The wrong answers hand a job to the neighbouring feature. Dependabot security updates are credited with discovering build-time components, but they only patch dependencies already in the graph; the Dependency submission API feeds that data in. Version updates are offered as a fallback when security updates are off, but they run on their own dependabot.yml schedule. Version updates and alerts are also offered as a pre-merge review of a pull request, which is the Dependency Review action's job, and security updates as a merge gate, which needs a required Dependency Review check.

    See it in a sample question
  • Expecting the dependency graph to find what no manifest declares

    The dependency graph reads supported manifest and lock files, and the wrong answers credit it with more. A library copied into the tree as source with no manifest entry is never detected, and renaming the directory does not change that. A hand-committed CycloneDX file is not a parsed manifest, and the graph reads files statically instead of capturing a build. Without a committed lock file it cannot resolve the pinned transitive tree.

    See it in a sample question
  • Expecting the SBOM export to hold more than a default-branch inventory

    The wrong answers load the exported SBOM with extra content or the wrong scope. The export is an SPDX document listing detected components and their versions, so it carries no per-package CVE list or severity score; those come from Dependabot alerts. CycloneDX is offered as the format, but the dependency graph export produces SPDX. The export describes the default branch, so a release commit on a long-lived branch is not what the REST API returns.

    See it in a sample question
  • Misreading versioning-strategy values

    The wrong answers choose increase, which edits the manifest on every update even when the current range already allows the new version. Lockfile-only never touches the manifest, so it cannot relax a requirement that blocks an update. Widen extends the upper bound but is only available for ecosystems such as Bundler and Composer, not npm. Increase-if-necessary leaves the constraint alone until it would otherwise block the update, then raises it.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleConfigure and use supply chain securitymedium

A maintainer runs the Dependency Review action with a deny list that forbids a particular vulnerable transitive package by advisory. A new pull request bumps a direct dependency, which pulls in a version of that transitive package carrying a GHSA advisory the team has reviewed and formally accepted as a one-off exception for this release. They want the gate to keep failing on all other high-severity advisories but to let this one specific advisory pass without lowering the overall severity threshold. Which configuration achieves this most precisely?

  • AAdd the advisory's identifier to the action's allow-ghsas input so that this single GHSA is exempted while every other advisory at or above the configured severity still fails the check. Correct
  • BLower fail-on-severity from high to critical so the accepted advisory, being high severity, no longer crosses the failure threshold.
  • CAdd the transitive package to the allow-dependencies-licenses input so the action skips this package entirely and stops evaluating its advisories during the pull request review.
  • DDismiss the matching Dependabot alert for that package with the reason that the risk is tolerable, which also tells the Dependency Review action to ignore the advisory.
Use the allow-ghsas input to exempt a specific advisory from the Dependency Review gate without changing the severity threshold. The dependency-review-action provides allow-ghsas as a list of GitHub Security Advisory identifiers to ignore during evaluation. Listing one GHSA exempts only that advisory; the fail-on-severity threshold continues to apply to all others, so the broad gate stays intact while a single reviewed exception passes.

Why A is correct: Correct: the allow-ghsas input takes a list of specific GitHub advisory identifiers to ignore, so the named advisory passes while the fail-on-severity gate continues to fail on all other qualifying advisories.

Why B is wrong: Tempting because it would let the high-severity finding pass, but it weakens the gate for every other high-severity advisory too, which contradicts the requirement to exempt only this one finding.

Why C is wrong: Tempting because it names the package, but allow-dependencies-licenses exempts a dependency from licence checks only and has no effect on vulnerability advisory gating.

Why D is wrong: Tempting because dismissing a Dependabot alert records an accepted risk, but Dependabot alert state is independent of the Dependency Review action's pull request gate, so the dismissal does not stop the action from failing the check.

Free sampleConfigure and use supply chain securitymedium

A repository builds a Go binary where several dependencies are pulled in by the build process rather than being fully captured in a committed manifest. The platform team wants those build-time dependencies to appear in the dependency graph, and therefore in the exported SBOM and in Dependabot alert coverage. Which GitHub mechanism is designed to feed these build-time dependencies into the dependency graph?

  • AThe Dependency submission API, which lets a build or workflow submit the dependencies it resolved so they are added to the repository's dependency graph. Correct
  • BEnabling Dependency Review on pull requests, which scans the build output and writes any newly discovered build-time dependencies back into the dependency graph.
  • CTurning on Dependabot security updates, which inspects the compiled binary and registers its embedded modules in the dependency graph automatically.
  • DCommitting a CycloneDX file to the repository root, which GitHub parses on push as a supported manifest and merges into the dependency graph.
Use the Dependency submission API to add build-time resolved dependencies to the dependency graph so they reach the SBOM and Dependabot alerts. Manifest parsing alone misses dependencies that only a build resolves. The Dependency submission API lets a workflow submit a snapshot of those resolved dependencies, which GitHub merges into the dependency graph. From there the components appear in the exported SBOM and are covered by Dependabot alerts, whereas Dependency Review, Dependabot security updates, and a checked-in CycloneDX file do not populate the graph with build-time data.

Why A is correct: The Dependency submission API accepts a snapshot of dependencies that a build resolves at build time and adds them to the dependency graph. Once in the graph, those components flow through to the exported SBOM and are covered by Dependabot alerts, which is exactly the requirement.

Why B is wrong: Dependency Review compares the dependency changes on a pull request and surfaces risky additions, but it does not capture build-time dependencies or write new components into the graph. It reads from the graph rather than populating it.

Why C is wrong: Dependabot security updates raise pull requests to patch vulnerable dependencies already known to the graph; they do not inspect compiled binaries to discover and register new components. This misattributes a discovery role to a remediation feature.

Why D is wrong: The dependency graph parses specific supported package manifest and lock files, and a hand-committed CycloneDX file is not one of those parsed manifests, so it would not be merged in. The supported route for build-time data is the submission API, not a checked-in BOM file.

Free sampleConfigure and use supply chain securitymedium

A release engineer wants the SBOM attached to a tagged release to reflect exactly the dependencies present on that release commit, which sits on a long-lived release branch rather than on the default branch. They call the dependency graph SBOM REST API for the repository as part of the tag workflow and store the response. They are surprised that the SBOM appears to describe the default branch's dependencies rather than the release branch's. What is the most accurate explanation of this behaviour?

  • AThe SBOM export reflects the dependency graph for the repository's default branch, so a release commit on a separate long-lived branch is not what the export actually describes. Correct
  • BThe API returns a union of all branches' dependencies, so the release branch is included but its entries are merged indistinguishably with the default branch, which makes them look like default-branch data.
  • CThe SBOM export accepts a commit SHA parameter that defaults to the latest commit on any branch, so the engineer simply needs to pass the release branch SHA to retarget it.
  • DThe export described the default branch only because the release branch had no committed lock file; once a lock file is committed to the release branch the same API call returns that branch's SBOM.
Understand that the dependency graph SBOM export reflects the repository's default branch, not an arbitrary release branch or tagged commit. GitHub maintains the repository's dependency graph from its default branch, and the SBOM export, whether through the browser action or the REST API, reflects that default-branch graph. It is not parameterised to describe an arbitrary branch or tagged commit, so a release commit living on a separate long-lived branch is not what the exported SBOM represents. An engineer needing a branch-specific inventory cannot obtain it simply by passing a different ref to this export.

Why A is correct: Correct because the dependency graph that GitHub maintains and exports as an SBOM is built from the repository's default branch, so the API returns the default-branch component inventory rather than the state of an arbitrary release branch or tag.

Why B is wrong: Tempting because a merged view sounds like it would hide the release branch, but the export is scoped to the default branch rather than a union across branches, so the release branch's distinct dependencies are simply not part of the exported inventory.

Why C is wrong: Tempting because many APIs take a ref parameter, but the dependency graph SBOM export reflects the default branch and is not retargeted to an arbitrary commit by a SHA parameter, so this misstates how the endpoint scopes its result.

Why D is wrong: Tempting because lock files do affect resolution depth, but the branch the SBOM describes is the default branch regardless of lock files on other branches, so adding a lock file to the release branch would not change which branch the export reflects.

Free sampleConfigure and use supply chain securityhard

A team uses Dependabot version updates for a npm project and pins exact versions in package.json. They want every version-update pull request to widen the allowed range where possible rather than only bumping to the latest pinned version, but only when the current requirement would otherwise block the update. Which versioning-strategy value in dependabot.yml produces this behaviour?

  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "daily"
    versioning-strategy: "???"
  • Aincrease-if-necessary, which keeps the existing constraint when it already allows the new version and only raises the lower bound when the current requirement would block the update. Correct
  • Blockfile-only, which restricts Dependabot to updating the lockfile and never touches the version constraints declared in the manifest at all.
  • Cincrease, which always raises the minimum version requirement on every update regardless of whether the existing constraint already permits the new version.
  • Dwiden, which expands the allowed range to include the new version while preserving the existing lower bound, and is supported for npm exact pins.
Choose increase-if-necessary so Dependabot only edits a manifest constraint when the existing requirement would otherwise block the update. The versioning-strategy key controls how Dependabot edits manifest requirements. increase-if-necessary leaves the constraint alone when it already admits the new version and raises the lower bound only when the current requirement blocks the update, which minimises churn while unblocking pinned dependencies. widen is valid only for certain ecosystems and increase always rewrites the requirement.

Why A is correct: The increase-if-necessary strategy leaves a version requirement untouched when it already permits the new version and widens or raises it only when the existing constraint would otherwise prevent the update. That precisely matches a team that wants minimal manifest churn but still wants ranges adjusted when a pin blocks an upgrade.

Why B is wrong: The lockfile-only strategy deliberately leaves the manifest version requirements alone and only refreshes the lockfile, so it is the opposite of widening a declared range. It is tempting because it sounds conservative, but it cannot relax a pinned requirement that is blocking an update.

Why C is wrong: The increase strategy edits the manifest on every update even when the current range already allows the new version, producing more manifest changes than asked for. The requirement was to adjust the constraint only when it would block the update, so increase does too much.

Why D is wrong: The widen strategy keeps the old lower bound and extends the upper bound to admit the new version, but it is only available for ecosystems such as Bundler and Composer, not npm. The rationale of widening sounds correct for the goal, yet the strategy is unavailable here and would be rejected.

Other domains in this exam

See also the GH-500 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by GitHub. Original, blueprint-aligned practice material only.