A deployment strategy is a bet about how you will find out something is wrong and how fast you can undo it. Everything else about it is detail.
That framing is more useful than the usual diagrams because it exposes the question people skip. Blue-green, canary and progressive delivery all reduce the blast radius of a bad release, but they reduce it in different ways, they detect problems at different points, and most importantly they undo differently. One of them can be reversed in the time it takes a load balancer to update a rule. Another cannot be reversed at all once a schema migration has run. Picking between them without knowing which is which is how teams end up with an elaborate canary process that still takes forty minutes to roll back.
The second thing the diagrams leave out is the hard part. The strategy is easy. Deciding automatically whether the new version is worse than the old one is hard, and that decision is what turns a deployment mechanism into progressive delivery. Every product in this category has a traffic-shifting implementation, and most of them are similar. What separates them is the analysis layer: what signals it reads, how it handles low traffic, and how often it is wrong.
And then there is the case nobody designs for until it hurts, which is a release that spans several services. A frontend that needs a backend that needs a schema change. Canary works beautifully on one service and has nothing to say about three.
Key takeaways
- Blue-green swaps all traffic at once between two full environments. Rollback is a routing change, so it is the fastest undo available, and the cost is running two environments and having no partial exposure.
- Canary shifts a fraction of traffic to the new version. It limits blast radius but rollback still means draining, and low-traffic services may never accumulate enough requests for the comparison to mean anything.
- Progressive delivery is canary plus an automated verdict. The traffic shifting is commodity; the analysis that decides to promote or abort is the entire product.
- No traffic strategy rolls back a database migration. Schema changes must be backward compatible for the whole window in which both versions can serve traffic, which is a design constraint rather than a tooling choice.
The three mechanisms, and how each one undoes itself
Blue-green
Two complete environments. Blue is serving production. You deploy the new version to green, verify it however you verify things, then point the router at green. Blue stays warm and idle.
Rollback is a routing change. Point the router back at blue. It is the fastest rollback in this article, measured in seconds, and it works no matter what is wrong with green because blue was never touched. That single property is why blue-green survives in environments where reliability matters more than efficiency.
Detection happens before the switch or after it, never during. There is no partial exposure. You either verify green with synthetic traffic and internal testing, which catches what your tests catch, or you switch and find out with all of production at once. A problem that only appears under real traffic appears for everyone simultaneously.
Cost is duplicated capacity. Two full environments, and if you provision green at full size you are paying double during the overlap. For a large deployment that is a real number.
Statefulness is where it breaks. In-flight sessions on blue, connection pools, caches that are warm on blue and cold on green, background jobs that might be running in both. And the database, which is shared, which means blue-green gives you exactly nothing for schema changes.
Canary
One deployment, two versions running at once, with a small percentage of traffic routed to the new one. Increase the percentage over time if nothing looks wrong.
Blast radius is bounded by the traffic share. A bug that breaks every request affects only the fraction of users routed to the canary. This is the main argument for it and it is a strong one.
Rollback is slower than blue-green. You shift traffic back to the stable version and then drain and remove the canary pods. Shifting the traffic is fast; the full cleanup is not, and during it you still have canary instances holding connections.
Detection is the whole point and also the problem. You are comparing the canary’s behaviour against the stable version’s. That comparison requires enough requests through the canary to be statistically meaningful. A service handling low traffic routed at a small percentage may take hours to accumulate enough requests, during which the deployment is stuck in a half-finished state that nobody wants to leave running overnight.
Both versions must coexist. They share the database, the cache, the message queue, and any other stateful thing. If the new version writes a message format the old version cannot read, a canary is an outage with extra steps.
Rolling update
Worth naming explicitly because it is what most teams are actually doing and it is not the same thing as a canary. Kubernetes replaces pods gradually under surge and unavailability settings, so old and new versions coexist during the rollout, but traffic distribution is a side effect of pod counts rather than a controlled variable, and there is no analysis or gate.
Rollback means another rolling update, in the opposite direction, at the same speed. If the roll forward took several minutes the roll back takes several minutes too, and during that window you are still serving the broken version to a shrinking share of traffic.
It is the right default for most services precisely because it is free and built in. It is the wrong choice when you need the failure to be contained rather than merely gradual.
Progressive delivery
Progressive delivery is canary with the human removed from the promotion decision. The controller shifts traffic to a defined step, waits, queries metrics, compares against thresholds or against the stable version, and then either advances to the next step or aborts and rolls back.
That control loop is what you are actually buying. Two implementation details determine whether it works:
What it queries. A metrics backend, using a query you write. The quality of that query is the quality of your entire safety mechanism, and a lazily written query is worse than no automation because it produces confident wrong answers.
How it handles insufficient data. When a query returns nothing, because no requests reached the canary yet, or because the metric has no data points, the controller has to decide something. Treating no data as success means a canary receiving zero traffic promotes to one hundred percent. Treating no data as failure means every low-traffic service fails every deployment. Both defaults exist in real products and both are wrong in the other case, so this is a configuration decision you must make consciously.
Automated rollback triggers, and what actually works
The trigger is the part teams get wrong. Some patterns hold up.
Compare against the stable version, not against a fixed threshold. An error rate above one percent is a bad trigger, because your baseline might be above one percent on a Monday morning. The canary having a meaningfully higher error rate than the stable version running concurrently is a good trigger, because both are experiencing the same traffic, the same dependencies and the same time of day. The concurrent comparison is the single most valuable property of a canary over a staged rollout.
Use a small number of signals that mean something. Error rate, latency at a high percentile, and one business metric that would notice a silent failure. Adding twenty metrics to the analysis produces false aborts, and a team that gets false aborts turns the automation off.
Latency needs percentiles, not averages. A mean latency hides a change that only affects a small share of requests, which is exactly the shape of the bug a canary is supposed to catch.
Include a business signal. Error rate and latency both look fine when the new version returns a perfectly formed empty list. Checkout starts, messages sent, searches returning results: one metric that would move if the feature broke silently. This is the trigger that catches the failures monitoring misses, and the Kubernetes APM guide covers where those signals come from.
Set a hard timeout. An analysis that never concludes leaves a deployment permanently half-shifted. A timeout that aborts is almost always the right behaviour, because an inconclusive canary is not evidence of safety.
Instrument the canary distinctly. The analysis needs to query canary metrics separately from stable metrics, which means both versions must emit a label identifying which they are. If your metrics do not carry that label, no product in this category can help you, and this is the most common reason an evaluation stalls in week one.
Treat the abort as an incident. An automated rollback is the system telling you a bad change reached production. If nobody looks at it, the same change gets redeployed tomorrow by someone who assumed it was a flake. Route aborts into your incident management flow.
Needs first-hand data: Take the last several production incidents caused by a deploy and, for each, work out which signal moved first and how long after the rollout started it became distinguishable from noise. That list is your analysis configuration. Anything you would not have caught with the metrics you have is a gap to close before automating promotion.
The part no deployment strategy solves: databases
Every mechanism above assumes both versions can serve traffic against the same data. Rollback is a routing change and routing changes do not undo schema migrations.
The consequence is a design constraint that sits outside the tooling entirely: for the whole window in which both versions can run, the schema must be compatible with both. In practice that means the expand and contract discipline. Add the new column, deploy code that writes both old and new, backfill, deploy code that reads the new, and only then, in a later release, remove the old column. Each step is independently reversible. The migration and the code change are never in the same deployment.
Skip that and your deployment tooling is decorative, because the first bad release that included a destructive migration will not roll back regardless of what the controller says. This is covered in depth in the database migration tools guide, and it is worth reading before you invest in traffic shifting.
Multi-service coordinated releases
Everything above handles one service. Real releases frequently involve several, and this is where the category thins out considerably.
The naive approach, deploy service A then service B then service C, fails in an obvious way: between A and B there is a window where A’s new version is talking to B’s old version. If the new API contract is not backward compatible, that window is an outage.
There are only a few honest answers.
Make every change backward compatible and stop coordinating. Deploy services independently in any order, with each version able to talk to the previous version of everything it depends on. This is more work per change and it is the approach that actually scales, because coordination cost grows superlinearly with service count while compatibility discipline grows linearly.
Deploy the consumer before the producer, or the reverse, depending on direction. For an additive API change, deploy the producer first so the capability exists before anything calls it. For a removal, deploy the consumers first so nothing calls it before it disappears. This ordering rule handles most cases and requires no tooling beyond the discipline to follow it.
Use a pipeline that models the dependency order explicitly, with gates between stages and a verification step at each. This is where Spinnaker, Harness and Octopus Deploy earn their place: they model a release as a graph of stages across environments and services rather than a single rollout. If you need coordinated releases, that modelling is what you are shopping for, not the canary implementation.
Decouple the release from the deployment with flags. Deploy every service with the new code path dark, then enable it everywhere with a flag change that is instant and instantly reversible. This is the strongest answer for a feature spanning services and it is why feature flags and deployment orchestration are complementary rather than competing.
Needs first-hand data: For your last multi-service release, record the wall clock from first deployment to last, and whether any incompatibility window existed between them. If it did, that window is a latent outage you got away with, and it should be the first thing your release process fixes.
Argo Rollouts
Argo Rollouts replaces the Kubernetes Deployment resource with a Rollout resource that adds canary and blue-green strategies with explicit step definitions. It integrates with service meshes and ingress controllers to control actual traffic weight rather than approximating it with pod counts, and its AnalysisTemplate resource defines the metric queries that drive automated promotion or abort.
Pros
- Traffic weight is controlled by the mesh or ingress rather than inferred from replica counts, so a small canary percentage means what it says rather than being bounded by pod granularity
- Analysis is a first-class Kubernetes resource, so the promotion criteria live in git alongside the workload and are reviewed like any other change
- Step-by-step canary definitions with explicit pauses support manual gates and automated ones in the same rollout, which suits teams partway through trusting the automation
- Fits naturally into a GitOps workflow, so the rollout definition and the application definition are managed by the same controller
Cons
- Requires replacing Deployment resources with Rollout resources, which touches every manifest and every tool that expected a Deployment, including some third-party operators and dashboards
- Fine-grained traffic control depends on a supported mesh or ingress, so without one you are back to replica-count approximation and the precision advantage disappears
- The analysis is only as good as the queries you write, and the product will confidently promote a broken release if your query does not measure the right thing
Best for: Kubernetes teams already running a service mesh or a capable ingress who want canary definitions and promotion criteria managed declaratively in git.
Pricing: Open source with no vendor and no bill. Cost is the cluster resources the controller consumes and the metrics backend it queries.
Flagger
Flagger takes a different design decision from Argo Rollouts: rather than replacing your Deployment, it watches it and generates the canary machinery around it. You keep a normal Deployment and add a Canary resource describing the strategy and the metric checks, and Flagger creates the shadow deployment, manages traffic weights through the mesh, runs the analysis, and promotes or rolls back.
Pros
- Leaves your existing Deployment resources intact, so adoption does not require rewriting manifests or breaking tools that expect standard resources
- Broad support across service meshes and ingress controllers, with the same Canary resource shape regardless of which one you run
- Supports webhook-based checks alongside metric checks, so a load test or an acceptance test can run as a promotion gate rather than only a metric query
- Part of the Flux ecosystem, so if you already run Flux the operational model and the security posture carry over
Cons
- Generating and managing shadow resources means more moving parts in the cluster than a single replaced resource, and debugging a stuck canary involves understanding what it created
- Effectively requires a service mesh or a compatible ingress for real traffic splitting, which is a substantial dependency to take on solely for progressive delivery
- Handling of low-traffic services is a configuration problem you must solve deliberately, and the default behaviour on missing metric data will surprise you at least once
Best for: Teams running a service mesh who want progressive delivery without changing their existing workload manifests.
Pricing: Open source with no vendor and no bill. Cost is the controller footprint and whatever mesh and metrics infrastructure it depends on.
Spinnaker

