Release artifact

Also known as: build artifact

On this page 8

A release artifact is the versioned, immutable output of a build that a project publishes for installation or deployment, such as an installer, an archive, a container image or a library package. In software distribution, the artifact is the unit that is signed, checksummed, stored in a repository and delivered to users, so its quality determines whether every downstream copy is trustworthy.

The broader synonym build artifact covers any file a build pipeline emits, including test reports and intermediate objects. A release artifact is the narrower subset that has been promoted for public or production use and carries a stable version number, metadata and provenance records.

How a release artifact is produced

A release artifact is produced by a build pipeline that compiles source code, bundles dependencies and packages the result in a format the target platform can install. The pipeline usually runs on a controlled build server rather than a developer workstation, because an isolated, scripted environment makes the output predictable and auditable.

The typical sequence moves from source to a published file in clearly separated stages. Each stage adds information that later consumers rely on, from the version identifier to the cryptographic signature.

StageWhat happensOutput added
CheckoutThe pipeline fetches a tagged commitExact source revision
BuildCode is compiled and dependencies resolvedBinaries and libraries
PackageFiles are assembled into an installable formatArchive, installer or image
VerifyTests and scans run against the packageTest and scan results
Sign and hashA signature and checksums are generatedSignature and digest files
PublishThe artifact is uploaded to a repositoryImmutable download location
Stages that turn source code into a release artifact

The central rule is build once, promote many times. The same file that passed testing is the file that reaches staging and production; rebuilding it for each environment would create a different binary and invalidate the earlier verification.

Common formats of release artifacts

The format of a release artifact depends on the target platform and the installation mechanism. Operating systems, language ecosystems and container platforms each define their own package conventions, and many projects publish several formats from one release.

FormatTypical targetInstalled by
MSI or EXE installerWindows desktopsWindows Installer or the installer itself
DMG or PKGmacOSFinder or the macOS installer
DEB or RPM packageLinux distributionsapt, dnf or zypper
Container imageServers and clustersDocker, Podman or Kubernetes
JAR, wheel or npm tarballLanguage ecosystemsMaven, pip or npm
ZIP or tar.gz archivePortable and cross-platform useManual extraction or scripts
Typical artifact formats by distribution target

Alongside the main file, a release usually ships companion files: a checksum list such as SHA256SUMS, a detached signature, a software bill of materials (SBOM) in SPDX or CycloneDX format and, increasingly, a provenance attestation describing how the artifact was built. Release notes describe the changes, but they are documentation, not part of the artifact itself.

Properties that make an artifact trustworthy

A trustworthy release artifact is one whose identity, origin and integrity can be verified by anyone who downloads it. Several properties work together to provide that assurance, and the absence of any one weakens the whole chain.

  • Immutability: once published under a version, the file never changes; a fix receives a new version number.
  • Unique versioning: a semantic version or build number maps each artifact to exactly one source revision.
  • Integrity data: a SHA-256 or SHA-512 digest lets users detect corruption or tampering.
  • Authenticity: code signing or a Sigstore signature proves which publisher released the file.
  • Provenance: SLSA-style attestations record the builder, inputs and build steps.
  • Reproducibility: a reproducible build lets independent parties rebuild a bit-identical file.

These properties support software supply chain security. Attacks such as compromised build servers or poisoned dependencies succeed precisely when consumers cannot tell whether an artifact matches its claimed source, so verifiable artifacts are now a baseline expectation in regulated and enterprise environments.

A release artifact is the deliverable itself, while neighboring concepts in distribution describe how that deliverable is stored, routed or checked. The comparison below separates terms that are often used loosely in the same conversation.

ConceptWhat it isRelation to the artifact
Build artifactAny file a build emitsSuperset that includes unreleased outputs
Software repositoryStorage and index for packagesHosts and serves the artifact
Release channelTrack such as stable or betaDecides which users receive it
ChecksumDigest of the file contentsVerifies the artifact was not altered
Delta updateDifference between two versionsDerived from two full artifacts
Source tagNamed commit in version controlInput from which the artifact is built
How a release artifact relates to neighboring distribution terms

The distinction matters in practice because a tag is not a release. Two builds of the same tag on different machines can differ in timestamps, compiler versions or bundled dependencies unless the project has invested in reproducible builds.

Managing release artifacts in practice

Teams manage release artifacts through an artifact repository manager or a registry that enforces retention, access control and immutability. Promotion between stages is handled by moving or relabeling the same artifact, not by rebuilding it.

SituationRecommended practiceReason
Artifact passes staging testsPromote the identical filePreserves tested behavior
Defect found after publicationPublish a new versionKeeps published versions immutable
Storage costs growExpire snapshots, keep releasesReleases may be needed for rollback
Customers need verificationPublish signatures and checksumsEnables independent integrity checks
Audit or compliance requestRetain SBOM and provenanceDocuments contents and origin
Practical decisions when managing release artifacts

Retention policy deserves attention. Previous release artifacts must remain available for software rollback, for reproducing customer issues and for legal obligations such as license compliance, so deleting old versions to save storage is a frequent and costly mistake.

Common mistakes with release artifacts

Most problems with release artifacts come from breaking immutability or losing traceability. The following failures recur across organizations of every size.

  • Overwriting a published version with a patched file, which breaks caches, mirrors and checksum verification.
  • Building on a developer laptop, which introduces untracked local changes and unknown toolchains.
  • Rebuilding for production instead of promoting the tested artifact.
  • Publishing without a signature, leaving users unable to confirm the publisher.
  • Embedding secrets, such as API keys or credentials, inside the packaged files.

A non-technical view

A release artifact is the finished, sealed product that comes off a software assembly line. Programmers write instructions, a machine turns them into something a computer can install, and that sealed result is what people download.

Think of it like a sealed bottle of medicine with a batch number. Every bottle from the same batch is identical, the seal shows nobody has opened it, and the label tells you exactly where it came from. If a problem appears, the maker issues a new batch rather than changing bottles already on shelves.

A concrete example

A mid-sized company develops a desktop accounting application for Windows and macOS. When version 4.2.0 is ready, a tag in version control triggers the build server, which produces an MSI installer and a DMG file, runs about 3,000 automated tests, generates SHA-256 checksums, signs both installers with the company certificate and uploads everything with an SBOM to its artifact repository.

The same two files go first to a beta release channel for internal staff, then to 10 percent of customers through a staged rollout. A minor display bug appears, so the team publishes version 4.2.1 instead of replacing the existing files. Customers who verify the checksum receive exactly the tested build, and support staff can reinstall 4.2.0 at any time to reproduce older issues.