Introduction
I read The Phoenix Project by Gene Kim, Kevin Behr and George Spafford expecting a book about DevOps. What I found was a mirror. An uncomfortable mirror, the kind that shows you the things you would rather not see — not because you don’t know they exist, but because you have already given up trying to change them.
The book tells the story of Bill Palmer, an IT manager who inherits a chaotic project, a company on the brink of technological collapse and a team that fights fires all day long without ever fixing the causes. The fiction is so accurate it reads like journalism. And for me, having worked as a software architect for years, the read was less fiction and more documentary — because I live variations of this story every week.
I am not going to write a review. There are hundreds. What I will do here is explain why this book hit me, where I recognized myself, and what it exposes about a problem few people want to admit: most IT organizations are not prepared to build software properly — and the professional who tries to do it right is often treated as the problem, not as the solution.
If you are a developer, architect, tech lead or any professional who has ever felt the frustration of wanting to apply good practices in an environment that doesn’t even know what CI/CD is, this text is for you.
The scenario the book describes — and that I recognize
IT as a glorified support department
In the book, IT at Parts Unlimited is not seen as a strategic part of the business. It is the department that “keeps the computers running”. Projects are pushed through without planning, priorities change every week, and nobody understands — or cares about — the impact of technical decisions on the final result.
This is not fiction. It is the norm in an absurd number of companies.
I have lost count of how many meetings I attended where critical architectural decisions were made by people who don’t understand the difference between a manual deploy and an automated pipeline. Where the answer to “we need CI/CD” is “but what is that?” — not from an intern, but from managers with years at the company.
The book captures this dynamic with painful precision: IT is not ignored out of malice, but out of systemic ignorance. The people at the top simply don’t know what they don’t know. And those who do know — those in the trenches writing code, maintaining systems, waking up in the middle of the night because of incidents — don’t have enough of a voice to change course.
Brent — the involuntary hero who blocks everything (and I know because I am him)
One of the most revealing characters in the book is Brent, the brilliant engineer who is the bottleneck for everything. Every project depends on him. Every critical escalation lands on his desk. He is indispensable — and precisely because of that, he is the organization’s biggest risk.
I didn’t “relate” to Brent. I am Brent. With one crucial difference: I am fully aware of it.
I know I am a bottleneck. I know that when everything goes through me, the organization is fragile. I know that if I go on vacation, projects stop. I know this is not a sign of competence — it is a sign of organizational failure. The book gave me a name for something I already felt: I shouldn’t be irreplaceable, and the fact that I am is a problem I cannot solve on my own.
⚠️ Warning: If your company has a “Brent” — someone without whom nothing works — you don’t have a hero. You have a single point of failure with a badge. And that professional probably already knows it. The question is: does management?
The difference between the Brent in the book and me is that the Brent in the book doesn’t question the situation — he just executes, absorbs, solves. I question it. I raise my hand and say: “we need more people with technical seniority”. And that is where things stall.
Because the real challenge is not technical. The challenge is convincing management that technical seniority has the same value as business seniority. That the company needs more professionals who understand architecture, who know how to configure a pipeline, who can make technical decisions autonomously — and not only people who understand the business process but don’t know the difference between a deploy and a commit.
The book shows that Bill Palmer’s solution to the Brent problem is to protect him, document his knowledge and distribute it to the team. I agree. But the book assumes something that doesn’t exist in my reality: that there is a team with enough technical capacity to absorb that knowledge.
When the whole team operates at a level where CI/CD is an unknown concept, distributing knowledge is not enough. Before that, the organization needs to invest in hiring and retaining professionals with real technical depth. Not more generalists who “figure it out”. Professionals who understand why things are done a certain way — not just how.
💡 Tip: If you are a self-aware Brent, document everything you do — not out of altruism, but as strategy. Documentation turns tacit knowledge into concrete evidence that the organization depends on a single person. When management asks “why do we need to hire more senior people?”, the answer is in the number of documents that have your name as the only author.
Where I recognize myself — and where it hurts
The architect who wants to do it right in an environment that doesn’t want to change
This is the most personal point of this text, and I will be direct.
I am the kind of professional who cares about quality. Not out of sterile perfectionism — but because I have seen the cost of doing it wrong. I have seen manual deploys break production. I have seen untested code cause incidents that lasted hours. I have seen bad architectural decisions generate technical debt that took years to pay off.
When I propose CI/CD, automated tests, code review, infrastructure as code, observability, it is not because I like to complicate things. It is because I have already lived the consequences of not having them. And the book captures exactly this frustration: the professional who sees the problem, proposes the solution, and hears “we don’t have time for that” — while all the time is consumed putting out the fires that the lack of those practices caused.
And here is the irony the book doesn’t explore but that I live: being Brent and being the architect at the same time. I am the technical bottleneck who solves everything — and at the same time I am the professional who knows this situation is unsustainable and tries to change it. But to change it, I need management to understand something that seems obvious but isn’t: the organization needs to value and invest in technical seniority, not only in business seniority.
In most companies I have known, the career path rewards those who understand processes, management, stakeholders. And that matters. But when the entire leadership is made up of people who can’t tell a monolith from a microservice, technical decisions end up in the hands of people who lack the context to make them — or in the hands of a single Brent who accumulates everything.
ℹ️ Info: The concept of “The Three Ways” presented in the book — Flow, Feedback and Continuous Learning — is the framework underpinning the whole DevOps culture. Flow is about optimizing work from left to right (dev → ops → production). Feedback is about creating fast return loops (monitoring, alerts, tests). Continuous Learning is about experimenting, failing in a controlled way and improving the system as a whole.
In my reality, what I see is the opposite of the Three Ways:
- Non-existent flow: manual deploys, no pipeline, no standardization. Each developer does it their own way. There is no defined path from code to production — there is a patchwork of scripts, manual access and “so-and-so knows how to do it”.
- Zero feedback: no real monitoring, no deploy metrics, no smart alerts. When something breaks, the team finds out because the user complained.
- Non-existent learning: post-mortems don’t happen. The same mistakes repeat. Nobody documents. Nobody questions the process — because there is no process.
When not even the basics exist
What the book calls “unplanned work” — that constant flow of interruptions, emergencies and fixes that consumes 100% of the team’s capacity — I call Monday.
At the book’s Parts Unlimited, unplanned work dominates because there are no controls. There is no visibility into what is in progress. There is no prioritization based on impact. Everything is urgent, so nothing is urgent.
In my context, I have seen entire teams that:
- Don’t know what a CI/CD pipeline is — they have literally never heard the term
- Deploy by copying files via FTP or RDP
- Don’t have a single automated test in projects that are years old
- Don’t use branches — everybody commits to main
- Don’t do code review — “trust that it works”
And when you propose changing this, the most common answer is not active resistance. It is something worse: indifference. “It has always worked this way.” “We don’t have the budget.” “The team isn’t ready.” “We’ll look at it later.”
The book names this pattern. And naming it is the first step to fighting it.
What the book teaches — for those who want to listen
The Three Ways in practice
Gene Kim didn’t invent DevOps. But he synthesized its principles in a way any IT person can understand — including those who have never read a technical book:
First Way — Flow: The goal is to reduce the time between a developer’s commit and the code running in production. This requires:
- An automated CI/CD pipeline
- Small, frequent deploys (instead of giant releases every 3 months)
- Eliminating manual handoffs between teams (dev → QA → ops → infra → security)
- Limited Work in Progress (WIP) — less work in parallel, more work finished
Second Way — Feedback: The goal is to know quickly when something broke — and understand why. This requires:
- Real monitoring and observability (not just a dashboard nobody looks at)
- Automated tests at every stage of the pipeline
- Alerts that reach the right people at the right time
- Deploy metrics: frequency, lead time, failure rate, recovery time (the DORA metrics)
Third Way — Continuous Learning: The goal is to create a culture where making mistakes is allowed — as long as you learn and the system improves. This requires:
- Blameless post-mortems
- Controlled experimentation (feature flags, canary deploys)
- Dedicated time for technical improvement (not just new features)
- Knowledge sharing (documentation, pair programming, tech talks)
💡 Tip: If you want to start applying the Three Ways and don’t know where to begin, start with the First Way: automate the build and the deploy. A simple CI pipeline with build + tests + automated deploy already eliminates an absurd amount of unplanned work. Don’t try to solve everything at once — the book itself teaches that incremental change is more effective than revolution.
Cultural change is harder than technical change
The book makes it clear: the technical side of DevOps is the easiest part. Configuring a pipeline, spinning up a container, automating a deploy — all of that has documentation, tutorials, tools. The hard part is changing people. Changing processes. Changing an organizational culture that rewards whoever puts out fires and ignores whoever prevents them.
This is the point that frustrates me the most and motivates me the most. Because I know change is possible. The book proves it — Bill Palmer succeeds. But he only succeeds because he finds allies, because he has support (even if late) from leadership, and because he is persistent enough not to give up when everything seems impossible.
Tips for those who relate to this frustration
If you have read this far and recognized yourself, here are some lessons the book reinforced for me:
- Document everything. Processes, decisions, incidents. Documentation is the silent weapon that turns “so-and-so knows” into “it is documented here”. The Brent syndrome dies with documentation.
- Start small. Don’t try to implement all of DevOps on Monday. Start with a CI pipeline for one project. Show the result. Let success speak.
- Measure before proposing. Before saying “we need CI/CD”, show the data: how many hours per month are spent on manual deploys? How many incidents happened due to human error in production? Numbers change conversations that opinions don’t.
- Find allies. Bill Palmer didn’t change Parts Unlimited alone. You won’t change your organization alone either. Identify who cares, who feels the same pain, and build the change together.
- Accept that some environments won’t change. This is hard to hear, but it is real. If after years of trying the environment is still resistant, maybe the environment doesn’t deserve your best. The book shows the transformation — but not every real organization wants to be transformed.
Conclusion
The Phoenix Project is not a DevOps book. It is a book about how IT organizations sabotage themselves — and how it is possible to stop doing it. Gene Kim, Kevin Behr and George Spafford wrote a novel that is, in fact, a diagnostic manual disguised as fiction.
For me, as an architect and as a self-aware Brent, the read was both validating and frustrating. Validating because it confirmed that what I observe is not paranoia — it is a documented, studied and solvable organizational pattern. Frustrating because it reminded me that knowing the solution is not enough. The environment has to want to change — and management has to understand that investing in professionals with technical depth is not a cost, it is prevention.
If you work in IT and have never read this book, read it. Not because it will teach you Kubernetes or Terraform. But because it will give you vocabulary to name the chaos — and conceptual tools to start organizing it. If you are a manager, read it even more carefully: your company’s Brent probably already knows he is a bottleneck. What he needs is not recognition — it is peers at his level. Professionals with real technical seniority who can share the load, question decisions and raise the level of the entire team.
And if you are like me — the Brent who knows he shouldn’t be irreplaceable, who proposes changes and hears silence, who wants to do it right in an environment that rewards improvisation — you will feel less alone when you realize that Bill Palmer has also been exactly where you are.
The difference between Parts Unlimited at the beginning of the book and at the end was not technology. It was decision. The decision to stop accepting chaos as normal. The decision to measure, automate, document and continuously improve. The decision to treat IT as a strategic part of the business, not as an operational cost. And, above all, the decision to value those who build — not only those who manage.
That decision still has to be made in many companies. Maybe in yours. Maybe in mine.
Read Also
- The Pragmatic Programmer: practical lessons from the book
- Will AI Replace Developers? An Honest Opinion
- Software Architecture: GoF, Patterns and Microservices
- Terminal vs Pipeline: differences when running scripts
References
- Gene Kim, Kevin Behr, George Spafford — The Phoenix Project (IT Revolution Press, 2013) — Official site of the book and of the publisher IT Revolution
- DORA Metrics — Four Keys — The four key software delivery performance metrics defined by Google’s DORA team
- Gene Kim — The DevOps Handbook (IT Revolution Press, 2016) — The practical companion to The Phoenix Project, with frameworks and techniques to implement the Three Ways
- State of DevOps Report 2024 — DORA — Annual report with data on DevOps maturity in organizations worldwide
- Martin Fowler — Continuous Integration — Seminal article on continuous integration that underpins the First Way

By commenting, you agree to our Privacy Policy, Terms of Use, Data Deletion Policy.