{"id":2332,"date":"2026-11-21T07:58:49","date_gmt":"2026-11-21T07:58:49","guid":{"rendered":"https:\/\/devopsschool.org\/blog\/?p=2332"},"modified":"2026-11-21T08:00:49","modified_gmt":"2026-11-21T08:00:49","slug":"rollback-roll-forward-flags-compared","status":"publish","type":"post","link":"https:\/\/devopsschool.org\/blog\/rollback-roll-forward-flags-compared\/","title":{"rendered":"Rollback, Roll-Forward, Flags or Failover: Which Plan B Fits?"},"content":{"rendered":"<p>Anyone preparing for a DevOps role will meet a question in interviews and on the job that sounds simple: &#8220;The release is failing in production. What do you do?&#8221; The strongest answers rarely name a single move. They compare options, state the conditions under which each fits, and say what would trigger the switch. This article compares four common fallback approaches, rollback, roll-forward, feature-flag switch-off and traffic failover, along the dimensions that matter to a practitioner: speed, risk, prerequisites and what each teaches you about the system. Use it to build the vocabulary of a plan B decided in advance.<\/p>\n<h2>The four options at a glance<\/h2>\n<ul>\n<li><strong>Rollback:<\/strong> redeploy the previous known-good version.<\/li>\n<li><strong>Roll-forward:<\/strong> ship a quick fix on top of the broken release.<\/li>\n<li><strong>Feature-flag switch-off:<\/strong> disable the new behaviour without redeploying.<\/li>\n<li><strong>Traffic failover:<\/strong> direct users to a healthy second environment or region.<\/li>\n<\/ul>\n<p>None is universally better. Each solves a particular kind of failure, and each has a cost that does not show up until you need it.<\/p>\n<h2>Comparison 1: Speed to restore service<\/h2>\n<p>Flag switch-off is usually the quickest, because the code is already deployed and a configuration change takes effect in moments. Traffic failover is next when the second environment is warm and routing is automated. Rollback takes as long as a deployment pipeline takes, which varies from a minute to much longer depending on the system. Roll-forward is the slowest and least predictable, because it depends on diagnosing the bug, writing a fix, testing it and shipping it, all under pressure.<\/p>\n<p>That ordering explains why teams that value fast recovery tend to invest in flags and automated routing. It also explains why roll-forward, though tempting, is rarely a sound pre-decided plan B: its duration is unknown.<\/p>\n<h2>Comparison 2: Risk introduced by the fallback itself<\/h2>\n<p>Every fallback is a change, and changes carry risk. A rollback reintroduces an older version that may not handle data written by the newer one. A roll-forward ships unreviewed code in a hurry. A flag switch-off can leave the system in a combination of states that was never tested. A failover may expose capacity or data-consistency issues in the second environment.<\/p>\n<p>The practical question for each is: what could this fallback break that is not already broken? Teams that answer it in advance usually add a constraint, for example making database changes backwards-compatible so that rollback stays safe, or rehearsing failover so that capacity is known.<\/p>\n<h2>Comparison 3: Prerequisites<\/h2>\n<ul>\n<li><strong>Rollback<\/strong> needs retained, deployable previous artefacts, and data changes that tolerate the older code.<\/li>\n<li><strong>Roll-forward<\/strong> needs a fast, reliable pipeline and a team able to diagnose quickly.<\/li>\n<li><strong>Flag switch-off<\/strong> needs the feature to have been built behind a flag and a flag system that is itself dependable.<\/li>\n<li><strong>Failover<\/strong> needs a second environment, replicated data, health checks and a routing mechanism you trust.<\/li>\n<\/ul>\n<p>For learners, this list is a useful study guide. Each prerequisite is a topic worth practising in a lab: artefact storage, schema migration patterns, configuration management, replication and load balancing.<\/p>\n<h2>Comparison 4: Cost<\/h2>\n<p>Flags are cheap to run but accumulate maintenance overhead if not cleaned up. Failover is the most expensive, since it effectively means paying for a second environment. Rollback is almost free if you already retain artefacts. Roll-forward costs little in infrastructure and a lot in engineer attention during an incident. Cost is worth weighing against the impact of the failure, because the sensible fallback for a revenue-critical checkout is not the same as for an internal report.<\/p>\n<h2>Comparison 5: What it teaches about the system<\/h2>\n<p>This dimension matters for careers more than for operations. Practising rollback teaches you about versioning and data compatibility. Flags teach progressive delivery and configuration discipline. Failover teaches you about replication, state and the real shape of dependencies. Roll-forward teaches debugging under pressure and the value of small changes. A learner who builds a small project and practises all four will understand deployment far better than one who only reads about it.<\/p>\n<p>If you are looking for projects to try, the walkthrough on <a href=\"https:\/\/devopsschool.org\/blog\/building-a-beginner-devops-portfolio-practical-projects-github-structure-and-roadmap\/\">putting together a starter DevOps portfolio, including project ideas and repository structure<\/a> offers a structure into which a &#8220;release with a documented fallback&#8221; project fits naturally. A write-up of how and why you chose the fallback shows interviewers more than a screenshot of a green pipeline.<\/p>\n<h2>A small lab to try all four<\/h2>\n<p>You can explore the comparison with a modest project. Build a simple web application with a database, deploy it through a basic pipeline, and keep two versions available. Add a flag that hides one feature. Run a second copy behind a simple router. Then deliberately break the new version in four different ways and respond with each fallback in turn, timing how long each takes and noting what surprised you.<\/p>\n<p>The write-up is the valuable part. For each exercise, record the trigger you would have used, how long restoration took, what the fallback risked, and what you would change. Over a few sessions you will have a compact set of evidence that you understand the trade-offs, and a repository that speaks for itself in an interview.<\/p>\n<h2>A decision table you can reason from<\/h2>\n<p>Instead of memorising rules, think in conditions.<\/p>\n<ol>\n<li>If the new behaviour is behind a flag and the fault is in that behaviour, switch it off.<\/li>\n<li>If the fault is in the build and the previous version is compatible with current data, roll back.<\/li>\n<li>If an entire environment or region is unhealthy, fail over, provided the standby is proven.<\/li>\n<li>If the fault is trivial, well understood and the pipeline is fast, a roll-forward may be reasonable, but it should be a deliberate choice and not the default.<\/li>\n<\/ol>\n<p>Notice that the decision depends on what you know at the moment, which is why each fallback needs a trigger and a named decision-maker. Interviewers often probe that gap: &#8220;How would you know it is time?&#8221; A measurable answer, such as an error rate over an agreed level for a set period, is far stronger than &#8220;when it looks bad&#8221;.<\/p>\n<h2>How certifications and study paths fit<\/h2>\n<p>Certifications cover many of these ideas in outline, and they can give a useful framework, though they do not replace practice. A balanced view of what they offer is in the discussion of <a href=\"https:\/\/devopsschool.org\/blog\/the-real-value-of-devops-certifications-in-modern-tech-careers\/\">where DevOps certifications help in modern tech careers<\/a>. For the topics in this article, the most valuable use of any course is as a prompt to build something and break it deliberately.<\/p>\n<h2>Take the idea beyond deployments<\/h2>\n<p>Having a pre-chosen alternative is a professional habit, not just a release technique. Plan your study schedule, your meetup attendance and your interview week the same way. If a workshop is cancelled or a session sells out, know what you will do instead. Events directories such as <a href=\"https:\/\/myeventnow.com\/\">MyEventNow<\/a>, an events-listing website with upcoming events, venues, categories like workshops and conferences, a blog and a forum, are one way to find a second option when the first falls through.<\/p>\n<h2>Summary of the comparison<\/h2>\n<p>Flags are fastest, rollback is simplest, failover is most robust and most costly, and roll-forward is the riskiest default. Choose per dependency, write the trigger, name the owner, and rehearse. Candidates who can explain that reasoning, and show a small project that demonstrates it, stand out in interviews because they are describing a way of working and not reciting a definition.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>A side-by-side comparison of four fallback approaches on speed, risk, prerequisites, cost and what each teaches, written for learners preparing for DevOps interviews and roles.<\/p>\n","protected":false},"author":5,"featured_media":2333,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[489],"tags":[],"class_list":["post-2332","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops-careers"],"_links":{"self":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/2332","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/comments?post=2332"}],"version-history":[{"count":1,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/2332\/revisions"}],"predecessor-version":[{"id":2402,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/2332\/revisions\/2402"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/media\/2333"}],"wp:attachment":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/media?parent=2332"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/categories?post=2332"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/tags?post=2332"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}