skip to content

Under the federal secure-development attestation regime, who attests for a subcontractor's component in a prime's deliverable?

level: seniorimportance: should knowfreq 42%

answer

  1. Follow the name on the contract
  2. The seller owns the whole product
  3. Flow-down moves risk, not visibility
  4. Prefer what you can check on receipt
  5. Provenance binds artifact to source and builder

basics

~20 s

The prime does. Whoever sells the software to the agency attests for the whole product, subcontracted components included. A flow-down clause obtains a matching promise from the subcontractor, but that shifts risk rather than verifying their build.

solid answer

~50 s

The producer selling to the agency signs for the entire delivered product, so a prime integrator attests for a subcontractor's component just as it does for an imported open-source library. Flowing the requirement down gets a matching commitment and someone to sue, but it is paper: the prime's officer is still the name on the government-facing assertion, and the prime never observed the sub's pipeline. So the useful question is what the prime can verify rather than what it can collect. Ask for signed build provenance tying the delivered artifact to a source revision and a builder, an SBOM of the component so your own bill of materials is complete, handoff pinned by digest rather than a floating tag, and a contractual clock for the sub to notify you of vulnerabilities. Then verify all of it in your own pipeline, on receipt, before the component enters your build.

go deeper

for a junior

Know the basic rule: whoever sells the software to the agency attests for all of it, including parts built by someone else. A subcontractor does not sign anything to the agency.

for a middle

Explain why flow-down clauses transfer liability without giving visibility, and name the artifacts that are actually verifiable — signed provenance, a component SBOM, digest-pinned intake.

for a senior

Show the intake gate: what your pipeline checks on receipt, what fails the build, and how you grade requirements by component blast radius when a small supplier cannot meet them.

for a principal

Own the supplier strategy — when to demand evidence, when to build from source yourself and remove the supplier's pipeline from the trust path, and when losing a supplier is the cheaper outcome.

## The rule first The federal secure-development attestation is made by **the producer of the software the agency acquires**. If a prime integrator delivers a system to an agency, the prime attests — for the whole thing. A subcontracted component sits inside that scope exactly like an imported open-source library does. The subcontractor does not attest to the agency; it usually has no privity with the agency at all. That single fact answers the question, but it is not what the interviewer is looking for. What they want to know is whether you understand the difference between transferring risk and reducing it. ## Flow-down is contract, not control The standard response to being on the hook for someone else's build is a flow-down clause: the prime's contract with the sub requires the sub to make the same commitments, provide the same artifacts, and indemnify the prime if it lied. That is worth doing. It is also, on its own, almost worthless as security. - The prime's officer signature is still the one made to the government. A sub's promise to the prime does not move that. - The sub's assurance covers the sub's pipeline, which the prime has never seen and will never see. - Recovery from a sub after the fact is money, and the failure being reduced here is not a money failure — it is a tampered artifact running inside a government system. - The sub has its own subs. Flow-down clauses stack indefinitely and nobody verifies the far end. This is the attacker position that makes the question worth asking. A compromised or coerced supplier one link out is inside your deliverable but outside your visibility, and the compromise reaches the agency wearing your name. ## What the prime can actually verify A senior answer pivots from collecting assurances to verifying artifacts. Concretely, what a prime should require of a subcontracted component: **Provenance.** A signed statement, produced by the sub's build system rather than by a person, binding the delivered artifact's digest to the source revision it was built from and the builder that produced it. This is verifiable evidence about origin, and it is checkable by machine at the moment you ingest the component. **An SBOM for the component.** Not because the SBOM proves anything about integrity — it does not — but because your own bill of materials for the delivered product is incomplete without it, and "we don't know what is inside the module our sub gave us" is not an answer you want to give an agency after a widely exploited library is disclosed. **Digest-pinned handoff.** The component enters your build by immutable content identifier, not by a tag or a branch the sub can move after you approved it. Otherwise what you verified and what you shipped are different things. **A disclosure channel with a clock.** A named contact and a contractual obligation to notify you within a defined window when a vulnerability affects the delivered component, because your obligation to the agency does not pause while your sub decides whether to tell you. **Verification you actually perform.** All of the above is theatre unless the prime's pipeline checks it on receipt — signature valid, digest matches, provenance names the expected source repository and builder — and fails the build when it does not. Requiring artifacts you never check is the most common version of this failure. ## The judgment layer Two tensions are worth naming out loud. First, **leverage is uneven.** A small subcontractor may be unable to produce build provenance at all, and a prime that demands it as an absolute may simply lose that supplier. The workable posture is graded: require the strongest evidence from the components with the largest blast radius, accept weaker evidence plus compensating checks — your own rebuild, your own scan, tighter runtime confinement — for the rest, and put a date on closing the gap. Second, **you can sometimes remove the trust relationship instead of assuring it.** If the sub delivers source and the prime builds it, the prime's own pipeline becomes the attested build and the sub's pipeline stops being in the trust path at all. That is not always possible commercially, but it is the answer that actually shrinks the problem rather than documenting it, and interviewers notice when a candidate reaches for it. ## What to say in the room Open with the rule — the seller attests for the whole delivered product, subcontracted parts included. Say plainly that flow-down transfers risk without reducing it. Then list what is verifiable rather than assertable: provenance bound to the artifact, an SBOM to complete your own, digest-pinned intake, a disclosure clock, and a pipeline gate that enforces all of it. Finish with the graded posture, because a blanket demand you cannot enforce across every supplier is the same failure in a different costume.

  • The subcontractor cannot produce build provenance at all. What do you do?
    Grade the requirement by blast radius. For a component with wide reach, either build it yourself from delivered source — which removes their pipeline from the trust path — or replace the supplier. For lower-consequence components, accept the gap with compensating controls: your own scan on intake, digest pinning, tighter runtime confinement, and a dated plan to close it at renewal.
  • Your subcontractor's own supplier is compromised. Does that change who attested?
    No. The prime still attested for the delivered product, and depth in the chain does not shift that. It does expose why stacked flow-down clauses give false comfort — each link assures only its own boundary. The only thing that improves with depth is verifiable evidence travelling with the artifact, which a chain of promises does not provide.
  • Does an SBOM from the subcontractor tell you their build was not tampered with?
    No. An SBOM says what is inside the component; it says nothing about how it was produced or whether the artifact you received is the one they built. Integrity of origin comes from signed provenance binding the artifact digest to a source revision and builder. The two artifacts answer different questions and neither substitutes for the other.

A restaurant is responsible for the meal it serves, not the farm. It can demand supplier certificates, but the only things it truly controls are checking each delivery on arrival and refusing what fails.

saying these in an interview costs you the question

  • Says the subcontractor attests directly to the agency
  • Treats a flow-down clause as verification of the sub's build
  • Assumes the prime's SBOM may omit subcontracted components
  • Believes indemnification removes the prime's obligation
  • Requires provenance artifacts the pipeline never actually checks

context