Spinnaker is the multi-cloud deployment platform built around modelling a release as a pipeline of stages across environments and providers. It predates the Kubernetes-native tools and shows it in both directions: it handles virtual machines, load balancer manipulation and cross-region orchestration that Kubernetes-only tools do not, and it carries the operational weight of a system designed in that era.
Pros
- Models releases as multi-stage pipelines across environments, regions and providers, which is the capability the Kubernetes-native tools genuinely lack
- Deployment strategies for virtual machine fleets and cloud load balancers, not just container orchestration, which matters for estates that are not entirely Kubernetes
- Automated canary analysis with statistical comparison between canary and baseline, developed for exactly this problem at large scale
- Manual judgment stages, approvals and complex conditional flows are first-class, which matters in regulated release processes
Cons
- Substantial operational footprint made of many microservices, and running it is a platform team commitment comparable to running the applications it deploys
- Configuration is largely through its own UI and data model rather than git-native manifests, which sits awkwardly alongside a GitOps practice
- Development pace and community energy have shifted toward the Kubernetes-native tools, so you are adopting something mature rather than something ascendant
Best for: Large mixed estates spanning virtual machines and containers across clouds, where multi-stage release orchestration matters more than Kubernetes-native ergonomics.
Pricing: Open source with no vendor and no bill for the software. Cost is the considerable infrastructure and platform engineering time required to operate it.
Harness

