From Engineer to Architect

Design the
Failure First

Article 5 of 10 The Craft of the Decision · 7 min

Every design begins as a happy path. Valid input goes in, the expected result comes out, and the diagram on the whiteboard looks clean because nothing on it has failed yet. That happy path is the half of the system that will never page you at three in the morning. The other half, the one that does, is the half you did not draw. So before I ask a design how it works, I have learned to ask it how it breaks.

// the crux

It is not pessimism, it is prevention. Design the failure first, with the team, before production designs it for you.

// in one breath
  • Forward thinking optimises for the happy path. The failures live in the questions you never got around to asking.
  • Five architect decisions, each with the inverting question that surfaces its real risk before production does.
  • The pre-mortem: how to turn failure-hunting from a private worry into a written team artifact, and why the writing down is the whole point.
↳ the whole value system · From Engineer to Architect – the fourteen mental models this series is built on, and where this one sits.
the half you did not draw

The Happy Path Is the Half That Never Pages You

When we design something, our instinct is to think forward. What is the input? What is the output? What is the accepted, expected result? Those are the right questions, and they are also the comfortable ones, because they describe the world going the way we intended. An architect has to ask the second set out loud. What if the input is invalid? What if the output is never produced at all? What if something fails quietly in between, and nobody notices until the numbers stop adding up a week later?

That habit sounds like negativity to a room that wants momentum. In practice it is the cheapest prevention the design will ever get. Architectural decisions are rarely black or white. They arrive carrying assumptions, risks, blind spots, and edge cases, and the forward-facing version of every one of them quietly assumes the good case will hold. Flipping the question is how you find the assumptions that were fragile while they are still cheap to fix.

I have written before about the raw technique of inversion: ask how you would guarantee failure, list every way, and then read the list backwards into a set of requirements. That essay, Invert the Problem, is about the move itself, worked through a line of code and a security review. This one is about the architect's version of it, which is a different thing. It runs the flip not on a single task but on the decisions that outlive your code, and it does the flipping in public, with the people who will have to live with the answer long after you have moved on to the next system.

five decisions worth failing first

Ask the Second Question First

Here are five places where the flip pays for itself, each a decision I make often and each with the question I have learned to ask second, before the design hardens into a diagram. The forward question gets you a plan. The inverting question gets you the plan's failure modes, which is the part that actually decides whether the thing survives contact with production.

Resilience
forward → how do we make this reliable?
What happens the first time this dependency is simply gone? Not slow, gone. Does the system shed load and degrade, or does it queue, retry, and take the rest of the platform down with it? The answer is the difference between an incident and an outage. See nobody promised you 100 percent uptime.
Deployments
forward → how do we ship this?
What is the rollback, who runs it at 2am, and have we ever actually tested it? A rollback plan nobody has executed is a hope with a filename. The deploy is not the risky moment. The undo you have never rehearsed is.
Tech-stack choice
forward → which tool is best?
What if this tool is deprecated, acquired, or abandoned in twelve months? Not whether it will happen, but how expensive it is if it does. The question is not which tool wins today, it is how married to it you are choosing to become.
API design
forward → what is the contract?
What is the worst thing a client can do with this endpoint, by accident or on purpose? Someone will call it in a loop, pass the wrong type, and depend on a field you meant to remove. The contract you can defend is the one designed against its misuse, not just its use.
Data modelling
forward → what is the schema?
What breaks the day this schema has to change? Schemas always change. The real design question is who is downstream of that change, how they find out, and whether they find out from a migration note or from a production error at midnight.

None of these are exotic. They are the ordinary decisions of a Tuesday, and that is the point. The inverting question does not require a framework or a workshop. It requires the discipline to spend thirty more seconds looking at the unhappy path before you sign off on the happy one.

write it down, invite the attack

A Worry in Your Head Is Not a Safeguard

This is where the architect's version diverges most from the private technique. If the failure list lives only in your head, it protects nothing. The move that turns inversion from a personal habit into a team capability is to write the failure factors down, and then hand them to the people most likely to find the ones you missed. The single most useful sentence I bring into a design review is not a proposal. It is an invitation: tell me how you would break this.

// the ritual
The pre-mortem
  • Before the build, gather the team and move the clock. Say it is a year from now and this system has failed. Not "might fail". Has failed, publicly, in a way everyone remembers.
  • Now work backwards. Why? Every answer is a failure factor. People will name risks in a failed-future frame that they would never raise against a design they were asked to approve.
  • Write the list down as an artifact, next to the decision record, not in the margin of your notebook. A named list gets reviewed. A private worry gets forgotten the moment the meeting ends.
  • Design against the top of the list, and keep the rest where the next person can see what you consciously chose to accept. Foreseen and accepted is a decision. Foreseen and unwritten is a liability.

The reason this works is social, not technical. A review that asks "does this work?" gets you agreement, because agreement is the polite default and nobody wants to be the person slowing the room down. A review that asks "how would you break this?" gets you the truth, because now finding a flaw is the assignment rather than an act of dissent. You are not inviting criticism of the design. You are recruiting the whole room into designing its failure with you.

// the failure that costs the most

The risk that was seen and never said

The most expensive failures I have watched were not the ones nobody predicted. They were the ones one person predicted privately, saw clearly, and kept to themselves because raising a concern felt like negativity in a room that had already decided to move. A risk foreseen and unspoken is worse than a risk nobody saw, because it was preventable, and all that stood in the way was the comfortable silence. Which is why inverted thinking and a team that is safe to challenge are the same discipline wearing two names.

into monday

Where This Lands

Inverted thinking does not replace design review, threat modelling, or architecture review. It is the cheapest thing that makes all of them honest, and it costs a whiteboard and the willingness to look at the stormy path on purpose. Five concrete moves carry it out of theory.

// take this into your next design
  1. Write the inverting question above the forward one. For the next real decision you own, put "how does this break?" on the page before "how does this work?".
  2. Run one pre-mortem before your next design review. Twenty minutes, the whole team, one prompt: it failed, why?
  3. Turn the failure factors into an artifact. A named list beside the decision record, not a worry in your head that expires when the meeting does.
  4. Ask "how would you break this?" out loud, and mean it. Make finding the flaw the assignment, not the transgression.
  5. Say the risk you would rather not mention. The unspoken one is the expensive one, every time.
owned publicly
// I believe this

Great architects do not just deliver the happy path. They anticipate the stormy one, and they write it down where the team can argue with it.

Ask how it breaks before you ask how it works. Write the answer down where the team can see it, and turn the review into a hunt for what could fail rather than a vote on what should work. Do that, and most of the failures you were going to discover in production, you discover instead on a Tuesday, on a whiteboard, with time to design around them and nobody awake at three in the morning because of a path you could have drawn and chose not to.
// carry forward

Designing the failure first assumes you can see it coming. Article 6 turns to deep roots: the core knowledge and the habit of continuous learning that let an architect recognise a failure mode before it has a name in production, and know which of the old fundamentals the new problem is really made of.