Chapter 3 · Planning and Risk
Risk Management
- Page 10 of 18
- 21 min read
On the previous page, Planning, Estimation and Scheduling, the ClinicQueue plan met its first surprise: registering with the SMS provider needed a document from the clinic, and the reminder task grew by 2 days. Lena used 1 day of the buffer and told Nadia early, so no harm was done. But the surprise was not really a surprise. Anyone who had asked "what could go wrong with the SMS provider?" in week one would have found it. A buffer absorbs problems you cannot name; risk management deals with the ones you can.
This page shows how a team finds what could go wrong, decides which of those things matter most, chooses what to do about each, and keeps watching. You will build a risk register for ClinicQueue, including a risk from the AI feature that drafts reminder texts, and score and sort it with a short Python script. Every risk and every number here is invented.
What you will learn
- The difference between a risk and an issue, and three kinds of risk: project, product (technical) and business.
- The four steps of risk management: identify, analyse (probability × impact), plan a response (avoid, reduce, transfer, accept) and monitor.
- How to build a risk register for ClinicQueue, including an AI-feature risk, and score and sort it in Python.
- How to spot early warning signs, how often to review risks, and why each risk needs one owner.
Risks and issues
A risk has not happened yet
A risk is an uncertain event or condition that, if it happens, would affect a project goal such as the date, the cost, the quality or the value to users. An issue is a problem that is already happening. The difference matters because you handle them differently: you prepare for a risk, but you solve an issue.
| Risk | Issue | |
|---|---|---|
| Time | Future: may or may not happen | Now: it has happened |
| Question | "How likely is it, and how bad would it be?" | "How do we fix it, and who does it by when?" |
| Where it lives | Risk register | Issue log or the team's task board |
| ClinicQueue | "The SMS provider may need paperwork that takes days" (week 1) | "The SMS provider needs the clinic's registration document; 2 days lost" (week 2) |
A risk that happens becomes an issue. Good risk management means fewer of your issues arrive as surprises: you saw them coming and had a plan ready.
Three kinds of risk
Sorting risks into kinds helps you search for them, because each kind has its own usual sources. These names are a common convention; different books group them slightly differently.
| Kind | What it threatens | ClinicQueue examples |
|---|---|---|
| Project risk | The plan: schedule, budget, people, suppliers | Farhan is ill in the launch week; the SMS provider is slow to approve the account; Nadia changes priorities late |
| Product (technical) risk | The software itself: correctness, performance, security, integration | Two patients book the same slot at once; patient data is exposed; the AI drafts a reminder with the wrong time |
| Business risk | The value of the product for the customer or organisation | Front-desk staff keep using the paper diary; patients do not trust online booking; running costs are higher than the clinic expected |
A finished, on-time product that nobody uses has failed just as surely as a late one. That is why business risks belong in the same list as technical ones.
The four steps of risk management
Risk management is a loop, not a one-time document. The four steps below are common practice in software teams.
Example:
+-------------+ +-------------+ +----------------+ +-------------+
| 1 Identify | --> | 2 Analyse | --> | 3 Plan the | --> | 4 Monitor |
| what could | | probability | | response | | triggers, |
| go wrong | | x impact | | avoid, reduce, | | review, |
+-------------+ +-------------+ | transfer, | | update |
^ | accept | +------+------+
| +----------------+ |
+--------------------- new risks, changed ratings -------------+1. Identify: what could go wrong?
Useful ways to find risks:
- Ask the whole team, separately first and then together, so that quiet people speak. Testers like Kwame are often best at it, because imagining failure is their job.
- Walk through the plan: for every task in the work breakdown and every dependency, ask "what would stop this?" The SMS registration risk is found this way.
- Check your assumptions. Every assumption ("the clinic has reliable internet", "Rina will use the screen") is a risk if it turns out false.
- Use a checklist from past projects: suppliers, key people, security, data, performance, adoption, legal and contract.
- Look at external parties: anything outside the team's control (a provider, the customer's decisions, the hosting company).
Write each risk as a clear statement, not a single word. A helpful pattern is cause → event → effect.
Example:
Weak: "SMS problems"
Better: "Because the SMS provider must approve each new sender (cause), our account may not
be ready before launch (event), so patients would get no reminders in week one
and miss more visits (effect)."The better statement tells you what to watch (the approval), what to do early (apply in week one), and how much it matters (missed visits).
2. Analyse: probability × impact
You cannot act on every risk with the same energy, so you rate each one. A common simple method gives two ratings on a scale of 1 to 5 and multiplies them:
| Rating | Probability (how likely in this project) | Impact (how bad if it happens) |
|---|---|---|
| 1 | Very unlikely | Hardly noticed |
| 2 | Unlikely | Minor: a few hours lost, easy workaround |
| 3 | Possible | Moderate: days lost, or some users affected |
| 4 | Likely | Major: launch delayed, or many users affected |
| 5 | Almost certain | Severe: harm to patients, data exposed, or the project fails |
Risk score = probability × impact, from 1 to 25. A grid shows where each risk sits:
Example:
Impact
5 | 5 10 15 20 25 HIGH score 12 or more, or impact 5
4 | 4 8 12 16 20 MEDIUM score 6 to 11
3 | 3 6 9 12 15 LOW score 5 or less
2 | 2 4 6 8 10
1 | 1 2 3 4 5
+------------------------------
1 2 3 4 5 ProbabilityThree warnings about these numbers. First, they are judgements, not measurements: a 3 means "the team thinks this is possible", so discuss the ratings together, as with planning poker. Second, the bands (12 or more is high, and so on) are a team's own choice, not a standard. Third, the product hides the shape of a risk: a data leak with probability 2 and impact 5 scores 10, the same as a nuisance with probability 5 and impact 2. That is why ClinicQueue's team adds a rule: any risk with impact 5 is treated as high, whatever its score. Harm to patients or exposed personal data is never "medium".
3. Plan the response: avoid, reduce, transfer, accept
For each important risk, choose a response. Four kinds are commonly used:
| Response | What it means | ClinicQueue example |
|---|---|---|
| Avoid | Change the plan so the risk cannot happen | Online deposits would bring card-payment security risks; leaving payment out of v1 ("Won't have this time", as Nadia chose on Project Management and the Roles in a Software Team) avoids them completely |
| Reduce (mitigate) | Lower the probability, the impact, or both | A database rule that rejects a second booking for the same slot, plus a test that tries it, makes double booking much less likely |
| Transfer | Move part of the impact to someone better placed to carry it, usually by contract or insurance | Use a hosting company whose contract includes daily backups and restores, instead of a server in the clinic's back office |
| Accept | Decide consciously to live with it, often with a fallback plan (a contingency) ready | If the clinic's internet is down for a morning, Rina works from a printed queue made at 07:30 each day |
Two points beginners often miss. Transfer does not transfer responsibility: if the hosting company loses data, the patients still blame the clinic, so Farhan still tests a restore once a month. And accept is a decision, not neglect: it is written down, with a reason (the response would cost more than the risk) and usually with a contingency plan.
A response has a cost, so choose it with the risk's score in mind. Spending a week to remove a low risk is a poor trade; spending an hour to halve a high one is a good one.
4. Monitor
Ratings change as the project moves. A risk can grow (a new test shows a problem), shrink (the response worked), happen (it becomes an issue), or pass (the SMS account was approved, so that risk can be closed). Monitoring is covered in its own section below, after the register.
A risk register for ClinicQueue
A risk register is the list where all of this is written down: one row per risk with its rating, response and owner. It can be a table in a document, a spreadsheet, or a page in the issue tracker. In week 2, after the SMS surprise, Lena and the team build one properly. The SMS paperwork is now an issue, so it goes to the task board, not the register.
The AI-feature risk
The feature that drafts reminder texts with an AI model deserves careful thought. A language model produces text that reads well, but it can still state the wrong date or time, mix up doctors, or add instructions the clinic never gave. A patient who trusts a wrong reminder comes on the wrong day. The feature is planned for a later release, but the team registers its risk now, and Kwame tries sample drafts with invented bookings. The team rates it probability 3 (possible) and impact 4 (major: patients miss visits) and chooses to reduce it:
- The date, time and doctor are filled in by ClinicQueue's own code from the booking, not written by the model; the model only drafts the friendly sentence around them.
- A person at the clinic approves each draft text before it is used, as planned from the start.
- Kwame keeps a set of sample bookings (late evening slots, long names, a holiday) and checks the drafts against simple rules: the time in the text must equal the booking time.
- Fallback: if anything looks wrong, the plain fixed template is sent instead.
The team also discussed avoiding the risk by dropping the AI feature. They kept it because the clinic wants friendlier reminders, and the reduce measures bring it down to a level Nadia accepts. Testing AI output is covered again on Software Quality, Testing and QA.
Scoring and sorting the register in Python
A spreadsheet can do this too, but a few lines of Python make the rules explicit and easy to check. The register is a list of dictionaries; the script scores each risk, applies the "impact 5 is high" rule, and prints the list with the most serious risks first.
# ClinicQueue risk register (invented). Probability and impact on a 1-5 scale.
register = [
{"id": "R1", "risk": "AI reminder text has a wrong date or time", "p": 3, "i": 4,
"response": "reduce", "owner": "Kwame"},
{"id": "R2", "risk": "Two patients book the same slot at once", "p": 2, "i": 4,
"response": "reduce", "owner": "Farhan"},
{"id": "R3", "risk": "Patient data is exposed", "p": 2, "i": 5,
"response": "reduce", "owner": "Farhan"},
{"id": "R4", "risk": "Only Farhan knows the backend", "p": 3, "i": 4,
"response": "reduce", "owner": "Lena"},
{"id": "R5", "risk": "SMS provider fails on the day", "p": 3, "i": 3,
"response": "reduce", "owner": "Farhan"},
{"id": "R6", "risk": "Front desk keeps using the paper diary", "p": 2, "i": 4,
"response": "reduce", "owner": "Omar"},
{"id": "R7", "risk": "Priorities change in the last week", "p": 3, "i": 2,
"response": "accept", "owner": "Lena"},
{"id": "R8", "risk": "Server failure loses bookings", "p": 2, "i": 5,
"response": "transfer", "owner": "Farhan"},
{"id": "R9", "risk": "Clinic internet is down for a morning", "p": 2, "i": 2,
"response": "accept", "owner": "Rina"},
]
def level(p, i):
"""Score = probability x impact. Any impact of 5 is treated as high, whatever the score."""
score = p * i
if score >= 12 or i == 5:
return score, "HIGH"
if score >= 6:
return score, "MEDIUM"
return score, "LOW"
def ranked(register):
"""Highest score first; equal scores keep the order of their ids."""
return sorted(register, key=lambda r: (-r["p"] * r["i"], r["id"]))
def show(register):
print(f"{'id':<3} {'risk':<42} P I score level response owner")
for r in ranked(register):
score, lvl = level(r["p"], r["i"])
print(f"{r['id']:<3} {r['risk']:<42} {r['p']:>1} {r['i']:>1} {score:>5} "
f"{lvl:<6} {r['response']:<8} {r['owner']}")
show(register)id risk P I score level response owner
R1 AI reminder text has a wrong date or time 3 4 12 HIGH reduce Kwame
R4 Only Farhan knows the backend 3 4 12 HIGH reduce Lena
R3 Patient data is exposed 2 5 10 HIGH reduce Farhan
R8 Server failure loses bookings 2 5 10 HIGH transfer Farhan
R5 SMS provider fails on the day 3 3 9 MEDIUM reduce Farhan
R2 Two patients book the same slot at once 2 4 8 MEDIUM reduce Farhan
R6 Front desk keeps using the paper diary 2 4 8 MEDIUM reduce Omar
R7 Priorities change in the last week 3 2 6 MEDIUM accept Lena
R9 Clinic internet is down for a morning 2 2 4 LOW accept RinaHow to read it: the four HIGH risks are discussed first at every review. R3 and R8 score only 10, but they are HIGH because of the impact-5 rule; sorted by score alone, they would hide below the AI risk and the key-person risk, and they are the two risks that could hurt patients' privacy and the clinic's records. R9 is LOW and accepted with the printed-queue fallback.
In the week 3 review, new information changes two ratings. Kwame's sample drafts showed a time in the wrong time zone, so the AI risk becomes more likely. Aiko has started reviewing and pairing on backend code, so the key-person risk is less likely.
# Week 3 risk review: new information changes two ratings.
updates = {"R1": 4, # test drafts showed times in the wrong time zone
"R4": 2} # Aiko now reviews and pairs on backend code
for r in register:
if r["id"] in updates:
old = level(r["p"], r["i"])
r["p"] = updates[r["id"]]
new = level(r["p"], r["i"])
print(f"{r['id']}: {old[0]} {old[1]} -> {new[0]} {new[1]}")
high = [r["id"] for r in ranked(register) if level(r["p"], r["i"])[1] == "HIGH"]
print("discuss first:", ", ".join(high))R1: 12 HIGH -> 16 HIGH
R4: 12 HIGH -> 8 MEDIUM
discuss first: R1, R3, R8The AI risk rose to 16 and is now the first item to discuss. The key-person risk fell to MEDIUM: the response is working. Because the list is re-sorted each time, the review always starts with what matters most now, not with what mattered in week 1.
Example:
# Each owner's watch list, so everyone knows which risks are theirs.
owners = sorted({r["owner"] for r in register})
for owner in owners:
ids = [r["id"] for r in ranked(register) if r["owner"] == owner]
print(f"{owner:<7}", ", ".join(ids))Farhan R3, R8, R5, R2
Kwame R1
Lena R4, R7
Omar R6
Rina R9The owner view reveals a problem the sorted list hides: Farhan owns four risks, two of them HIGH, while he is also the subject of the key-person risk R4. Lena moves R5 (SMS provider failure) to Kwame, who already tests the reminders. Spreading ownership is itself a way to reduce risk.
Watching risks: warning signs, reviews and owners
Early warning signs
An early warning sign (often called a trigger) is something you can observe before the risk happens that tells you it is getting closer. Writing it down turns "keep an eye on it" into a concrete check.
| Risk | Early warning sign | Action when it appears |
|---|---|---|
| R1 AI text wrong | Any sample draft fails a rule check; the approver edits more than one draft in ten | Stop using AI drafts, send the fixed template, fix and re-test |
| R4 Key person | A backend pull request waits more than a day because only Farhan can review it | Pair Aiko and Farhan on the next backend task |
| R5 SMS failure | The provider's delivery report shows failed messages; no delivery report by 18:00 | Front desk phones the next morning's patients from the unsent list |
| R6 Paper diary | In the test week Rina still writes bookings on paper "to be safe" | Omar sits with Rina for a morning and fixes what slows her down |
| R7 Late priority changes | Two or more change requests in one week | Lena and Nadia review the release scope together |
How often to review
A register that nobody opens is worse than none, because it gives a false feeling of safety. A simple cadence for a small team:
- Weekly: a ten-minute look at the HIGH risks and any warning signs, for example right after a stand-up or in the weekly status meeting. Changed ratings and new risks are added here.
- Every sprint or milestone: a full pass over the register in sprint planning or the retrospective. Close risks that have passed, and move risks that happened to the issue log.
- At big changes: a new feature, a new supplier, a new team member or a change of date. Each brings new risks.
- In the status report: the top risks and any risk that became an issue go in the "Risks and issues" line you saw on the project management page, so Nadia hears about them early.
One owner per risk
Every risk needs exactly one owner: the person who watches its warning signs, makes sure the response happens, and raises the alarm. The owner does not have to do all the work alone; they make sure it is done. This is the same idea as the single "A" in a RACI table. A risk owned by "the team" is owned by nobody. The owner should be close to the risk: Kwame for the AI text he tests, Rina for the internet at her own desk.
How much risk management is enough?
Practitioners differ. Some teams keep a detailed register with dates, residual ratings and costs for every response; this fits large, regulated or fixed-price projects. Others keep only a "top five risks" list on the team board and talk about it every week; this fits small agile teams. Short iterations also reduce some risks by themselves, because problems show up after weeks rather than months. You met a model built entirely around risk on Process Models: Waterfall, Incremental, RAD and Big Bang: Boehm's spiral model starts every cycle by looking at the biggest risks. For ClinicQueue, a one-page register reviewed weekly is about right. A useful test: if the register has not changed for a month while the project has, nobody is really managing risk.
Where this shows up at work
- Project proposals and freelance quotes often include a short "risks and assumptions" section; it explains in advance why a date might move.
- Before a release, teams ask "what could go wrong in production, and how would we notice?" The answers become monitoring and a rollback plan.
- Security, privacy and data-protection reviews are risk management with a narrow focus: what could be exposed, how likely, how bad.
- Teams adding an AI feature are increasingly asked to write down its risks (wrong output, private data in prompts, unfair results) and the human checks around it.
Common mistakes
- Writing the register once and never opening it again. Ratings go stale and new risks are missed. Fix: a short weekly review of the top risks, and a full review each sprint or milestone.
- Vague risk statements. "Technical problems" cannot be rated or acted on. Fix: cause → event → effect, specific enough to name a warning sign.
- Trusting the score blindly. A rare but severe risk can score lower than a common nuisance. Fix: look at impact separately and treat severe impacts (harm, data exposure) as high.
- Mixing risks and issues. Problems that are already happening sit in the register being "monitored" instead of being solved. Fix: once a risk happens, move it to the issue log with an owner and a date.
- No owner, or the same owner for everything. Nobody watches, or one overloaded person misses the signs. Fix: one named owner per risk, close to the risk, and spread across the team.
Try it yourself
- Easy: For each statement, say whether it is a risk or an issue, and whether it is a project, product or business risk/issue: (a) "Aiko may be moved to another client's project in month two." (b) "The booking page crashes on Rina's old browser; she cannot book walk-in patients today." (c) "Patients over 70 may find online booking too hard and keep phoning." (d) "The hosting price may rise at renewal."
- Medium: Using the 1–5 scales and the team's rules on this page, score these risks and give each a level (HIGH, MEDIUM, LOW) and a sensible response: (a) "The AI model's provider changes its terms and the feature must be switched off": probability 2, impact 3. (b) "A reminder is sent to the wrong patient's phone number, revealing a booking": probability 2, impact 5. (c) "Omar's usability tests find the booking flow too long, two weeks before launch": probability 4, impact 3.
- Hard: Dr. Rahman will take two weeks' holiday next month, and nobody has said how ClinicQueue should block his slots. Write this as a cause → event → effect risk statement, rate it, and add a full register row: response, owner, early warning sign and the action when the sign appears. Then say where it would appear in the script's sorted output and why.
Answers
- (a) Risk, project (people). (b) Issue, product: it is happening now, so it needs a fix today (for example a supported browser at the desk), not a rating. (c) Risk, business (adoption). (d) Risk, business (cost); some teams would call it a project risk because it affects the budget, which is fine if the reason is stated.
- (a) 2 × 3 = 6, MEDIUM. A good response: reduce, by keeping the fixed template as a fallback so reminders still go out if the AI feature is switched off; accept the rest. (b) 2 × 5 = 10, but impact 5 makes it HIGH: it exposes personal data. Reduce: phone numbers are confirmed when the patient registers, and the message contains only the clinic name and time, never the reason for the visit. (c) 4 × 3 = 12, HIGH. Reduce the impact by testing a paper or clickable prototype with patients much earlier, so the finding arrives in week one, not two weeks before launch. A good answer computes each score, applies the impact-5 rule in (b), and gives a response that changes probability or impact, not just "monitor".
- Model answer: "Because no one has defined how ClinicQueue handles a doctor's absence (cause), patients may book Dr. Rahman's slots during his holiday (event), so they would arrive and find no doctor, and the front desk would have to phone and rebook them (effect)." Probability 4 (likely: the holiday is certain and no feature exists), impact 3 (moderate: some patients affected, workaround by phone), score 12, HIGH. Response: reduce, by adding a simple "block these dates" screen for Rina before next month, or (if there is no time) by Rina blocking the slots by hand with a fake booking as a stopgap. Owner: Lena (she can get the story into the next sprint and agree it with Nadia). Early warning sign: the holiday dates are known and two weeks before the holiday the blocking feature is not in testing. Action: switch to the manual stopgap and tell Nadia. Added to the register after the week 3 review as R10, it would be listed second: after R1 (16) and before R3 and R8 (10), because the script sorts by score first and uses the id only to break ties. A good answer has a full cause → event → effect statement, a computed score with level, one owner, a concrete trigger with a date or number, and an action.
Summary
- A risk is an uncertain future event that would affect a project goal; an issue has already happened. Risks can be project, product (technical) or business risks.
- Risk management is a loop: identify, analyse with probability × impact, plan a response (avoid, reduce, transfer, accept) and monitor.
- Scores are team judgements; look at impact separately so that rare but severe risks, such as exposed patient data or a wrong AI reminder, are not hidden.
- A risk register lists each risk with its rating, response, owner and early warning sign; a few lines of Python can score, sort and re-sort it after each review.
- Review the register regularly, give every risk exactly one owner, and move risks that happen to the issue log.
Next: Software Design Basics: From Requirements to Modules: how the ClinicQueue team turns its requirements into a structure of modules that is easy to build and to change.

