Outsourced ProgrammersPowered by StealthAgents

Write a build artifact retention rule for offshore release trains

A retention rule that keeps a rebuildable artifact for every released commit, records where it lives, and proves a restore before the pipeline changes.

Write a build artifact retention rule for offshore release trains
WORK_LANE / FIELD GUIDE / RELEASEREVIEW QUEUEACCEPTANCEPASSowner review requiredEVIDENCE TRAILTICKET → BRANCH → REVIEW → CLIENT RELEASE
Table of contents
  1. Quick read
  2. Readiness check
  3. Define what a rebuildable artifact must contain
  4. Tie each artifact to a commit and a pipeline run
  5. Set the retention period and the storage owner
  6. Protect the artifact index from silent edits
  7. Test a rebuild from a retained artifact
  8. Retire artifacts with evidence
  9. Role brief
  10. Frequently asked questions
  11. Sources

Is the handoff ready?

Use these checks before access expands or the first ticket begins.

Definition

Ready: Each artifact type and its required contents are written down.

Needs work: A source tag is treated as the release record.

Traceability

Ready: Commit, pipeline run, and digest are stored with the release.

Needs work: The artifact is a mutable tag with no owner.

Retention

Ready: The period, the storage owner, and the delete rule are agreed.

Needs work: Old files are deleted when storage looks full.

Restore

Ready: One retained artifact is redeployed and checked each quarter.

Needs work: Nobody has tried a rebuild since launch.

Define what a rebuildable artifact must contain

A rebuildable artifact is a packaged output that can be deployed without re-running an uncertain local build. It should contain the compiled code, the locked dependency list, the build configuration, and the commit identifier that produced it. Record the toolchain version and the environment variables that affect the output. An artifact without that context is a file, not a release record.

Decide which artifact types the lane produces, such as a container image, a static bundle, or a signed mobile package. Write the definition for each type in the delivery agreement. Do not assume that a source tag is enough, because a tag can point at a commit that no longer builds. The artifact should be the thing the team deploys.

Tie each artifact to a commit and a pipeline run

Record the commit hash, the pipeline run, the artifact digest, and the deploy time for every release. Store the digest rather than a mutable tag so two builds cannot be confused. Link the record to the ticket that approved the release. The reviewer should be able to answer what is running in production from one page.

Require the pipeline to publish the artifact and the record together, so a missing record blocks the release. Do not allow a manual upload that skips the pipeline unless an incident ticket explains why. Record the exception with an owner and an expiry. The exception should be visible in the next release review.

Set the retention period and the storage owner

Choose a retention period that covers the client audit window and the longest rollback the team would attempt. Keep at least the last several releases and every release that is still deployed. Name the person who owns the storage account and the person who can delete an artifact. Delete permission should be narrower than publish permission.

Record where each artifact lives, its size, and its cost when that matters. Move old artifacts to cheaper storage rather than deleting them on a hunch. Set a review date before the first deletion. A retention rule that nobody reviews becomes either a hoard or a gap.

Protect the artifact index from silent edits

Keep the artifact index in a repository or a system with an audit log, not in a shared spreadsheet. Require a change record for any edit to a digest, a path, or a retention date. Review the log for edits made outside the pipeline. A silent edit to an index can point a release at the wrong build.

Restrict write access to the pipeline identity and to one named human backup. Rotate the pipeline credentials on the same schedule as other machine secrets. Alert on a manual upload or a digest mismatch. The index should show who changed what and when.

Test a rebuild from a retained artifact

Pick one past release each quarter and redeploy it into an isolated environment from the retained artifact. Confirm that it starts, serves the expected version, and passes the smoke checks. Record the time it took and any step that needed tribal knowledge. A rebuild that fails is a finding about the record, not about the old code.

Also test one rebuild from source using the recorded commit and lockfile. Compare the new digest with the retained digest where the build is reproducible. Investigate a difference before assuming it is harmless. Report both results to the client technical owner.

Retire artifacts with evidence

Delete an artifact only when the retention date has passed and the release is no longer deployed anywhere. Check the deployment inventory before deleting, including disaster recovery and demo environments. Record the deletion date, the operator, and the ticket. An artifact that disappears while still in use turns a routine cleanup into an outage.

Keep a small metadata record after the artifact is gone, with the commit, the digest, and the reason for deletion. The metadata is cheaper than the artifact and answers most audit questions. Review the retirement list once a quarter for mistakes. A clean retirement process makes the retention period trustworthy.

Put the operating agreement in writing.

Artifact record

Store the commit, pipeline run, digest, deploy time, and ticket for every release.

Storage owner

Name the account owner and restrict deletion to one role with an audit log.

Retention window

Keep every deployed release plus the last several versions for rollback.

Restore test

Redeploy one past release into an isolated environment and record the result.

Frequently asked questions

Is a Git tag enough for a release record?

No, a tag can point at code that no longer builds, so pair it with a retained artifact and digest.

How long should artifacts be kept?

At least the client audit window and every release still deployed, with a review before first deletion.

What if the retained artifact will not start?

Record it as a finding about the release record and test a rebuild from the recorded commit.

Sources

  1. SLSA specification

    Build provenance and artifact integrity levels.

  2. NIST Secure Software Development Framework

    Release and provenance evidence practice.

  3. GitHub Actions artifact storage

    Artifact retention and pipeline storage behavior.

  4. Google SRE Workbook

    Release engineering and rollback practice.

Build a programming lane your technical owner can review.

Bring the stack, backlog, acceptance checks, and release boundaries. We will help scope the role around the work.

Discuss your programming needs