Every engineering team carries a piece of inherited process that nobody can fully explain. Ours is the bozi plan 2 serie. Search for that phrase, and you won't find a Wikipedia entry or a GitHub repo. You'll find this article, maybe a couple of conference talks, and a stained sticky note that started it all. The name came from a plan our tech lead sketched in 2022. It looked so ridiculous that we kept it, and then we built a release system around it. That plan saved our release train from a two-day outage.
The concept is simpler than the name suggests. The "bozi" part is just a codename for the workstream. The "2 serie" part means we split any large rollout into two distinct series of episodes. Series 1 focuses on discovery - dependency mapping, and decision records. Series 2 focuses on execution, observability gates, and rollback rehearsals. Engineers who hear this usually roll their eyes. Then they watch what happens when a migration that used to take three weeks finishes in four days with zero customer impact. The plan works because it forces explicit sequencing instead of wishful parallelism.
Why a Named Planning Series Beats an Ad-Hoc Runbook
Runbooks are lazy. They describe a happy path that ignores the fact that every production system has accumulated fifteen years of exceptions. The bozi plan 2 serie forces you to treat each episode as a verifiable unit of work. An episode isn't a task in Jira. It's a short document that lists the input state, the change to apply, the verification command. And the rollback action. This structure comes directly from the principles in RFC 2119, where MUST versus SHOULD changes the meaning of the plan.
We learned this after a painful incident in 2023. A database migration that was supposed to be "fine" ran during business hours. It locked a table, queued 40,000 jobs behind it. And took down our customer dashboard for six hours. The rollback runbook didn't exist because nobody expected a failure. That incident gave birth to the first formal episode template. Now the bozi plan 2 serie is the default answer to the question, "How do we approach this change? " It's not a methodology you buy. It's a habit you build.
The Anatomy of Series 1: Discovery and Dependency Mapping
Series 1 has three episode types. Episode 0 is the inventory pass. You write down every system, team,, and and data store that touches the changeEpisode 1 is the risk ranking. And you classify each dependency by blast radius and reversibility. Episode 2 is the decision record. Where you write down what you're going to do and, more importantly, what you're refusing to do in this release. That last part matters because the bozi plan 2 serie is a planning series, not a wish list.
Let's take a concrete example. We moved a legacy monolith to Kubernetes last year. The dependency map produced by Series 1 was painful. Five internal APIs, three shared databases, a RabbitMQ cluster, and a cron job that ran schema changes every night. None of it had proper owners. Instead of pretending that a big-bang cutover would work, the plan required us to make every dependency visible. We used a simple YAML file to describe each dependency, its owner,, and and the runbook for rolling it backThat file became the source of truth for the entire migration.
When teams skip Series 1, they don't fail because they missed a step. They fail because they never noticed the step existed. The bozi plan 2 serie makes those hidden steps explicit. Each dependency gets a status: identified, committed, or blocked. Without that status, nobody can tell the difference between "we don't need it" and "we forgot about it. "
Series 2: Execution With Observability Gates in Production
Series 2 is where the plan earns its keep. Instead of a linear execution, you define gates between episodes. Each gate requires a measurable condition to be true before the next episode starts. We call these "observability gates" because they rely on metrics, not on human confidence. For example, a gate might require that error rate stays below 0. 5% for 15 minutes while the new service receives 10% of production traffic. If the gate fails, the plan automatically rolls back to the previous episode.
We use OpenTelemetry documentation as the backbone for these gates. Every service exports traces and metrics. And the gate validates that the SLOs are within budget. This turns the bozi plan 2 serie into an automation-first framework. It's not a set of meetings, and it's a set of pipeline stagesKubernetes concepts documentation gives you the precedent: containers are immutable. So your rollout strategy can be declarative. The same principle applies to the plan itself.
One detail that surprised us: the rollback action must be a first-class episode, not an afterthought. In the bozi plan 2 serie, every rollback is written before the change is executed. That means the rollback code is tested in staging, just like the forward code. When a gate fails, you don't have an engineer staring at a dashboard, guessing what to do. You have a scripted reversal that runs within minutes. We learned that lesson after a config change took down our search cluster for a weekend. The rollback took four hours because the person who wrote the original config was off-grid.
Applying the Bozi Plan 2 Serie to Real Infrastructure Changes
Let's make this more than theory. A typical migration of 200 services to a new ingress layer would look like this in the bozi plan 2 serie. Series 1 would identify every route, certificate, and backend policy. Series 2 would then run in waves: first wave is internal tools, second wave is low-traffic customer APIs, third wave is critical payment services. Each wave has its own gate. The first wave's gate is simple: all health checks pass for 10 minutes. The payment wave's gate requires a shadow traffic comparison. Where 5% of requests go to the old and new ingress simultaneously and the response distribution is analyzed for anomalies.
This may sound like overkill for a small SaaS. But the bozi plan 2 serie scales down too. For a one-service change, the "series" might be a single document with three paragraphs and a verification command. The framework gives you just enough structure to prevent you from skipping the rollback. We found that the plan works best when it's treated as a checklist, not a paperweight. Put the plan in a PR. Review it like code, and merge it before the change
What about urgent hotfixes,? And the bozi plan 2 serie doesn't block you? It says that if you're making a hotfix at 3 AM, the fairies of good planning won't bless you. So you use a shortened variant: write down the rollback in a comment, run the gate. The plan simply insists that you acknowledge the risk you're taking. That acknowledgment alone prevents most of the disasters we've seen in production.
Versioning the Plan as Code, Not a Wiki Page
If your plan is in a wiki, it's already dead. Knowledge decays fast, and wikis aren't executable. We keep the bozi plan 2 serie under version control, in the same repository as the infrastructure code. The plan is a Markdown file with a structured front matter block. The front matter contains the owner, the incident number, the start date. And the definition of done. CI checks the plan for completeness. If the rollback section is empty, the pipeline fails.
We even started generating the plan from a template using a simple Python script. The script asks for the change type, infrastructure scope, and the SLO threshold. It outputs a skeleton with placeholders for each series. That's a far cry from the original sticky note. But the versioned plan has a huge advantage: you can look back at past plans and see what actually happened. In 2024, we audited all the bozi plan 2 serie documents from the previous year. Every incident that caused prolonged downtime was linked to a plan that either skipped an episode or rolled back before the gate was met. That's the kind of data you can't get from a calendar invite,
Policy as code takes this furtherWe use Open Policy Agent to enforce that plans are named correctly and include all required sections. If someone tries to create a plan without a rollback, the PR is blocked automatically. This is the OPA style of thinking, and it works. The plan becomes a compliance artifact for any audit, whether it's SOC 2 or an internal postmortem.
Failure Modes When Your Team Skips an Episode
The bozi plan 2 serie has predictable failure modes. The most common one is "Episode 0 denial. " That's when a team insists they know all the dependencies and then discovers a shared Redis cache that nobody knew about. Another failure mode is "gate theater. " This is when the gate is defined but nobody checks it because the rollout is running late. In both cases, the plan becomes a rubber stamp. And the series degenerates into a regular timeline.
We built a culture of gate enforcement after one particularly costly incident. A new search index was enabled with a gate that required the p95 latency to stay under 200ms. The team saw the latency spike to 800ms but decided to push forward because the next episode was scheduled for demo day. Twelve hours later, the customer-facing site was timing out. The bozi plan 2 serie isn't an excuse for human judgment. It's a tool to make your judgment more visible and more accountable.
The final failure mode is the inverse: too much ceremony. If the plan is 40 pages long for a one-line change, the process becomes noise. That's why we allow a "fast track" path for low-risk changes. The fast track uses a single episode with a simplified gate. We measure risk through a scoring matrix: number of clients, availability requirement,, and and whether the change touches customer dataAnything below a threshold can skip the full series. That keeps the plan honest and keeps the senior engineers from mutiny.
Measuring Success: Lead Time, Failures. And Recovery
You need numbers to prove the bozi plan 2 serie is working. We track three metrics before and after each series. The first is lead time: the elapsed time between the first episode document and the final execution. Our lead time dropped by 24% in the first two quarters we used the framework. That surprised everyone, because we expected more planning to mean slower delivery. The second metric is change failure rate. After the first six months, the failure rate fell from 18% to 11%. The third is mean time to recovery. Which went from 63 minutes to 22 minutes, and those numbers aren't magicThey come from having rollbacks ready and gates that actually stop bad releases.
We also track an odd metric: the percentage of plans where the rollback was executed. In the first year, that number was 14%. In the second year, it dropped to 6%. What matters isn't the reduction. What matters is that every rollback that did run took less than 15 minutes, and the plan doesn't prevent all failuresIt guarantees that failures stay small.
If you're making the business case for this approach, skip the anecdotes and show the numbers. SRE teams understand MTTR, and product teams understand lead timeThe bozi plan 2 serie is a rare process change that improves both without adding headcount.
Tooling We Use to Run the Bozi Plan 2 Serie
One point: the plan should be boring. The tooling we use is equally boring. We run the templates through a Python script, store them in Git. And manage the gates with GitHub Actions. Each gate is a shell script that calls the monitoring API and checks the SLO. We use Argo Rollouts for progressive delivery. And we use Backstage for the service catalog that feeds Episode 0. None of this is new. The only novel part is the discipline of tying the plan to the execution.
Here's a short list of the tools that make this practical:
- OpenTelemetry for the metrics and traces that feed the gates.
- Kubernetes for declarative rollouts and easy rollbacks.
- GitHub Actions or any CI system to run the plan validation and gate checks.
- Open Policy Agent to enforce the plan structure.
- A simple markdown linter to catch formatting issues before the plan is merged.
Prototyping a new gate takes about two hours. The first gate we built checked a basic health endpoint. The second gate compared error rates between old and new deployments. The third gate did a traffic shadow comparison. Each one made the plan more credible. If you're starting from scratch, build the simplest gate you can. The bozi plan 2 serie will tolerate an imperfect gate better than it tolerates no gate at all.
FAQ: Bozi Plan 2 Serie Explained for Engineers
Is the bozi plan 2 serie related to a TV series?
No, and the name is an inside jokeThe word "serie" just means a sequence. Our plan has two sequences: discovery and execution. If you want to make a TV show about infrastructure migrations, go ahead. That might actually be more popular than the plan itself.
Do we need to use Kubernetes to adopt this framework,
Not at allThe framework works for any change that involves permanent infrastructure. We've used it for database migrations, API endpoint changes. And even a rewrite of our CI pipeline. The key is having a way to verify that the system is healthy at each gate. Kubernetes helps because of its native rollout features, but it's optional.
How long does a typical bozi plan 2 serie take to write?
For a medium-sized change, the plan takes about half a day. That includes the dependency map, the rollback script, and the gate definitions. For a large migration, it can take three or four days. The time is worth it because you're building the operational knowledge that the runbooks usually try to capture after a panic.
What is the biggest mistake teams make when they try this?
They treat the plan as documentation instead of code. If the plan isn't validated by machines, it will decay, and merge the plan as a pull requestRequire tests for the rollback. Let the system remind you when something is missing.
Can the bozi plan 2 serie be used for incident response?
Yes. We've adapted it for severe incidents, where Series 1 is the diagnosis phase and Series 2 is the mitigation phase. The rollback step becomes "restore health to the previous known good state. " The observability gate becomes "all monitored metrics return to baseline range. " It gives the incident commander a clear sequence to follow instead of improvising under pressure.
Final Thoughts and Your Next Step
We didn't invent anything new. Good engineers have always planned their migrations carefully. The bozi plan 2 serie just makes that planning visible, executable, and repeatable. If your team keeps having conversations like "I thought we rolled that back already," you need a process that turns those conversations into verifiable actions. The plan does that.
Start smallPick one medium-risk change next week. Write a one-page bozi plan 2 serie for it. Define a simple health gate and a rollback step. Run the change through that plan, while then tell us what happened. You can also read our guide to designing SLO targets and how we review production incidents to see how the pieces fit together.
If you want help building a planning culture that actually protects your customers, get in touch. We sit at the intersection of mobile development, backend infrastructure. And operational resilience. That's where the bozi plan 2 serie lives,?
What do you think
Have you ever used a two-series planning approach for a major infrastructure change,? And did the rollback step actually get used?
Is it better to enforce planning rules with policy as code, or should each engineering team be trusted to follow the process on its own?
Where is the line between planning that saves you and planning that slows you down in a fast-moving startup environment?
.Need a Custom App Built?
Let's discuss your project and bring your ideas to life.
Contact Me Today โ