Table of contents
- Quick read
- Readiness check
- Define what a rebuildable artifact must contain
- Tie each artifact to a commit and a pipeline run
- Set the retention period and the storage owner
- Protect the artifact index from silent edits
- Test a rebuild from a retained artifact
- Retire artifacts with evidence
- Role brief
- Frequently asked questions
- 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.
Copy-ready brief
Put the operating agreement in writing.
Store the commit, pipeline run, digest, deploy time, and ticket for every release.
Name the account owner and restrict deletion to one role with an audit log.
Keep every deployed release plus the last several versions for rollback.
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
- SLSA specification
Build provenance and artifact integrity levels.
- NIST Secure Software Development Framework
Release and provenance evidence practice.
- GitHub Actions artifact storage
Artifact retention and pipeline storage behavior.
- Google SRE Workbook
Release engineering and rollback practice.
