Skip to content
Tutorials Center
My learning

Topics

Lesson 38 of 50 ยท Management, Risk and Professional Practice

Risk Management

Learn the risk management cycle for software projects: identify, assess, plan responses and monitor, with a risk register, a probability-impact grid and runnable scorers.

A risk is an uncertain event that, if it happens, affects a project's goals. The key word is uncertain: a risk has not happened yet. A server that is already down is an issue, not a risk. If you know a key developer is leaving in March, that is a fact to plan around. If there is a chance that she might leave, that is a risk.

Risk management is the habit of thinking about what could go wrong while there is still time to do something about it. It is cheap compared with surprises: finding out in week 2 that a vendor library does not support your platform costs a day, while finding out in week 20 can cost the project. Earlier lessons showed risk used to choose a process (spiral model and risk-driven development); this lesson covers the everyday process and tools, including the risk register that most projects keep.

The register and scoring below are done with JavaScript stand-ins, because a real project would use a spreadsheet or tracker. Everything in them is invented sample data, and the scores are conversation tools, not predictions.

The risk management cycle

The process has four repeating steps, and it never ends while the project runs.

flowchart LR
    I["Identify<br/>what could go wrong"] --> A["Assess<br/>probability and impact"]
    A --> P["Plan responses<br/>mitigate, avoid, transfer, accept"]
    P --> M["Monitor<br/>triggers and the register"]
    M --> I

The risk cycle. Monitoring regularly feeds new risks back into identification.

Four steps, on repeat

Identify List what could go wrong.
Assess Score probability and impact.
Respond Choose an action for each top risk.
Monitor Review the list every week.

A risk list nobody reads is just paperwork.

1 / 2

Step 1: identify risks

You cannot manage a risk you have not named. Useful sources of ideas are:

  • Checklists of typical software risks: unclear or changing requirements, unrealistic schedules, unfamiliar technology, performance targets, third-party dependencies, staff turnover, weak communication with the customer, security flaws, legal or regulatory changes.
  • Workshops with the whole team, where everyone is asked "what keeps you up at night about this project?". Developers, testers and operations people often see risks managers do not.
  • Lessons from past projects. A retrospective from last time is the best checklist.
  • Assumption review. Every assumption in the plan ("the payment provider's API will be ready by June") is a risk if it might be false.

Write each risk as a clear sentence of the form cause, event, effect: "Because the team has never used the new messaging service, integration may take twice as long as estimated, delaying the pilot." A vague entry like "technology problems" cannot be scored or acted on.

Step 2: assess risks

For each risk, estimate two things:

  • Probability: how likely is it to happen?
  • Impact: how bad is it if it does (schedule, cost, quality)?

Teams often use a simple 1 to 5 scale for each, and multiply them into a score (also called risk exposure, compare the numeric version from the spiral lesson). A score from 1 to 25 is easy to sort and to talk about. A probability-impact grid (also called a heat map) plots risks so that the top-right corner, high probability and high impact, is visible at once.

Be honest about what the numbers are. They are guesses made by people, with known biases (people underestimate risks in their own work and overestimate dramatic ones). Their value is that they force a discussion, and that the relative ranking is usually more reliable than the absolute values. Note also that a rare, catastrophic risk (low probability, impact 5) can deserve attention even though its score looks modest, so many teams look at impact separately as well as the product.

The risk register

The risk register is a living table. A good one has, for each risk: an ID, the description, probability, impact, score, an owner (one named person responsible for watching and responding), the planned response, a trigger (an early warning sign, such as "prototype benchmark exceeds 2 seconds"), and a status. The owner and trigger are what turn a list into a management tool.

This stand-in scores a sample register, sorts it and draws a simple grid.

JS Score and rank a risk register

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The two catastrophic-but-unlikely risks (R3 and R6) score MEDIUM and LOW in the table, though each has impact 5. A sensible team would add a rule such as "any impact-5 risk needs an owner and a written contingency plan, whatever its score". Scoring rules should serve judgment, not replace it.

Step 3: plan responses