Harness is a commercial platform that packages deployment orchestration, progressive delivery and the analysis layer together, with an explicit focus on making automated verification work without you writing every query. It connects to your existing observability tooling, learns what normal looks like for a service, and makes the promotion decision from that rather than from thresholds you configure by hand.
Pros
- Automated verification that builds a baseline from your existing observability data removes the hardest part of progressive delivery, which is writing analysis queries that are actually correct
- Covers pipelines, approvals, environments and deployment strategies in one product, so the release process is modelled end to end rather than assembled from parts
- Supports Kubernetes alongside virtual machines, serverless and traditional targets, which suits estates midway through a migration
- Governance, approvals and audit trails are built for organisations where releases require sign-off, rather than added later
Cons
- Commercial platform with the lock-in that implies, since release pipelines defined in a vendor’s model are expensive to move and tend to accumulate organisational dependencies
- Automated verification is a statistical judgment on your data, and when it is wrong it is wrong in a way that is hard to interrogate without understanding the model
- Substantial product surface means adopting it is a platform decision rather than a tool decision, and using only the deployment piece leaves most of it unused
Best for: Organisations that want progressive delivery with the analysis layer handled, across mixed deployment targets, and prefer buying that capability to building it.
Pricing: Commercial subscription with metering typically on the number of services or deployment targets under management, tiered by capability.
Octopus Deploy
Octopus Deploy comes at this from the release management direction rather than the Kubernetes-native one. It models environments, releases, variables and deployment targets explicitly, and is strong precisely where the container-first tools are weak: deploying the same versioned release across many environments and many targets with per-environment configuration handled properly.
Pros
- Environment and variable modelling is the best in this category, which is what makes promoting one built artifact through many environments actually reliable
- Handles Windows and .NET deployment targets seriously rather than as an afterthought, which is a real differentiator for estates that include them
- Runbooks sit alongside deployments, so the operational procedures around a release live with the release rather than in a wiki
- Release promotion with per-environment approvals is a natural fit for organisations with formal change control
Cons
- Progressive delivery and automated canary analysis are weaker than in the Kubernetes-native tools, so if traffic-weighted rollout with automated verdicts is the goal this is not the closest fit
- The server-and-agent model is a piece of infrastructure to run and keep available, with its own upgrade path
- Its configuration lives in the product rather than in git by default, which takes deliberate effort to reconcile with a GitOps practice
Best for: Organisations promoting versioned releases through many environments, particularly mixed Windows and Linux estates with formal approval requirements.
Pricing: Commercial subscription metered on deployment targets, with a cloud-hosted and a self-hosted option under the same model.
Kubernetes
Before adding anything, it is worth being clear about what the platform already does, because for many services it is enough. A Deployment performs a rolling update governed by surge and unavailability settings, gated by readiness probes, with revision history that supports an undo command. There is no traffic weighting and no analysis, but there is a correct, well-understood gradual replacement mechanism that costs nothing to adopt.
Pros
- Already present in every cluster with no additional controller, no mesh dependency and no new failure mode to operate
- Readiness probes provide a genuine safety gate: a new pod that never becomes ready never receives traffic and the rollout stalls rather than proceeding
- Rollback to the previous revision is a single command against stored revision history, which is adequate for a large share of real failures
- Universally understood, so any engineer can reason about what is happening during a rollout without learning a product
Cons
- Traffic distribution is a side effect of pod counts, so you cannot express a small traffic percentage independently of replica count, which makes real canarying impossible below a coarse granularity
- No analysis and no automated abort, so detection is entirely human and rollback speed depends on someone noticing
- A rollback is another rolling update at the same pace as the roll forward, so recovery is not fast, and during it the broken version is still serving a share of traffic
Best for: The default for most services, and the correct answer until you can name the specific failure that traffic weighting and automated analysis would have caught.
Pricing: No vendor and no bill. It is part of the cluster you already run.
How to choose
Start by asking what your last bad deploy would have needed. Not what a strategy comparison says, what actually happened. If a rolling update plus a readiness probe would have caught it, you do not have a tooling problem. If it needed ten minutes of real traffic to become visible, you need canary analysis. If it needed instant reversal, you need blue-green.
Check that your metrics can distinguish canary from stable. Both versions must emit a label identifying which they are, and your metrics backend must let you query them separately. Without that, nothing here works, and fixing it is the prerequisite step rather than part of the rollout.
Decide the low-traffic policy before you automate. What should happen when a canary receives too few requests to judge? Pick abort, and accept that low-traffic services will need longer analysis windows or manual promotion. The alternative default promotes untested code.
Separate the one-service question from the many-service question. Argo Rollouts and Flagger are excellent at one service and have nothing to say about coordinating three. Spinnaker, Harness and Octopus Deploy model multi-stage releases and are comparatively unremarkable at traffic weighting. Buying the wrong half is the common mistake.
Fix your migrations first. Expand and contract, migrations separate from code deploys, backward compatible for the full coexistence window. Until that holds, your rollback button is a suggestion.
| Tool | Strategy focus | Rollback speed | Analysis | Scope |
|---|---|---|---|---|
| Argo Rollouts | Canary and blue-green, mesh-weighted | Fast traffic shift, then drain | Declarative metric templates | One service, Kubernetes |
| Flagger | Canary, mesh-weighted | Fast traffic shift, then drain | Metric checks plus webhooks | One service, Kubernetes |
| Spinnaker | Multi-stage pipelines | Pipeline-dependent | Statistical canary analysis | Multi-cloud, VMs and containers |
| Harness | Pipelines plus progressive delivery | Automated abort | Baseline learned from observability | Mixed targets |
| Octopus Deploy | Release promotion across environments | Redeploy previous release | Limited | Mixed estates, formal approvals |
| Kubernetes | Rolling update | Another rolling update | None | One service, built in |
For most Kubernetes teams the honest sequence is: get readiness probes right, adopt expand-and-contract migrations, then add Argo Rollouts or Flagger for the handful of services where a bad release is expensive. Everything else stays on rolling updates. If your estate is mixed or your releases genuinely span services with approval gates, you are shopping in the Spinnaker, Harness and Octopus Deploy half of the table instead. The rollout mechanism sits downstream of whatever builds the artifact, which is covered in the CI/CD platform comparison, and if the desired state is reconciled from git the GitOps tools guide covers how the two interact.
Frequently asked questions
Is blue-green or canary better?
They optimise for different things. Blue-green gives the fastest rollback, a routing change back to an untouched environment, at the cost of duplicated capacity and no partial exposure, so a problem hits everyone at once when you switch. Canary bounds the blast radius to a traffic percentage and lets you compare the new version against the old under identical conditions, but rollback involves draining and low-traffic services may never gather enough data to judge. Choose blue-green when reversal speed dominates, canary when limiting exposure dominates.
Do I need a service mesh for progressive delivery?
For meaningful traffic weighting, effectively yes, or a capable ingress controller that supports weighted routing. Without one, the traffic split is approximated by replica counts, which means a small canary percentage requires a large number of stable replicas and fine control is impossible. Adopting a mesh solely for progressive delivery is a big dependency for one capability; if you already run one, the marginal cost is small.
What happens if the canary does not get enough traffic to judge?
That depends on a configuration decision you should make explicitly. Treating missing metric data as success means a canary that received no requests promotes to full traffic, which defeats the purpose. Treating it as failure means low-traffic services fail every deployment. The workable pattern is to abort on insufficient data, and give low-traffic services longer analysis windows, a higher canary percentage, or manual promotion instead.
Can I roll back a database migration with these tools?
No. Every mechanism here changes routing or replaces pods, and neither undoes a schema change. The working discipline is expand and contract: additive migrations deployed separately from code, both versions able to operate against the schema for the whole coexistence window, and destructive changes deferred to a later release once nothing reads the old shape. Your rollback is only as good as your schema compatibility.
Do feature flags replace canary deployments?
No, they cover a different failure class. A flag controls behaviour inside a deployed binary, so it reverses instantly and does not require shipping anything, which makes it ideal for feature-level risk. A canary controls how much traffic reaches a new binary, which is the only thing that helps when the problem is a dependency upgrade, a runtime change, a memory leak or anything else that is not behind a flag. Teams that ship confidently use both.
Related reading
- Best CI/CD platforms — the pipeline that produces the artifact these tools promote.
- Best GitOps tools — reconciling desired state from git, and how it interacts with a rollout controller.
- Best feature flag platforms — reversing a feature without reversing a deployment.
- Best database migration tools — expand and contract, the constraint that makes rollback real.
- Best APM for Kubernetes — where the canary analysis signals come from and how to label them.
- Best incident management tools — treating an automated abort as the incident it is.
- Best postmortem tools — closing the loop on what the rollback did not prevent.