Trace Items — Requirements, Risks & Risk Controls¶
Audience: authors of specifications, risk analyses, and design documents.
LQMS lets you trace at a finer grain than "document → document". A requirement, a risk, or a risk control is a keyed block inside a controlled document — not a separate register, not a linked ticket. Once a block has a key it can be linked, counted for coverage, and walked in the traceability views (see trace-links and the traceability workspace).
The design choice that makes everything else simple: the document's lifecycle IS the item's lifecycle. A requirement is draft/in-review/released/superseded exactly as the document version that defines it is. There is no separate item state to manage, no item to approve on its own, no way for the register and the document to disagree — because they are the same thing.
1. What a trace item is¶
A trace item lives in the document's content, right where you write about it. It carries:
- A key — the stable identifier (e.g.
SSRS_API_012,RISK-004,RC-002). The key is what links point at and what the coverage views count. - A short type-specific attribute set (below) — fixed per type, no custom fields.
- A body — the normal rich text of the block: the requirement's statement, the risk's narrative, the control's description.
Identity and history are derived, never managed. LQMS tracks the block's content across document versions by its content hash — "this requirement changed in v6" simply means its hash differs from v5. You never set a version number on an item or move it through states by hand.
A key is unique within its scope and defined in exactly one document. Moving a definition to another document is a deliberate act (remove it from one draft, add it to another) — both under document review. Links to an item may originate anywhere; only its definition is single-homed.
What a project declares, and which documents may define it. The product ships a catalog of element kinds — the eight above — and knows what each one means: that a risk control mitigates a risk, that a user need is satisfied through a system requirement, that a stakeholder requirement is resolved by one. A project then declares which of them it uses, what it calls them (naming conventions differ between organisations, so the catalog name is a starting point), and the key prefix its items are minted from. That is one row per kind in the setup wizard's Special elements section — see special elements for the whole story, including the freeze that locks a name and its prefix together once the first item exists, and the pairing: risks and risk controls come as a pair, because a control exists to reduce a risk.
Which documents may define which items is decided per project, per document type, per kind — on that same row, as the "document types that may define it" selection, and equally on the Scope configuration → Document types tab (the gear menu), where each activated type carries its row of may-define switches: May define requirements, May define stakeholder requirements, May define risks, May define risk controls, May define user needs, May define validation cases, May define design elements, May define regulatory references. One model, two places to read it from. A type is enabled only for the items it should author: specification types define requirements and user needs, risk-analysis types define risks and risk controls, design documents define design elements, a Validation Plan defines validation cases, a GSPR / applicability matrix defines regulatory references. This is deliberate — a record type (a form, a log, a report) is not allowed to start minting requirements.
A project can leave this half-done in three ways, and its setup check names each: a type may define a kind the project never declared; a declared kind no type may define; or a kind in use whose prerequisite kind is not (risk controls with no risks is loud — nothing can ever be mitigated; risks with no controls is a quieter note, because accepting a risk without reducing it is legitimate).
(Project-local custom kinds — an assumptions register, a SOUP inventory — are a planned later step: keyed and citable, but deliberately outside derived traceability and marked as such.)
This is why the insert menu can look "empty". The slash blocks in §2 (and the table toggles in §6 and §8) appear only for the item types the current document's type may define in this scope. If you open a draft and a block you expected is missing from the
/menu, the document's type is simply not enabled for that item here — that is governance working as designed, not a bug. The remedy is in Scope configuration: a quality manager turns on the matching May define… switch for that type, and the block appears when you reopen the editor. (If the kind itself was never declared by the project, the switch alone is not enough — the setup check says so, and the setup wizard's Special elements section is where the declaration is made.)
2. Authoring an item in the editor¶
In the draft editor, type / and pick the block:
- System requirement — opens the New requirement dialog.
- Stakeholder requirement — opens the New stakeholder requirement dialog (§3.1).
- Risk — opens the New risk dialog.
- Risk control — opens the New risk control dialog.
- User need — opens the New user need dialog (Stage C — §7).
- Validation case — opens the New validation case dialog (§7).
- Design element — opens the New design element dialog (§7).
- Regulatory reference — opens the New regulatory reference dialog (§7).
Only the blocks the document's type may define in this scope are offered (§1) — the list you see follows the may-define governance, not a fixed menu.
Each dialog has a Suggest button next to the Key field that fills in the next free key using the scope's prefix convention (so keys stay consistent and collision-free). Uniqueness is checked against the scope when you save; a clash is rejected with a clear message.
To change an item later, open its block and use Edit (requirements show their kind/priority as chips with a Details expander for rationale and acceptance criteria). Editing an item is a content change, so it follows the normal rule: you edit items on a draft, and a released item is changed by revising its document.
Pre-save authoring (on the create form)¶
Unlike diagrams, trace items do not require you to save the draft first. Every trace-item slash
block — /requirement, /stakeholder requirement, /risk, /risk control, and the four Stage C
blocks (/user need,
/validation case, /design element, /regulatory reference) — is available on the create form,
before the document's first save, whenever the chosen type and scope allow that item. This means you
can lay a specification's keyed requirements — or a risk analysis's first rows, or a stakeholder
document's user needs — into the very first draft as you write it, and they are persisted with the
initial save. (The set of offered items follows the type you pick in the create form; change the type
and the offering updates.)
3. System requirements — the fixed attribute set¶
| Field | Meaning |
|---|---|
| Key | Stable identifier, unique in scope. Use Suggest for the next free key. |
| Kind | Fixed vocabulary: Functional, Non-functional, Safety, Other (or unset). Drives the coverage view's kind filter. |
| Priority | A short free-text token in your project's own priority language (e.g. must, high). |
| Rationale | Why the requirement exists. |
| Acceptance criteria | How you will know it is met. |
There is no custom-attribute engine — the set is fixed on purpose. The key hint in the dialog states the rule you are living under: "Unique within the scope; defined in exactly one document."
The item is called a system requirement because a device that is not software still has requirements of its system, and for a pure-software product the system is the software. A supplier project working under IEC 62304 usually renames it Software requirement for its own people — the name is the project's (see key rules §0); what the system derives from it is not. Software and architecture requirements typically carry Functional, Non-functional, or Safety.
3.1 Stakeholder requirements — the level above¶
A stakeholder requirement is its own item type, not a system requirement wearing a label. It is the specification-lane input at the top of the V — what any stakeholder requires (not only the clinical user: service, regulatory affairs, the business) — and it is distinct from a user need, which is the validation lane; the difference is verification vs. validation, spelled out in §7.2.
Its slash block is Stakeholder requirement and its dialog carries the same fields as a system
requirement minus Kind: a type that is the level needs no attribute saying so. Its default key
prefix is STK-, and its own may-define switch governs which document types may write one — typically
a Stakeholder Requirements specification, which usually also defines the user needs beside them.
The requirement chains view reads the type — stakeholder requirements are the top of each chain (see traceability-workspace §3), resolved downward by the system requirements that Satisfy them.
4. Risks — the recorded score, not a computed one¶
A risk block mirrors one row of an ISO 14971 risk table: a hazard, the hazardous situation that exposes someone to it, and the harm that may result. The New risk dialog captures:
- Hazard, Hazardous situation, Harm — the three-part risk statement.
- Initial risk — the pre-control estimate as tokens: Severity (S), P1 (situation), P2 (harm), and Level.
- Residual risk — after controls — the same four tokens for the post-control estimate, in a subsection you fill in once mitigating controls are linked.
- Acceptability (current evaluation) — Acceptable / Not acceptable / Not evaluated.
The two-factor probability (P1 = probability the hazardous situation arises, P2 = probability it then leads to harm) is the ISO 14971 shape. The narrative — sequence of events, justification — goes in the block body.
The tool records; it does not compute. LQMS never multiplies S × P or derives a level from your tokens. As the risk dialog states: "Recorded per your risk-scoring scheme (a controlled document) — the tool records, it does not compute." Your scoring scale and how a level is reached live in content — your Risk Management Plan / risk policy — not in the tool. That is why the score fields accept the tokens your scheme uses (a 3×3 scale, a 5×5 scale, qualitative labels — all fine) and why a score renders as tokens like
S3 · P1 · P2 — High, never as an equation.
Acceptability is the current evaluation, not a residual-only field. It always shows, even before any residual score. An initial risk you judge Acceptable with no control and no residual is complete — "accepted without reduction" — and the traceability views treat it as such, not as a gap (ISO 14971 does not require reducing a risk that is already acceptable). See traceability-workspace §4.
Implementation and verification of a risk are not attributes — they are links (a control
mitigates a risk; the control is implemented-by something and verifies-d by evidence). See
trace-links.
5. Risk controls¶
A risk control is a measure that reduces one or more risks. Its only fixed attribute is the Control kind (ISO 14971 §7.1) — the standard's priority order:
- Inherent safety by design
- Protective measure
- Information for safety
(or Unspecified). This vocabulary is fixed because it is normative — it comes from the standard, not from a project preference. The control's description goes in the block body; what it mitigates, what implements it, and what verifies it are all links.
6. The risk table — a grid over the same blocks¶
Risk-analysis work is table-native, so a risk-defining document offers a Risk table toggle
("Switch between prose and a risk table over the same content."). This is the key thing to
understand: each row of the grid IS a :::risk block in the document. The grid is a view and
controller over the very same content the editor holds — there is no second record and no parallel
copy:
- Add risk inserts a new risk block; editing a cell edits that block's attribute; Delete removes the block from the document ("Delete risk {{key}}? This removes the risk block from the document.").
- Columns are the fixed attribute set — Key, S / P1 / P2 / Level (initial and residual), Acceptability — plus Derived (from links) columns that are read-only: Controls, Impl. by, Verified by, and Gaps. Those derived columns are the same derivation as the risk traceability view, scoped to this document — you author the risk in the grid and see its coverage build up as you add links.
- The same grid renders read-only on a released version's detail — that is the risk table an auditor reads, alongside the narrative body.
The single-item Risk dialog and risks embedded in narrative sections stay first-class; the grid is an additional surface over the one document, not a replacement. Everything you author either way is one and the same tree.
7. The Stage C item types — validation & regulatory axes¶
Stage C (ADR-0084) adds four more trace-item types so the whole V-model is traceable at item level, not just requirements and risk. They are authored exactly like the types above — a keyed block, a small fixed attribute set, a body — and each is gated by its own may-define switch (§1).
| Item type | Slash block | The role it plays | Typically defined in |
|---|---|---|---|
| User need | User need | The top of the V — "the right thing" the device must do for its user | Stakeholder Requirements |
| Validation case | Validation case | A validation activity — proof you built the right thing | Validation Plan |
| Design element | Design element | The design "how" — architecture / interface / component / unit | Software Design |
| Regulatory reference | Regulatory reference | One GSPR / essential-principle / standard clause the scope claims | GSPR Applicability Matrix |
The "typically defined in" column is the shipped default governance for the SAMPLE demo scope; your own scope decides its mapping in Scope configuration.
7.1 User needs¶
A user need captures a stakeholder's need at the top of the V-model — the input the design must ultimately satisfy and that validation must confirm. The New user need dialog captures one fixed attribute:
- Source — a short free-text token naming the stakeholder the need comes from (e.g. Clinician, Biomed). The need statement itself is the block body.
The key hint reads "Unique per scope (e.g. UN-001)." User needs are the rows of the Validation matrix (see traceability-workspace §7) and the target of the Validates link (see trace-links §6). How a user need differs from a stakeholder requirement — the two lanes — is the next section.
7.2 Stakeholder requirements vs. user needs (verification vs. validation)¶
A recurring question: what is the difference between a stakeholder requirement and a user need — is this verification versus validation? They sit at the same end of the V-model, but they belong to two different lanes, and LQMS keeps them apart on purpose.
A stakeholder requirement is the specification lane. It is its own item type — a
:::stakeholder-requirement block (§3.1) — stating what the product must do, raised by any stakeholder:
not only the clinical user, but service, regulatory affairs, or the business. A stakeholder requirement
is decomposed — a system (or architecture) requirement Satisfies it, and that requirement is in
turn verified by evidence (a Verifies link from the evidence document). This is the "did we
build the product right?" question, and it is exactly what the Requirement chains view walks
(stakeholder requirement → satisfying system requirement → verification evidence), each stakeholder
requirement being the top of one chain. Depth:
the traceability workspace §3.
A user need is the validation lane. It is a :::user-need block stated in the terms the user
uses (its Source names whose need it is), and it is deliberately not decomposed into software
requirements. A user need is confirmed by validation — a Validates link from a validation case
or a released validation record — checking the finished device against the need in its real use
context. This is the "did we build the right product?" question, and it is what the Validation
matrix view reads (see traceability-workspace §7).
The distinction is precisely verification vs. validation, and the norms frame it that way. IEC 62304 governs the software requirements-and-verification chain (the stakeholder-requirement lane); ISO 13485 §7.3.6 (design and development verification) and §7.3.7 (design and development validation) name the two as separate design-control activities — verification shows the output meets the input, validation shows the product meets the user's needs and intended use. You verify a stakeholder requirement through its satisfying system requirements; you validate a user need against the working device.
In practice the two lanes overlap, and that is correct, not duplication. A user need is often restated as one or more stakeholder requirements so the design can be specified and verified against them — while the original need still stands in the validation lane to be validated in use. Both lanes then legitimately apply to the same underlying need: it appears once as a user need (a row of the Validation matrix) and again as a stakeholder requirement (the top of a Requirement chain). Keeping the two item types distinct is what lets a project prove both that it built the product right (chains) and that it built the right product (validation) — the whole point of the V.
7.3 Validation cases¶
A validation case records a validation activity — the evidence that the device does the right thing for its user (validation), as distinct from meeting its written requirements (verification). The New validation case dialog captures one fixed attribute:
- Intended-use reference — free text pointing at the intended use / user need the activity validates (the load-bearing linkage is the Validates link, not this field).
The case narrative is the block body. A validation case — or a whole Validation Plan / Validation Report document — Validates a user need; that link, and its planned-vs-verified class, is what the Validation matrix reads.
7.4 Design elements — and the per-scope Design kinds vocabulary¶
A design element is a unit of the design "how" — the architecture, an interface, a component, a unit. It sits below requirements in the V: a design element Satisfies a requirement (see trace-links §1). The New design element dialog captures one fixed attribute:
- Design kind — a value chosen from the scope's configured vocabulary. The shipped default set is Architecture, Interface, Component, Unit (plus Unspecified).
Unlike the risk-control kind — fixed because it is normative (ISO 14971 §7.1) — the design-kind vocabulary is a per-scope configurable list, because design taxonomies genuinely differ between projects. It is edited in Scope configuration under Design kinds: "The vocabulary a design element's kind is chosen from in this scope. Leave empty to use the default (architecture, interface, component, unit)." Add a value with New design kind, Remove ones you do not use, and Save design kinds. A scope that has not customised the list shows "Using the default vocabulary (architecture, interface, component, unit)." The design-element dialog then offers exactly that scope's set, and the server validates the chosen kind against it.
7.5 Regulatory references — GSPR / essential principles¶
A regulatory reference is one clause of a regulation or standard the scope claims conformity to —
a General Safety and Performance Requirement (GSPR) from MDR Annex I, an IEC 62304 clause, and so on.
A scope's conformity "checklist" is simply a controlled document holding one :::regulatory-ref block
per clause. The New regulatory reference dialog captures four fixed attributes, in this order:
- Source — a free-text token naming the regulation/standard (e.g.
mdr-annex-i). - Clause — a free-text token naming the clause (e.g.
10.1). - Applicability — Applicable or Not applicable. A new clause is born Applicable — the honest "all applicable, mark the exceptions" default.
- Justification — free text. It may be left empty while authoring, but an unjustified Not applicable is flagged (see §8 and the conformity view).
The regulation text itself is never tool data — LQMS ships the type and the conformity view, not the standard (a deliberate licensing boundary). To help you author a GSPR checklist there is a paraphrased MDR Annex I skeleton — clause numbers plus one-line house paraphrases only — at docs/regulatory/mdr-annex-i-skeleton.md; consult the MDR itself for the authoritative wording. A requirement (or a design element) Complies with a regulatory reference; that link is what the GSPR conformity view reads (see traceability-workspace §8).
8. The GSPR table — a grid over the regulatory-ref blocks¶
A GSPR / applicability matrix is intensely table-native (one row per clause), so — exactly like the
risk table (§6) — a regulatory-ref-defining saved document offers a GSPR table toggle
("Switch between prose and a GSPR conformity table over the same content."). Each row of the grid
is a :::regulatory-ref block in the document; the grid is a view over the same content, not a
second record. Its columns are the fixed attribute set — Key, Clause, Source,
Applicability, Justification:
- Add clause inserts a new regulatory-reference block (born Applicable); editing a cell edits that block's attribute; Delete removes the block ("Delete {{key}}? This removes the regulatory-reference block from the document.").
- A row whose applicability is Not applicable with no justification is flagged inline as N/A without justification — "A not-applicable clause needs a justification — this is a hard gap in the conformity view." This is your early warning, right in the authoring grid, of the hard gap the conformity view will raise.
- On a released version the grid renders read-only as the GSPR conformity checklist — the clause table an auditor reads alongside the narrative body.
Unlike the risk table, the GSPR grid has no derived (from links) columns — the conformity roll-up lives in the workspace GSPR conformity view (see traceability-workspace §8), not in the authoring grid.
Governing decisions: ADR-0077 (requirement items — keyed blocks, scope-unique keys, derived identity, definition governance), ADR-0078 (generalized trace items — one substrate, per-type attribute schemas), ADR-0079 (risk & risk-control items — the recorded-score model, P1/P2, acceptability, normative control kind), ADR-0082 (table-shaped risk authoring — grid over the risk blocks), ADR-0084 (Stage C — the user-need / validation-case / design-element / regulatory-ref types, the per-scope design-kind vocabulary, the GSPR authoring grid). Presentation honesty: conventions.md "Presentation honesty" (record vs compute). Standards: ISO 14971 (risk), MDR (2017/745) Annex I (GSPR).