Pre-Mortem vs Post-Mortem vs Risk Register: Which Fits When

Pre-Mortem vs Post-Mortem vs Risk Register: Which Fits When

Teams building web applications use several tools to think about things going wrong, and the names get muddled in conversation. A post-mortem, a risk register and a pre-mortem are not interchangeable, yet they are often treated as the same thing with different timing. This comparison lines them up so you can judge which one suits which stage of a project, and why the youngest of the three, the pre-mortem, deserves a slot before development begins.

The three tools in one paragraph each

The post-mortem happens after something has gone wrong. The team reconstructs the sequence of events, identifies contributing causes and records lessons. Its great strength is that it deals with facts. Its great weakness is that the damage is done by the time you hold it.

The risk register is a maintained list of known hazards, each with an estimate of likelihood and impact and an owner. It is a steady, administrative tool. It works well for risks someone has already thought of, and it says nothing about the ones nobody has.

The pre-mortem is a short workshop in which the team assumes the project has failed and writes down the reasons. It is not a register and not a review. Its job is to generate hazards, especially the uncomfortable ones that planning meetings tend to suppress.

A side-by-side look

  • Timing. The post-mortem looks backward, the register runs continuously, and the pre-mortem fits at planning and at each major milestone.
  • Input. The post-mortem uses evidence from an incident. The register uses known risks. The pre-mortem uses imagination, structured by a single premise.
  • Output. Lessons, a prioritised list, and a set of new hazards with owners, respectively.
  • Cost. The post-mortem is expensive because of what triggered it. The register is cheap but needs upkeep. The pre-mortem costs roughly an hour per session.
  • Risk of misuse. The post-mortem can turn into blame. The register can become stale paperwork. The pre-mortem can become a one-off ritual.

What the evidence suggests

It would be neat to claim measured superiority for one method. That would overstate what we know. The reasoning behind the pre-mortem is sound: research on planning shows that people produce more specific reasons for an outcome when they imagine it as already having happened. But most published support comes from practitioners describing their experience, not from controlled trials, so it is wise to treat the technique as a promising habit.

The honest comparison, then, is about complementary strengths rather than a winner. Each covers a gap the others leave.

Where each one falls short

  1. The post-mortem arrives late. It cannot prevent the failure it describes, only the next one.
  2. The register depends on the imagination of its authors. If the team shares a blind spot, the register shares it too.
  3. The pre-mortem produces unranked material. Without a follow-up step, it generates anxiety rather than action.

Seen this way, the combination is natural. Run a pre-mortem to find hazards, put the serious ones in the register with owners, and hold a post-mortem if something still goes wrong. The first feeds the second, and the third closes the loop by improving the next pre-mortem.

Applying the comparison to a web application project

Consider a team planning a custom web application. Their register might contain items such as “requirements may change” and “third-party service may be unavailable.” A pre-mortem pushes further. Imagining that the release failed, participants write notes such as “the staging environment did not match production,” “the migration script ran for longer than the maintenance window,” and “the only person who knew the deployment steps was unavailable.”

Those notes point toward earlier decisions about scope and requirements. A detailed article on drawing up engineering requirements for a web project covers how well-defined requirements reduce several of these failure routes, and a handful of prompts to settle before commissioning a custom build serves as raw material for the pre-mortem premise.

The delivery pipeline as a standing suspect

One theme appears in almost every web project pre-mortem: the path that carries code from a developer’s machine to production. If that path fails, the release fails, and if it is misused, the consequences can be worse. The blog at DevSecOps Now is largely devoted to securing CI/CD pipelines, and reading it alongside your own notes can help you phrase this theme precisely. In our comparison, the pipeline is a good example of a hazard the register may miss and the pre-mortem usually catches.

Choosing by situation

  • Before a project starts: pre-mortem, then register entries for the serious items.
  • During the project: keep the register current and re-run a short pre-mortem at each major milestone.
  • After an incident: post-mortem, with its findings fed back into the next pre-mortem prompts.
  • When choosing between two directions: use the pre-mortem on each option. The one whose imagined failures are cheaper to prevent may be the better path. For a framing of that decision, see this discussion of redesigning a site versus building an application.

Running a pre-mortem well

The quality of the session depends on a few practical choices. Keep it short, around an hour for a mid-sized project. Collect written notes silently before any discussion so loud voices do not set the agenda. Mix roles: developers, operations, testers and someone representing the customer. Close with a ranking and, crucially, owners and dates for the chosen items. A session that does not end with named owners has produced only a list of worries.

It is also worth recording what happened to each item after the project. Over several cycles you build a small body of local evidence about which imagined failures were real and which were noise. That evidence is more valuable than any general claim in an article, including this one.

Summary

The three tools are not rivals. The post-mortem teaches from failure that has occurred, the register tracks hazards that are known, and the pre-mortem hunts for the ones that are not. A project that uses only the first two is relying on hindsight and existing imagination. Adding the third costs little and widens what the team can see. If your next web project already has a register, schedule a pre-mortem beside it and compare what each produces. The differences will make the case better than any comparison table.