Key takeaways
- Product risks threaten the quality of what you ship. Project risks threaten the testing itself. Track both, but only product risks drive test design.
- Each product risk should map to a specific test response: a technique, a test type, a depth and an order.
- Run the highest risks first, and report progress as risk covered and risk remaining, not just the number of tests passed.
Where this picks up
You know that a test plan decides what to test and what not to. Risk-based testing gives you a reason for every one of those decisions.
The core formula is simple: risk level = likelihood × impact. This article is about applying it day to day. For building an organisation-wide strategy around risk, see Advanced risk-based testing.
Two kinds of risk
The ISTQB syllabus separates them:
| Product risk | Project risk | |
|---|---|---|
| Threatens | The quality of the product | The testing work and schedule |
| Examples | Wrong calculations, slow pages, data leaks, confusing screens | Late builds, unstable test environment, key tester on leave, supplier delays |
| Handled by | Testing: designing tests to find the problem | Management: plans, staffing, escalation |
Both belong in your risk list, but they lead to different actions. A late build doesn't need a test case. It needs a conversation about the schedule.
Finding product risks
Don't rely on one person's intuition. Combine several sources:
- Quality characteristics. Walk through the ISO 25010 list (functional correctness, performance, security, usability, compatibility and so on) and ask what could fail for each.
- Change. New code, rewritten modules and new integrations are where bugs are most likely.
- History. Defect data and production incidents show where problems have clustered before.
- Architecture. Integration points, data migrations and concurrency are classic risk hot spots.
- People. A short risk workshop with a product owner, a developer and someone from support finds risks no single role would see.
The risk register
Keep the risks in one simple table that the whole team can see:
| ID | Risk | L | I | Score | Test response | Status |
|---|---|---|---|---|---|---|
| R1 | Refund amount wrong for partial refunds | 3 | 3 | 9 | Decision table + boundary values; automated regression | Mitigated |
| R2 | Two admins editing one order overwrite each other | 2 | 3 | 6 | State transition tests + exploratory session | Open |
| R3 | Order history slow for customers with 1,000+ orders | 2 | 2 | 4 | Load test with large accounts | Planned |
| R4 | Typo in help texts | 2 | 1 | 2 | Accept; quick review | Accepted |
L = likelihood, I = impact, both on a 1–3 scale.
From risk to test response
The score tells you how much to test. The type of risk tells you how:
| Type of risk | Fitting test response |
|---|---|
| Complex business rules | Decision tables, boundary value analysis |
| Workflows and statuses | State transition testing |
| Many configurations | Pairwise or combinatorial testing |
| Unknown behaviour, new feature | Exploratory sessions with focused charters |
| Load and response times | Performance tests |
| Data exposure | Security tests, especially authorisation |
| Change to existing code | Targeted regression, ideally automated |
Higher scores get more techniques, earlier testing and independent review. Lower scores get a light touch or an explicit decision to accept the risk.
Reporting residual risk
"412 of 450 tests passed" sounds precise but doesn't help anyone decide. Report in terms of risk instead:
Payments: 3 high risks, all tested; no open critical bugs.
Loyalty points: 1 high risk still open (R7, points lost on cancelled orders). Recommendation: release with the feature switched off.
Order history: load test not yet run; medium risk accepted by the product owner for this release.
This lets the product owner make a release decision with their eyes open, which is the real purpose of testing.
A team had planned two weeks to test a new returns feature. A week before the start, the release date moved forward. They now had one week.
Because the plan was risk-based, the conversation took ten minutes. The team ran the four highest risks first: refund calculations, stock updates, payment reversal and fraud checks. Medium risks got one exploratory session each. Low risks were listed as "not tested this release", and the product owner signed off on that list.
Two serious bugs were found in refund calculations on day two. Nothing from the low-risk list caused problems in production.
Lesson: the risk list turned a stressful schedule cut into a clear, shared decision about what would and wouldn't be tested.
Keep the risks alive
A risk register written once and forgotten is worse than none: it gives false confidence. Update it when:
- a high-risk area passes its tests (likelihood goes down);
- a bug cluster appears (likelihood goes up);
- a production incident happens (you missed a risk, so add it);
- the scope or architecture changes.
Do
Agree the impact scores with the product owner. Impact is a business judgement, and their agreement makes later trade-offs easier.
Don't
Score every risk as high "to be safe". If everything is high priority, nothing is, and the register stops guiding decisions.
Check yourself
The test environment keeps crashing, so testing is two days behind. Is that a product risk or a project risk, and what do you do about it?
Show answer
It's a project risk: it threatens the testing, not the product's quality. The response isn't a test case. Raise it with the team lead, agree on a fix or more time, and meanwhile re-order testing so the highest product risks are covered first.
