
A requirements traceability matrix is a table that links each requirement to the tests that check it and the defects that break it. Most teams build one for an audit, fill it in once, and never open it again, because the way it is usually built answers a question nobody asks twice: “is every requirement covered by a test?”
That question has a useful answer exactly once, before release. The question that comes up every week is the other way round, and it starts with a bug.
Two directions, and only one gets used
A traceability matrix can be read forwards or backwards.
Forwards, from requirement to test: does every requirement have something checking it? This is the direction templates are built for, and it is genuinely worth doing before a release. A requirement with an empty test column is a promise nobody is verifying.
Backwards, from a defect to the requirement it breaks: when a report arrives, which agreed behaviour does it contradict, and which test should have caught it? This is the direction that gets used daily, and most matrices make it hard, because the defect column was an afterthought.
- Weak
- A spreadsheet of requirements with a "Test case IDs" column, filled in for the audit and frozen the day it passed.
- Better
- The same rows, kept alive by the defects: every new bug is either linked to the requirement it breaks, or it exposes a requirement nobody wrote down.
The backward read is where the matrix pays for itself, because it settles an argument that otherwise has no referee. A defect is behaviour that contradicts something agreed. If a report cannot be traced to any row, it is not a bug in the agreed sense: it is either a new request or a gap in the requirements, and both of those deserve a different conversation than “fix it”.
The template
Five columns. Keep the requirement wording short enough to read in the table; the full text lives wherever your requirements live.
# Traceability matrix: [product or release]
**Last reviewed:** [date]
**Owner:** [who keeps this current]
| Requirement | What must be true | Test cases | Last result | Open defects |
| --- | --- | --- | --- | --- |
| [REQ-ID] | [the acceptance criterion, one line] | [TC-IDs, or NONE] | [pass / fail / blocked, and the build] | [bug IDs, or none] |
| [REQ-ID] | [the acceptance criterion, one line] | [TC-IDs, or NONE] | [pass / fail / blocked, and the build] | [bug IDs, or none] |
## Defects with no requirement
Reports that do not trace to any row above. Each one is either a new
request or a requirement nobody wrote down. Decide which, then move it.
| Defect | What happened | Decision |
| --- | --- | --- |
| [bug ID] | [one line] | [new request / missing requirement, and who owns it] |
The rows that tell you something
A matrix is mostly rows that say nothing: a requirement, two tests, both passing, no defects. The value is in four patterns, and it is worth reading the matrix for those rather than top to bottom.
A requirement with no test. Written NONE, deliberately, rather than left blank. A blank cell
reads as “somebody forgot to fill this in”; NONE reads as a decision, which it should be.
A requirement whose tests pass and which still has open defects. This is the most informative row in the table. The tests check something other than what the users are hitting, which usually means the acceptance criterion was too narrow or the test checks the happy path and the defects live in the starting state nobody named.
A test that traces to no requirement. Either it checks something that matters and the requirement was never written, or it checks something nobody agreed to and is costing time on every run.
The section at the bottom. Defects with no requirement are where scope arguments come from. A team that keeps that list visible has the argument once, early, with a decision recorded beside it. A team that does not has it in every triage meeting.
A test matrix is a different grid
The two names get used interchangeably and describe different things.
A traceability matrix is requirements against tests. A test matrix is tests against configurations: the same test case run across the browsers, devices and environments that matter, so a cell says “test 14 on Safari on an iPhone: failed”. It answers a different question, which is not “is this covered?” but “where does it break?”.
They meet in the defect column. A bug that fails in one cell of the test matrix and passes in the others is not a failed requirement, it is a failed configuration, and recording it against the requirement as if the requirement were broken everywhere sends the fix to the wrong place. The cross-browser testing guide covers how few configurations that grid actually needs.
Keeping it alive
A matrix built once is accurate for a week. The ones that stay useful are fed by something that happens anyway.
Tie it to triage rather than to the release calendar: when a defect is triaged, the person triaging it fills in the requirement it breaks, or adds it to the section at the bottom. That is a thirty-second step on a decision being made anyway, and it is the step that keeps the backward direction working. The rest of the table changes rarely: requirements when scope changes, test cases when the test case template gets a new case, results when a run happens.
The requirement column is only as good as the requirements. If they are adjectives, the matrix traces defects to sentences nobody can check. The acceptance criteria guide covers writing them so a defect can actually contradict one.
Where it meets a bug report
The backward direction only works if a report carries enough to trace. “The checkout is broken” traces to nothing. “Paying with a saved card fails with an error after the address step, in Safari, on an account with two saved cards” traces to a requirement, a test case, and probably a configuration cell the test matrix never ran.
Session Replay
Free Chrome extension. One click on the page that is misbehaving captures the screenshot, the console and the network log, and hands you a link to paste into the ticket.
The browser, the page, the steps and what came back from the server are what turn a complaint into a row in the matrix. The bug report guide covers the rest of what a report needs.
The short version
Link requirements to tests and to defects, and read it backwards: from a new bug to the
requirement it breaks. Write NONE where there is no test, on purpose. Keep a section for defects
that trace to nothing, because that is where scope arguments start. And keep a test matrix
separately, for the question of where a passing test fails.