Software Testing

Intermediate path · lesson 3 of 19

IntermediateStrategy5 min readPublished November 12, 2026

Risk-based testing

Risk-based testing decides what to test, how deeply and in what order, based on what could go wrong and how much it would hurt. Here's how to identify risks, turn them into tests and report the risk that's left.

On this page

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 riskProject risk
ThreatensThe quality of the productThe testing work and schedule
ExamplesWrong calculations, slow pages, data leaks, confusing screensLate builds, unstable test environment, key tester on leave, supplier delays
Handled byTesting: designing tests to find the problemManagement: 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:

IDRiskLIScoreTest responseStatus
R1Refund amount wrong for partial refunds339Decision table + boundary values; automated regressionMitigated
R2Two admins editing one order overwrite each other236State transition tests + exploratory sessionOpen
R3Order history slow for customers with 1,000+ orders224Load test with large accountsPlanned
R4Typo in help texts212Accept; quick reviewAccepted

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 riskFitting test response
Complex business rulesDecision tables, boundary value analysis
Workflows and statusesState transition testing
Many configurationsPairwise or combinatorial testing
Unknown behaviour, new featureExploratory sessions with focused charters
Load and response timesPerformance tests
Data exposureSecurity tests, especially authorisation
Change to existing codeTargeted 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.

Real-world exampleWhen the testing window was cut in half

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.