Release vs deployment: what is the difference?
7 min read
Deployment puts a new version of your code on production infrastructure. A release makes a change available to the people who use the product. On many teams both happen in the same minute, so the words get used as synonyms, but they are separate events with separate owners, and keeping them apart is what makes feature flags, canary rollouts and calm Friday deploys possible. A quick test for release vs deployment on your team: if you can deploy code that nobody can see yet, you have already separated the two.
| Deployment | Release | |
|---|---|---|
| What changes | The code running in an environment | What users can see and use |
| Who usually decides | Engineering, often the pipeline itself | Product, with support and marketing |
| Typical trigger | A merge to the main branch | A flag change, a rollout percentage, a launch date |
| How you undo it | Roll the build back or forward | Turn the flag off or shrink the rollout |
| Measured by DORA | Deployment frequency, change lead time | No DORA metric covers it |
| What users hear | Nothing, ideally | The changelog entry and the release notes |
What is the difference between deployment and release?
Deployment is a technical step: a build moves into an environment and starts serving requests. Release is a product decision: a change becomes available to users, to all of them or to a chosen group. When every deploy exposes its changes immediately, the two look like one event; once anything stands between the running code and the user, they come apart.
SAFe’s article on continuous deployment describes the older model directly: “Traditional development practices treat deployment and release as the same activity,” and in that model “changes deployed to production are immediately available to users.” It recommends separating the deployment process from releasing, so that changes reach production and are verified there before the business needs them.
Why separate deployment from release?
Because each step gets smaller and safer on its own. Small, frequent deploys are easy to check and easy to undo, and a release made by a separate decision no longer ties the launch date to the build.
Martin Fowler’s entry on continuous delivery lists reduced deployment risk first among its benefits: “since you are deploying smaller changes, there’s less to go wrong and it’s easier to fix should a problem appear.” SAFe’s Release on Demand article adds the business side: “releases are decoupled from the work to deploy the functionality,” which lets product marketing aim an announcement at specific audiences.
There are quieter benefits too. Unfinished work can merge to the main branch every day instead of living on a long branch. Support and documentation can prepare while the code is already live but hidden. And a launch that slips by a week costs nothing in engineering, because the code shipped long ago.
How do teams deploy without releasing?
With a switch between the running code and the user. Four techniques do most of the work, and many teams combine them.
- Feature flags. The new code path ships turned off and someone turns it on later. Pete Hodgson’s Feature Toggles article says release toggles let “incomplete and un-tested codepaths” ship to production as latent code, and calls them the most common way to implement the principle of “separating [feature] release from [code] deployment.”
- Dark launching. New back-end behavior runs inside existing user flows, but its result is not shown. Fowler’s note on dark launching describes it as a way to assess load and performance “before making a public announcement of the new capability.”
- Canary releases. The new version goes to part of the infrastructure, a small group of users is routed to it, and the group grows as confidence grows. In Danilo Sato’s canary release entry, the rollback strategy is simply to “reroute users back to the old version.”
- Blue-green deployment. Two production environments run side by side and the router decides which one users reach. Fowler’s blue-green deployment entry notes it “gives you a rapid way to rollback” by switching the router back.
How do continuous delivery and continuous deployment fit in?
Continuous delivery means every change could go to production at any time. Continuous deployment means every change actually does, automatically. Neither one says when users see the change, which is the release decision.
Fowler draws the line in the same continuous delivery entry: “Continuous Deployment means that every change goes through the pipeline and automatically gets put into production,” while continuous delivery “just means that you are able to do frequent deployments but may choose not to do it.” A team practicing continuous deployment almost always needs flags or staged rollouts, because deploying many times a day only works when a deploy does not force a release.
Which one should the changelog follow?
The release. People read a changelog to learn what they can now do, so an entry published at deploy time for a feature whose flag is still off announces something they cannot find yet.
The habit that works is to write the entry when the change merges and publish it when the change is released. The pull request holds the context while it is fresh, and publishing waits for the moment users can act on it. In Changeloop, each user-facing merged pull request becomes a draft entry that waits in the review inbox until a person approves it, unless auto-publish is turned on for that repository, so the entry for a flagged feature can stay a draft until the flag reaches everyone, then go to the changelog page, the feed and the widget at once, as described in the docs. When a feature reaches users in stages, feature flag release notes covers who to tell at each stage.
Some changes are released the moment they deploy, and their entries should go out then: bug fixes, performance work, and anything that changes an API contract. A fix shipped as a hotfix is the clearest case, since users are waiting for it.
Who owns deployment and who owns release?
Engineering owns deployment, and on mature teams the pipeline does most of it without anyone pressing a button. Release belongs to whoever owns the product decision, usually a product manager, with support and marketing told before it happens.
Writing both owners down matters most when they differ. If engineering assumes product will announce a feature and product assumes it went out with last week’s deploy, nobody tells users. The release management process article gives each step an owner and an exit criterion, including the announcement. In larger organizations that plan on a shared cadence, such as an agile release train, the separation is built into the framework itself.
How do you measure deployment and release?
DORA’s metrics measure deployment, and you have to measure release yourself. Deployment numbers can look excellent while finished features sit behind flags for weeks.
DORA’s software delivery metrics define deployment frequency as “the number of deployments over a given period or the time between deployments,” and change lead time as the time for a change “to go from committed to version control to deployed in production.” None of the five metrics tracks when users actually get the change. Two numbers fill the gap: the time from deploy to release for each feature, which shows how long finished work waits, and the time from release to a published note, which shows how long users wait to hear about it.
FAQ
Can you release without deploying? Yes, when the code is already deployed behind a flag. Turning the flag on releases the feature with no new deployment, which is the whole point of shipping it dark.
What happens to a release when you roll back a deployment? Every change that shipped in that build disappears for users. If a released feature goes away in a rollback, it deserves a short note, the same as its original release did, while flagged code that was never released rolls back silently.
Should a deploy with no visible change get a changelog entry? Usually not in the public changelog, because users have nothing to notice or do. An internal changelog for support and other teams is the right place for refactors, dependency updates and infrastructure work.
Do small teams need to separate deployment from release? Not always. A small team that ships each change as it merges can treat every deploy as a release, and it starts paying off once a feature takes longer than one deploy cycle to finish or needs a fixed launch date.
The technical claims in this article have not been independently reviewed. If something here is wrong, tell us and we will correct it.