The Question That Saves Launches: Why We Start With How It Could Fail

The Question That Saves Launches: Why We Start With How It Could Fail

Most software projects begin with an enthusiastic question: what should we build? The conversation that follows is usually full of energy. Features are listed, screens are sketched, and a launch date appears on the calendar. Almost nobody in the room asks the less comfortable question, the one that sounds pessimistic but is actually the most useful thing a team can do before writing a single line of code.

Imagine it is one year from now, and this project has failed. What happened?

This exercise is called a pre-mortem. It was popularised by the researcher Gary Klein, and it works for a simple reason: people are far better at explaining a failure that has already happened than at predicting one in the abstract. Asking "what could go wrong?" invites polite optimism. Asking "what went wrong?" invites specifics.

At UDaaann IT Solutions, the pre-mortem is one of the first things we do with a client. This article explains what it looks like in practice, why it changes the work, and what it reveals about how good software gets made.


Why Optimism Is the Default Setting

Teams are not careless. They are human. When a project is new, the people involved are motivated, the scope feels manageable, and the deadline looks reachable. That energy is valuable, but it has a side effect: risks get framed as small, unlikely, or somebody else's job.

Psychologists describe one version of this as the planning fallacy, the tendency to underestimate how long things take and how much can go wrong. In business, it often appears as the gap between the plan on the slide and the plan that survives contact with real users.

The pre-mortem does not remove optimism. It gives optimism a checklist.

How a Pre-Mortem Works With a Client

We run it as a structured conversation, usually in a single session of around ninety minutes, with the people who will own the product on the client side and the people who will build it on ours.

Step-1: set the scene. We ask everyone to imagine the launch has happened and the project has clearly failed. Users have stopped logging in, a key integration has broken, or the budget ran out halfway through. The failure is treated as fact, so the discussion stays concrete.

Step-2: write the reasons, silently. Each person writes down the causes they can think of, alone, for a few minutes. Silent writing matters. It stops the loudest voice from setting the agenda, and it surfaces concerns a newer team member might never say aloud in a meeting.

Step-3: group and rank. The reasons are sorted into themes such as unclear ownership, a data problem, a dependency on a third party, or a timeline that assumed no surprises. We then ask which causes are both likely and damaging.

Step-4: turn the top risks into decisions. Each serious risk gets an owner, a mitigation, and a check. A risk of "the payment provider changes its API" might lead to an abstraction layer and an agreed fallback. A risk of "nobody uses the new feature" might lead to a small pilot before the full build.

The output is not a document that sits in a folder. It is a short list of decisions that shape the scope, the architecture, and the rollout plan.

What Pre-Mortems Usually Reveal

After many of these sessions, a few patterns appear again and again. None of them are dramatic, which is exactly why they are easy to miss.

Ownership is assumed, not agreed. Two people believe the other is responsible for data migration. A pre-mortem exposes this in minutes, which is far cheaper than discovering it during the cutover.

Integrations are treated as details. A connection to an accounting system or a payment gateway often looks like one line in the plan. In the pre-mortem, it becomes a likely cause of failure, because its rules, limits, and failure modes were never explored.

Success is not defined. Asked "how will we know this worked?", teams often answer "users will be happy." That is not a measure. The exercise pushes the conversation toward numbers: response time, error rates, manual steps removed, or enquiries that reach the team.

The launch is treated as the finish. Many failure stories begin after go-live. Nobody owns the monitoring, the documentation was never written, or the team that built the system has moved on. A good pre-mortem keeps the whole lifecycle in view.

Why This Changes the Engineering, Not Just the Plan

A pre-mortem can sound like a project management exercise, but its effects show up in the code and the architecture.

If a team fears a third-party outage, it builds a fallback. If it fears a surge in traffic, it plans load testing early. If it fears a feature will be misused, it adds limits and clear messages before release. If it fears nobody will understand the system in a year, it writes decision notes and keeps the design simple enough to explain.

In this sense, a pre-mortem is engineering. It creates the conditions in which good engineering becomes possible.

The Honest Limits of the Exercise

A pre-mortem is not magic. It cannot predict every failure, and it can create false confidence if teams treat the list as complete. The discipline lies in revisiting it, not just at the start. We recommend a short review at each major milestone: which risks have passed, which have changed, and which new ones have appeared.

It also does not replace judgement. Some risks are accepted deliberately because avoiding them costs more than living with them. The value of the exercise is that those trade-offs are made consciously, by people who have looked at the problem honestly.

What This Says About How We Work

We believe the most valuable part of a software partnership happens before the first sprint. It lives in the questions that feel slightly uncomfortable, asked early enough that the answers are still cheap to act on.

A client who has run a pre-mortem with us usually leaves the room with more clarity and less certainty. That is a good trade. Certainty about the plan feels comfortable, but clarity about the risks is what keeps a product healthy once the launch excitement fades.

The question we keep returning to is simple: if this project failed, what would we wish we had asked on day one? If the answer is uncomfortable, that is exactly the conversation worth having now.


Planning a project and want to test it against the ways it could fail? Get in touch and we will set up a focused session with your team.