A platform distributes large artefacts to many consumers. What does artefact management need beyond storage?

Beyond storage

1. Immutability and content addressing. An artefact identified by its content hash cannot change under its consumers, and a rebuild producing the same content is recognised as identical. Mutable tags pointing at changing content is the source of "it worked yesterday" incidents, and pinning to digests rather than tags is the fix.

2. Provenance attached to every artefact — which commit, which builder, which dependencies, which pipeline run. This is what makes "is this the artefact we think it is" answerable, and it is the raw material for vulnerability response.

3. A retention policy with automation. Artefact storage grows without bound. Retention needs tiering — recent builds hot, releases retained long, intermediate builds expired — and it must be automatic, because manual cleanup does not happen.

4. Promotion rather than rebuild. The artefact tested in one environment is the artefact promoted to the next. Rebuilding between environments means what is in production was never tested, which is a surprisingly common and entirely avoidable defect.

5. An inventory query. "Which releases contain this dependency version" must take minutes, not days — because that is exactly the question asked when a vulnerability is announced, under time pressure.

6. Efficient transfer for large artefacts — chunk-level transfer so updating one file in a large repository does not re-download everything, resumable downloads, and integrity verification. For a platform whose artefacts are large, this is where most of the perceived quality lives.

The distribution properties

• A CDN in front, since popularity is heavily skewed and the hot artefacts should be served from the edge.
• Deduplication across artefacts, which for a store where many artefacts share content is a large cost saving.
• Access control at the artefact level, evaluated at request time rather than baked into a distribution layer that cannot see permission changes.

The failure to design against

A registry that becomes a single point of failure for deployment. If artefacts cannot be pulled, nothing can deploy or scale — including the recovery from the incident that made you want to deploy. Caching and a fallback path matter more than they appear to.