For each important risk, pick one of four standard responses:

  • Avoid. Change the plan so the risk cannot occur. Drop a risky feature, choose a proven technology instead of a new one.
  • Mitigate. Reduce the probability or the impact. A prototype lowers technology risk; pair programming and documentation lower the impact of someone leaving; automated tests lower the impact of late changes. Mitigation costs something, so compare cost with benefit.
  • Transfer. Shift the consequence to a third party: insurance, a fixed-price contract with a supplier, a cloud provider's guarantee. The risk does not vanish, but someone else bears the loss.
  • Accept. Consciously decide to live with it, usually because it is minor or because action is too costly. Acceptance can be passive (do nothing) or active (set aside a contingency budget or time, and agree on a fallback plan to follow if the trigger fires).

Planned responses create new work, which must be scheduled and owned. A mitigation that is written in the register but not in the plan will not happen. A response can also bring new risks (secondary risks), for example choosing a mature technology avoids the learning risk but may bring licence cost.

A quick view of cost versus benefit

A response is worth buying only if it removes more expected loss than it costs. This stand-in, using numeric losses in person-days, compares the expected loss before and after each response and shows its net benefit. Compare it with the leverage calculation in the spiral lesson; it is the same idea in a register-friendly form.

JS Is the response worth it?

Press Run (or Ctrl + Enter) to see the console output here.

No output.

R3 shows a response that works on impact rather than probability: sharing knowledge does not stop a person leaving, but it shrinks the damage. R4 is a case where the cheap move is to accept the risk and keep a watch on the price.

Step 4: monitor and review

A register is only useful if it is reviewed, usually in a short weekly or per-iteration slot. In each review the team:

  • Checks whether any trigger has fired, and runs the contingency plan if so.
  • Re-scores risks as new information arrives. Good mitigations lower scores; slipping dates raise them.
  • Closes risks that can no longer happen, and records risks that did happen and became issues.
  • Adds newly identified risks.
  • Watches the overall picture: the number of high risks should fall over the life of the project. If it does not, the project is not retiring its dangers. This is the risk burn-down.

When a risk becomes real, it becomes an issue and moves to the issue log with an owner and a deadline, and the lesson goes into the retrospective.

Typical software risks and responses

Risk Typical response
Changing or unclear requirements Short iterations, frequent demos, a change control process (SRS and change control)
Unrealistic estimates Estimate ranges, track velocity, plan buffer (estimation)
New technology Spike or prototype early; fallback to a known option
Key person dependency Pair programming, documentation, code review (working in a team)
Security flaws Threat modeling, automated scans, security review (ethics, security and licensing)
Third-party dependency Contract terms, abstraction layer, monitoring of vendor health
Late integration Continuous integration, vertical slices (version control and CI)

Common mistakes

  • Listing risks once at the start and never looking again.
  • No owners. A risk everyone owns is owned by nobody.
  • Confusing risks with issues, or with vague worries that cannot be scored.
  • Only external risks, ignoring the team's own habits such as skipped testing.
  • Hiding bad news. A culture that punishes people for raising risks guarantees surprises.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Which of these is a risk rather than an issue?

    A risk is an uncertain future event. The other items have already happened, so they are issues.
  2. 2. A risk has probability 3 and impact 4 on 1-to-5 scales. What is its score?

    Score = probability x impact = 3 x 4 = 12.
  3. 3. Buying insurance against a data-center fire is which response?

    Transfer shifts the financial consequence to a third party. The risk of fire remains.
  4. 4. Why should every register entry have an owner and a trigger?

    Without an owner nobody acts. Without a trigger nobody knows when to act.
  5. 5. Why might a team still plan for a risk with probability 1 and impact 5?

    Multiplying can hide rare disasters, so many teams review high-impact risks separately.

Summary

  • A risk is an uncertain future event; once it happens it becomes an issue.
  • The cycle is identify, assess, plan responses, monitor, and it repeats for the life of the project.
  • Write risks as cause, event, effect; score probability and impact, but treat the scores as discussion aids.
  • A register records owner, response and trigger for each risk; responses are avoid, mitigate, transfer or accept.
  • A response is worth buying only if it removes more expected loss than it costs.
  • Review regularly and keep the culture safe for bad news.

Next: Cost Estimation Models.