Tutorial — from zero to a released document¶
Audience: a brand-new user, following along on a running demo stack. No prior LQMS knowledge is assumed beyond being able to log in.
This is a hands-on tutorial, not a reference. You will follow a single project from the moment it is registered, through configuration, authoring, review, release, training, traceability, and a recurring operational duty — doing each step yourself and checking the result before moving on. Every part ends with a ✔ Checkpoint so you always know whether you are on track. The reference chapters (linked from each part and from the README) carry the depth; this tutorial walks the happy path.
An honest aside about this document. This tutorial lives in the repository today, as a Markdown file. It is a candidate to become a controlled training document inside LQMS later — brought in the same dogfooding way the early controlled-vocabulary drafts were, so that "learn to use LQMS" is itself a released, acknowledged QMS document. Until that happens it is uncontrolled repo documentation. Nothing below depends on that move.
Before you start — the demo stack, the personas, the project¶
You need a running demo instance and its address — most readers get both from whoever operates their stack: ask for the URL and the demo credentials, open it, and you will be redirected to the login page.
Running the demo stack yourself (operators with a source checkout only): deploy/DEMO.md
carries the two commands and the host prerequisites; the app then answers on
http://localhost:8080/.
You will switch between four seeded people. Each is a real login; to change persona, open the user menu (your name, top right) and Log out, then log in as the next one.
| Persona | Login / password | Their part in this tutorial |
|---|---|---|
| Quality Manager | carla.fischer / carla |
configures the project; staffs people (also a User Administrator) |
| Document Author | ben.keller / ben |
writes drafts, submits them, authors trace links |
| Quality Reviewer | anna.sommer / anna |
reviews, approves and releases (the second pair of eyes) |
| Administrator | demo / demo |
the system administrator — note admin ≠ content: they manage the role catalog but see no project documents |
The project you will work in. In Part 0 you register a project of your own. From Part 1 on, the
hands-on steps run in a project the demo world already carries — Cardio Monitor (code
MEDTECH-CARDIO), a software project — because the later lessons need content that is already there.
Treat it as the project you just registered. Two other seeded projects appear where they show a
feature best and you will only observe them:
- SAMPLE — a compact ISO 14971 / IEC 62304 teaching corpus with a complete item-level trace chain already built (Part 5).
- QMS-OPS — the internal operations QMS, which carries a ready recurring obligation (Part 6).
Wherever the demo stack already contains something this tutorial would have you create, a > On the demo stack note tells you to skip or just observe.
Part 0 — Register a new project¶
Manual topics: How a new organization and project are born · The setup wizard's lanes
In LQMS a project is a scope: a strictly separated space that holds one project's documents, records, roles and configuration. Every project belongs to an organization — the customer or company the work is done for, and the hard boundary between one tenant's data and another's. Both are created in the app, and that is what you are about to do: found an organization and register a project inside it, before you spend six parts working in that project.
They are two acts, deliberately. Founding an organization creates a separation boundary — its own space, its own membership, its own permanent trail — and starting a project is routine work inside a boundary that already exists. The app keeps them apart so the first can never happen as a side effect of the second.
Log in as carla.fischer. On this stack she is also a User Administrator**, which is what
lets her found an organization, create a project and staff people into it.
- Click Admin in the top bar. → The left sub-nav lists the governance surfaces, and the two acts of this part are two separate entries in it: Project setup and Found an organization. That separation is the point — you cannot wander into founding a customer while doing routine work.
- You need a customer of your own first, so click Found an organization. → A page of its own opens, and before it asks anything it states what founding creates: its own space, its own membership, its own audit trail.
- Type
Muster Diagnostics AGinto Organization name and click Found the organization. → It exists, and the page says what that means: "It has no project and nobody in it yet" — both are separate next acts. Click Set up its first project, the first of the two beats offered. - The project wizard opens on its Project step, already in the The new project block, with the boundary stated at the top: "This project will belong to: Muster Diagnostics AG". (The wizard is subtitled "Set a project up in four steps — the house-validated configuration, editable before it is written." All four steps — Project, Lane, Configuration, Apply & verify — are listed from the start, so you see the whole checklist instead of meeting it one screen at a time. Nothing is written until the last step, so you can go back and change anything on the way.) Fill in the rest:
- Project code — a code of your choosing, e.g.
PULSE(the field upper-cases as you type). Read its hint: "Unique and immutable; it prefixes every document id in this project." Take that literally, because this is the one entry nobody can correct later: withPULSE, the first SW requirement you write here is calledPULSE-SWREQ-001— and that name is what every export, cross-reference and audit trail will carry from now on. - Project name —
Pulse Analyzer, or whatever you like. The form asks for nothing else, and says so: it does not ask whether the project keeps its own records (that follows from the project type) nor whether it may be a derive source — the latter is a governed setting on an existing project, set later on the project's own configuration page (or under Admin → Scopes), not a birth-time choice. A brand-new project is not one anyway: base procedures are derived into a project from the operating organization's own, not out of a fresh one. Click Next.
Why the boundary is never quietly filled in. The organization a project belongs to is the one thing here that can never be corrected later, so the wizard only ever asks for it when there is a real choice and always states it before you commit. Where several organizations exist, the picker has no default and Next stays disabled until you choose — "Pick the customer this project belongs to — there is no default, and it cannot be changed later." Where only one does, or where you arrived from the founding workflow as you just did, there is no question to answer, but the binding is stated as a fact in front of you. And founding a second organization under a name that already exists is refused rather than quietly adopted: two customers collapsing into one tenant is exactly the failure the boundary exists to prevent.
- Step Lane asks what kind of scope this is. Three cards, differing in kind rather than degree:
- Supplier lane (IEC 62304) — "Software supplier: requirements, design, tests and the risk file — verification against the customer's requirements. No validation or GSPR axis."
- Manufacturer lane (ISO 13485) — "Legal manufacturer: everything the supplier lane carries plus stakeholder needs, the validation axis and the GSPR applicability matrix."
- QMS / process scope (ISO 13485) — "The organisation's own QMS: SOPs, work instructions, templates and records — no product traceability." Pick Supplier lane (IEC 62304) for this lesson, then Next. (How to choose for a real project — and why the manufacturer lane is the safe answer when you are torn between the two product lanes: The setup wizard's lanes.)
The lane is a starting proposal, not a label you are stuck with. It decides which document types, special elements and folders the next step suggests — all of them editable before anything is written.
- Step Configuration opens pre-filled: "This is the proposal, not a decision: everything below is editable before anything is written." Work down it:
- Roles — three questions in plain words: Who authors documents in this project?, Who reviews them?, Who manages quality? Here they resolve to Document Author, Quality Reviewer and Quality Manager; because a new project carries no roles yet, the dropdown marks each of them will be activated, and the list below the three questions names exactly those — with Remove per row and Also activate a role if you need a fourth.
- Staff yourself now — confirm Quality Manager is ticked (it already is; tick any other role you mean to work in). Do not clear it; the paragraph after this list says why.
- Document types and their policies — one expandable panel per proposed type, each carrying its four-eyes toggle and its workflow grants (Authors (may submit) / Reviewers (must approve) / Releasers (may release)). At the foot of each panel a quiet line states what that type will be allowed to mint — Defines: Risk, Risk control on the Risk Analysis panel, Defines no special elements on most of the others. It is a statement, not a control: the decision behind it is made one section further down. Leave the proposal as it stands — Part 1 is where you learn to change it.
- Folder skeleton — leave Create these folders ticked (Procedures, Requirements, Design, Verification, Records for this lane).
- Special elements — the keyed things this project traces. Every kind the product knows is listed, grouped by what it is for (Requirements and design, Risk management, Validation, Regulatory); the four this lane uses are already ticked (Software requirement, Design element, and Risk & Risk control, which is one tick for two kinds). Each ticked row carries the name in this project — Software requirement, say, with the product's own default ("System requirement") named underneath; change it if your people say Systemanforderung — the key prefix (REQ-, DE-, RISK-, RC-, each showing the key it would mint first: First key: REQ-001), an Add a category button, and the document types that may define it — that last one is the relationship the panels above only report. Two things are worth reading rather than clicking past. Under Risk management: risks and risk controls come as a pair — they share one tick (Risk & Risk control), because a control exists to reduce a risk, so this project uses both or neither. And under the whole section: a name and a prefix are free to change until this project mints its first item of that kind, and frozen together after that, because existing keys are never renamed. Try it if you like — tick Validation case and watch User need switch itself on, saying which kind brought it ("Activated together with Validation case, which needs it.") — then untick both again: unticking the case does not take the need back off, and a kind left on with no document type allowed to define it says so in its own warning line. Depth: Special elements. Click Next.
Why "Staff yourself now" is not optional in practice. Activating a role makes it bindable in the project — it staffs nobody. So a project born ten seconds ago contains no people at all, its creator included, and a project's own configuration is gated inside that project. Without the checkbox the run would create your project and then hand its review policies, folders and acknowledgement policies back to you as work to come and do later. The section states the reason itself: "Activating a role staffs nobody, so a brand-new project leaves even its creator holding nothing in it." Ticking it puts a Staff yourself act into the plan right after the role activations, so everything it unlocks runs in this same pass.
- Step Apply & verify lists the plan one act at a time — the project (naming the organization it will belong to, in words), each role activation, Staff yourself, each document-type activation and what it may define, the folders, the special elements. The organization is not in this plan: you founded it a few minutes ago, in its own act. The review policies are not in it yet either, and that is the staffing bridge at work: you hold nothing in a project that does not exist, so the run derives the rest of the plan again the moment Staff yourself succeeds — a Review policy — … row then appears after each type. Read the list, then click Apply. → Each row reports its own outcome: Pending → Running… → Done, or Already there where something was already true. A failure stops the run at that row and leaves it resumable — nothing after it has run. Every act is recorded in the audit trail under your name, with its before and after values.
- Under the finished list, read the Setup check — the project's own status, re-read against what was just written. It either says "This project's setup is complete." or names what the system will still flag, grouped one entry per cause instead of as a wall of rows. Here you should expect Document Author — no holder yet and Quality Reviewer — no holder yet, because you staffed only yourself: each group is summarised by how many workflow gates and standing permissions stay blocked until somebody holds that role, with Details to read the individual findings and Staff it — Admin › Users to go and fix it (that act is Part 1d). Below them, a The project itself section adds one more honest finding about the role you did staff: "This role is staffed here but nothing says what it is for: no released document describes its duties in this project." — a duty description is a document you have not written yet. Take the line above the list at face value: "Unstaffed roles are normal on day one: invited users bind on first login, and the project is already usable." This step checks; it does not gate — finishing on warnings is fine, and meeting them here rather than at your first submit is the entire point.
- Click Done — open the project configuration. → You land on Scope configuration for the project you just made, which is exactly where Part 1 starts.
If Project setup hands you "Hand this to an administrator" panels instead of live forms,
nothing is broken: creating projects is a governance right, and the panel names the right, the roles
that carry it in your installation, and what to ask for. The step is real — it just belongs to someone
else. The same holds for Found a new organization: it carries a right of its own, so an installation
may well let you set projects up while an administrator founds the organizations. Ask them to found
Muster Diagnostics AG, then start this part again at step 4 — the picker will offer it. Depth:
How a new organization and project are born.
✔ Checkpoint — Open the Project context switcher in the top bar (the workspaces icon beside the search box): your new project is in the list under the name you gave it. Pick it, then open Documents — the navigation tree carries the five folders the wizard created and not a single document. That is what a newborn project looks like. (More on the switcher: The project context.)
On the demo stack: the demo world — the MedTech projects and the four personas — is already there, so the later parts have content to work with from the first click. The project you just registered is yours, alongside it; nothing you did in Part 0 touched it.
Where the rest of the tutorial happens. From Part 1 on, the hands-on steps run in Cardio
Monitor (code MEDTECH-CARDIO) — a project that already has neighbours to link to, a corpus to
trace and released documents to acknowledge. Treat it as the project you just registered. If you want
the harder path, run every remaining lesson in your own new project instead: every step works the
same, but it starts empty, so Part 5's tour has only what you author yourself in it.
Part 1 — Configure the project (as the Quality Manager)¶
Stay logged in as carla.fischer. Configuration is governance: the rules a project runs by. It
lives behind the gear icon in the top bar (its tooltip reads Scope configuration) — a settings
affordance next to Admin, deliberately not another navigation word.
- First switch the Project context (the workspaces switcher in the top bar) to Cardio Monitor — Part 0 left it on the project you just registered, and from here on the hands-on steps run in Cardio. Then click the gear (Scope configuration): with a project named in the switcher, that project's configuration opens directly; if the switcher says All projects, a Select a project prompt appears — pick Cardio Monitor there and the toolbar follows. → You should now see a page titled Scope configuration with a row of tabs (Review policies, Training policies, Obligations, Document types, Emergency cover).
1a. Review policies — and four-eyes vs. direct¶
Manual topic: Review policies — what they control
- Open the Review policies tab. Each document type in the project is an expandable panel marked Configured or Using built-in default. Expand SW Requirement.
- Read the two toggles and the dropdown:
- Four-eyes review (approver must differ from the author) — leave this on.
- Block release while review comments are unresolved — leave this on.
- Release mode — Explicit (a releaser releases) vs Automatic (on last approval). Leave it Explicit. Under Workflow defaults for new documents, confirm the Reviewers — who must approve grid names one role (e.g. Quality Reviewer) with Min. approvers 1. Leave it and click Save — the filled button at the very BOTTOM of the expanded policy panel, below Standing permissions on this type (scroll down inside the panel if you don't see it).
The one paragraph to internalise — four-eyes vs. direct. Four-eyes means the person who submits a version for review can never be the person who approves it: a second, independent pair of eyes must approve before release. That independence is right for prescriptive documents — procedures, specifications — whose correctness someone else must attest. A record is different: a record is proof that a process ran (a meeting minute, a verification record), not an instruction to be independently approved (ISO 13485 §4.2.5). Forcing the full submit → approve → release ceremony on every record is pure friction. So for record types LQMS offers a second choice:
- Still on the Review policies tab, expand the Quality Record type (a Record-category type). Because it is a record, an extra control appears: Release flow (records). Change it from Standard (submit → approve → release) to Direct (single-person release from draft). A quiet line reminds you to ask first whether the record — and the step producing it — is needed at all. Click Save.
You have just made records of this type releasable in one attributed step (you will use this in Part 3 and Part 6). Note this is a permission, not a rule: the full review flow stays available on a direct-mode type whenever you want the extra ceremony. Depth: Documents & the lifecycle §4a and training §4.
1b. Training policy on one type¶
- Open the Training policies tab. Find the SW Requirement row and set:
- Requires acknowledgement — turn on.
- Addressee roles — open the multi-select and add Document Author and Quality Reviewer (roles that actually have holders in this project, so a release later produces real tasks).
- Training deadline (days) — optional; leave it empty for "no objective training deadline", or enter a number to make the training overdue after that many days. (Leaving it empty does not make the inbox task dateless: an acknowledgement task always carries the installation's own working deadline, which the addressee sees as a Due date.) Click Save.
These are creation-time defaults: a new document of the type copies this addressee list into its own editable addressee set — when its creator may read the policy. That read is part of training management, so an author who does not hold it (Ben, in Part 2) gets a draft with an empty addressee set and no warning; Part 2d has you fill it in by hand. (The training mode — none / acknowledge / questionnaire — is chosen per document in the draft editor, not here; you will meet it in Part 4.)
1c. Let a type define requirement trace items¶
- Open the Document types tab. This tab displays each type — its prefix and name, its category chip, review interval and retention, and an Activated / Not activated status. Activating a type happens where the project is set up — Admin → Project setup, as in Part 0 — so there is no activate button here; the chips are read-only status.
- For an Activated type you can change what it may define. On the SW Requirement row, check that May define requirements is on — on the demo stack Cardio already has it on, so there is nothing to click; leave it that way, because Part 2c writes a requirement item into this very type. The row carries one toggle per special element the project has activated (Cardio activated only the requirement kind, so that is the only one here; a project that also uses risks would show May define risks, and so on). Beside them sits a read-only chip — Does not count as verification evidence — a catalog-wide fact stated here, not a switch.
- At the TOP of the same tab (above the document-type rows), note the Design kinds editor — the vocabulary a design element's kind is chosen from (default: architecture, interface, component, unit). You can Add a value and Save design kinds; leave it at the default for now.
The scope's key prefixes (the ones the Suggest button uses when you author a trace item) come from the Special elements section you read in Part 0 — one row per kind, carrying the project's name for it, its prefix and the types that may define it — so every key in the project is consistent and collision-free. This tab is the other face of the same model: the switches here and the document types that may define it selection there write the same fact. If your project declared no kind at all, you simply type the key yourself. Depth: Special elements.
1d. Staff a person into a role¶
Manual topic: Staffing, assignments & the accountable holder
Configuration decides what a role may do; staffing decides who holds it. Staffing is an
administration act (it needs MANAGE_USERS, which carla.fischer holds as a User Administrator).
- Click Admin in the top bar, then Users. → You see a table of users with their Role
assignments shown as
scope: rolechips. - On any user's row, click Assignments. In the Manage role assignments dialog, pick a Scope (e.g. MEDTECH-CARDIO), pick a Role, and click Add — the assignment appears in the list immediately. Click Done.
On the demo stack:
ben.keller,anna.sommerandcarla.fischerare already staffed in every project, so you can just observe the assignment chips rather than add new ones. (The role catalog and its per-scope activation live under Admin → Roles, which needs the broaderMANAGE_CATALOGpermission held only by thedemoadministrator — another governance surface, not the Quality Manager's job.)
✔ Checkpoint — On Review policies, the SW Requirement panel shows Configured; expand the Quality Record panel and Release flow (records) reads Direct (single-person release from draft) (the collapsed header states only Configured — the flow is inside). On Training policies, SW Requirement shows Requires acknowledgement on with two addressee roles. On Document types, SW Requirement shows May define requirements on.
Part 2 — Author a draft¶
Now you write a document. Log out and log in as ben.keller (the Document Author).
2a. Create the draft¶
- Go to Documents. Click New draft (top right).
- On the create page, choose:
- Scope — MEDTECH-CARDIO — Cardio Monitor.
- Document type — SWREQ — SW Requirement.
- Folder — leave Unfiled (you can file it later).
- Title — type
Heart-rate alarm requirement. - Click Create draft. → You land on the new document, shown as v1 in state Draft.
The human ID is assigned automatically — the project code, then the type's prefix, then the next free
number. There is no ID field to fill in. On the demo stack Cardio already carries three SW
Requirements, so yours is MEDTECH-CARDIO-SWREQ-004; in an empty project it would be -001.
2b. Write, in the visual editor¶
- Click Edit draft. The editor opens in the visual (WYSIWYG) mode by default: a toolbar (headings, Bold, Italic, lists, Table, colour, links, images) over a document surface.
- Type a heading and a sentence of body text.
- Type
/in an empty line to open the slash menu — the insert menu for blocks (table, code block, diagram, formulas, and the trace items below). - The mode buttons switch between Switch to Markdown source and Switch to visual editing if you prefer typing Markdown; leaving source mode re-imports your text. Depth: Documents & the lifecycle §2.
2c. Insert a requirement trace item¶
Because May define requirements is on for this type (Part 1c), the editor offers requirement items. The slash menu lists one entry per kind the type may define — here, just Requirement.
- On an empty line, type
/and choose Requirement. → The New requirement dialog opens. - Fill it in:
- Key — click Suggest. Cardio has a key convention, so it fills in the next free key
(
REQ-004on the demo stack); the field hint states the rule you live under: "Unique within the scope; defined in exactly one document." Type a key by hand only where no convention exists — and never one an existing document already defines: the save is refused with, e.g., "Requirement key REQ-001 is already defined in MEDTECH-CARDIO-SWREQ-001." - Kind — choose Functional.
- Priority — a short token in your own language, e.g.
high. - Rationale and Acceptance criteria — optional; fill them if you like.
- Type the requirement statement in the block body. Click Save. → A keyed requirement block appears inline in the document.
Depth on the fixed attribute sets and why the item's lifecycle is the document's: Trace items.
2d. Attach a file and link another document¶
- Still in the editor, open the Details panel (the tune button in the editor's header). It is the boxed Document settings — Changes apply immediately section: everything in it takes effect the moment you make it, without Save. Two things to do here:
- Addressees — who must acknowledge — add Document Author and Quality Reviewer. On a draft created by an author this list is empty (see Part 1b), and Part 4 needs it filled.
- Attachments → Attach a file, and pick any small file. It appears as a download-only attachment (it is not inlined into the text). Once a document has one, an Attachments section appears on the document page too.
- Back on the writing surface, use Insert document link (the link button, or the
/menu) to link to another controlled document by its stable ID — search for one in the Find a document box and insert it. The link survives the target's later renames and folder moves, and it also records a document-level reference you will see on the References card.Typing
[[as a shortcut works in the Markdown source mode — a completion menu opens; type a few letters of the target's title or ID and pick it. In visual mode, use the link button or the/menu instead. - Save the draft (the Save action). Saving is optimistic-locked: if someone else saved while you were editing, your save is refused with a clear message rather than overwriting them.
✔ Checkpoint — The document detail shows Draft · v1, a requirement block keyed with the key you took from Suggest, one file under Attachments, an in-text document link, and the line Addressees: Document Author, Quality Reviewer. Diagrams: Diagrams.
Part 3 — Review & release¶
A controlled document moves Draft → In review → Released. You will drive a full four-eyes round, then see the direct-release shortcut for records.
3a. Submit (as the author)¶
- Still as
ben.keller, open your draft and click Submit for review. → The document becomes In review and read-only. Submitting freezes the content, the change reason, and the workflow roles for this round.
If a workflow group is unstaffed the button is blocked with the reason (e.g. "A workflow group has no active role holder in this scope…"). Because four-eyes is on, you cannot approve your own round; Ben holds no approve-capable role here, so the review console simply offers him no reviewer section at all. Where a submitter does hold one, LQMS says so in its place: "You submitted this version for review — a second person must approve it."
3b. Review and approve (as the reviewer)¶
- Log out and log in as
anna.sommer(the Quality Reviewer). - Go to Inbox → My reviews. Your document is listed because Anna holds a Reviewer role on it. Open it.
- To comment on a passage, select some text and choose Add comment; type a note and Post it. (The Add comment button on the Review comments card posts an unanchored comment about the version as a whole.) A comment is anchored to that text, cannot be edited, and can be Resolved (or Reopened) later — its author may delete it only while the version is still a draft and nobody has replied. Depth: Review comments.
- In the review console on the document, under As reviewer, check your Acting as role: with exactly one approve-capable role (anna's case here) it is preselected and shown as plain text — nothing to pick; only if you hold several does a picker appear. Optionally add a Comment, and click Approve. (Reject would send it back to Draft for the author.)
3c. Release¶
- Your own comment from step 4 is still open, and Part 1a left Block release while review comments are unresolved on — so Resolve it first (the Resolve action on the comment). Then, with the required approvals in and nothing left open, the As releaser section offers Release. Click it. → The document becomes Released — the controlled, effective version.
If release is not yet allowed, the action tells you exactly what is missing — e.g. "awaiting 1 approval(s) from Quality Reviewer" or "3 unresolved review comment(s) must be resolved before release." (To correct a round instead of rejecting it, an author uses Withdraw, which voids the round's approvals and returns the document to Draft.)
✔ Checkpoint — The document detail shows Released. Download PDF is now available; every
page of that PDF carries the distribution-control footer band — "Uncontrolled copy — issued via
LQMS to
3d. The counter-example — direct release of a record¶
Records skip the ceremony when you allowed it in Part 1.
- Log in as
carla.fischer(the Quality Manager — she may release records in this project). Click New draft, choose scope Cardio Monitor, type Quality Record, give it a title, and Create draft**. - On the draft you now see a Release button beside Submit for review. Click it. → A confirmation dialog titled Release directly appears: "This record type allows direct release: releasing now skips the submit → approve steps and makes this a single-person, attributed release. Continue?" Confirm.
✔ Checkpoint — The record went straight from Draft to Released in one attributed step — no reviewer needed. Depth: Documents & the lifecycle §4a.
Part 4 — Training & acknowledgement¶
Releasing a document that has addressee roles raises an Acknowledgement required task for each person holding one of those roles. The type policy you set in Part 1 supplies the default list; the document's own set — the one you filled in by hand in Part 2d — is what actually decides.
- The moment your Part-3 SW Requirement released, an acknowledgement task was created for its
addressees — Ben and Anna. Log in as
ben.kellerand open the Inbox. → Under Awaiting your acknowledgement** you see the released document. - Open it. On the released version a prominent panel invites you to Acknowledge (read &
understood), with the hint "You are addressed by this document — please confirm you have read
and understood it." Click it. → The panel changes to "Acknowledged on
" .
On the demo stack there is a ready acknowledgement waiting regardless of your own release: log in as
ben.kellerand acknowledge the Design Control Procedure (in QMS-OPS) — Anna acknowledged hers already, Ben's is left outstanding on purpose.
The questionnaire variant, in two sentences. A type can train by Questionnaire instead of a simple acknowledgement; the author builds the quiz in the draft editor's Training section (pass threshold + questions), and a version cannot be released until it carries one. The addressee then passes the questionnaire (a passing attempt records the training; failed attempts are recorded too and retries are unlimited).
Where coverage shows. As an addressee you see your own line — Acknowledged on
✔ Checkpoint — Your Inbox no longer lists that document under Awaiting your acknowledgement
(the seeded Design Control Procedure stays there until you do that one too), and the released
version shows Acknowledged on
Part 5 — Trace & prove¶
Traceability is how you prove the QMS holds together: requirements covered by evidence, risks controlled, needs validated. You will author one link yourself, then tour the fully-built picture in the SAMPLE project.
Two lanes run in parallel here, and it helps to name them up front. Stakeholder requirements are the specification lane — what the product must do, stated as requirements (any stakeholder is a source: clinicians, service, regulators, business), decomposed into software requirements and verified: "did we build the product right?" That is the Requirement chains view. User needs are the validation lane — the need in the user's own terms, never decomposed, validated against the finished device in use: "did we build the right product?" That is the Validation matrix view. The distinction is verification vs. validation (IEC 62304 vs. ISO 13485 §7.3.6/7.3.7); depth: Trace items §7.2.
5a. Author a Verifies link (in your project)¶
- As
ben.keller, create a New draft in Cardio Monitor of type SW Test; give it a title and Create draft. - On the draft's document page, find the Trace links card and click Add link — note it lives on the document page (right column), NOT inside the edit view: close the editor (Save, then back) if you are still in it. The card opens a small form in place:
- Source item — leave (the document) (a document-level claim).
- Link type — leave Verifies.
- Leave A keyed item selected and search, under Target item, for the requirement you wrote
in Part 2c (
REQ-004on the demo stack). - Target scope — leave Cardio Monitor (where the target item lives). Click Add.
Adding or removing a link is a structure change, so it is allowed only while the source has a Draft version — the server enforces this (it refuses a link on a released document with 409 Conflict, telling you to revise first). Depth: Trace links & the suspect cycle.
✔ Checkpoint — The Trace links card lists (the document) · VERIFIES · your requirement's key.
5b. Read the coverage — and the new validation matrix¶
Open Evidence → Traceability in the top bar (Evidence is the menu that also holds Dossiers and Authority). This is the workspace hub — "QMS health at a glance — pick a view." Each tile carries a metric and links to a focused page. Sub-pages show one project at a time: if the toolbar says All projects, a Select a project prompt appears — pick one.
On the demo stack: switch the toolbar's Project context to SAMPLE for the richest, fully-seeded example. SAMPLE was built precisely to show every verdict at once.
- Open the Requirement coverage tile. A requirement counts as covered when it has at least one inbound Verifies or Satisfies link; the evidence chips split planned ×N / verified ×N / satisfied ×N. In SAMPLE you should read 2 of 6 requirements covered with four gaps listed — REQ-001 is verified and the stakeholder requirement STK-001 is satisfied by REQ-001, while REQ-002/003/004 and STK-002 remain uncovered. The kind filter separates stakeholder requirements from the functional / safety software ones (a planned verification is a designation; a verified one is a released report). Depth: The traceability workspace §2.
- Back at the hub, open the Requirement chains tile — it walks stakeholder requirement → satisfying software requirements → verification evidence end to end, carrying honest roll-up flags (Not satisfied, Satisfied, unverified, Planned only, Suspect on path). This view is driven by requirements of kind Stakeholder. In SAMPLE you should read 1 of 2 stakeholder requirements satisfied and 1 fully verified: expand STK-001 to see the software requirement REQ-001 that satisfies it, and REQ-001 in turn verified by the released Verification Report — a complete, genuinely verified chain (no flag). STK-002 carries Not satisfied — no software requirement satisfies it yet (the honest gap). The flat matrix is a Download matrix (CSV) on this page — the artifact auditors mean by "traceability matrix".
- Back at the hub, open the Validation tile — the Validation matrix (the "right product" axis — user need → validating validation-cases / records). In SAMPLE you should read 2 of 3 user needs validated · 1 genuinely validated · 1 planned only, and that three-part headline is the honest part: one need is validated by a released Validation Report (verified class), one carries Planned only (a validation-case in a plan, not yet executed) and counts toward the 2, and one is Not validated (the honest gap). Below, a Design realization section shows a design element satisfying a requirement.
- Back at the hub, open GSPR conformity (regulatory clause → complying requirements, with each complier's verification state). In SAMPLE, note the deliberate hard gap: a not-applicable clause carrying N/A — no justification — an unjustified exclusion an auditor would flag.
- Open Risk traceability (hazard → control → requirement / verification → residual risk). In SAMPLE you should see three risks: one full chain, one with control not implemented / control not verified gaps, and one Accepted without reduction (an already-acceptable initial risk that is complete, not a gap). Scores render as recorded tokens (RISK-001 reads Initial: S4 · P2 · P3 — High, Residual: S4 · P1 · P2 — Low) — the tool records, it does not compute. Depth: Trace items §4.
5c. Export the proof¶
- On the hub header, click Traceability report (PDF). → One derived PDF downloads: a front-page gap digest, then the requirement chains, requirement-verification status, risk chains and relation coverage. It is labelled derived — as at export and is not a controlled document (two exports on different days may legitimately differ).
The audit pack, in one paragraph. From the top bar's Evidence menu, under the Audit pack heading (it appears whenever a single project is in context), you can export the whole scope at once: Audit pack (single PDF) — one merged file with a cover, a clickable table of contents and every effective-released document as a bookmarked chapter, whose internal links work in any PDF viewer (this leads the menu) — or Audit pack (zip) — one PDF per document plus a SHA-256 hash manifest, carrying the caution "Cross-document links open only in Adobe Acrobat." Depth: PDF exports & the audit pack.
✔ Checkpoint — You have read requirement coverage, the requirement chains, the validation matrix, GSPR conformity and risk traceability for SAMPLE, and downloaded the traceability report PDF. Depth: The traceability workspace.
Part 6 — Operate: a recurring obligation¶
Some QMS duties recur on a schedule and must leave evidence each time (a backup rehearsal, an environment check). LQMS models these as recurring obligations: a duty whose evidence is a released record. There is no "done" button — releasing the record is the proof it ran.
Log in as carla.fischer** (defining obligations needs review-policy permission).
- Open the gear (Scope configuration) for Cardio Monitor, then the Obligations tab. Click Add obligation.
- In the New obligation dialog:
- Name —
Monthly environment check. - Completion record type — pick Quality Record (only Record-category types appear; you set this one to Direct release in Part 1, which makes completing it frictionless).
- Schedule — choose a calendar schedule: End of month (or Monthly on a day… and set a Day of month; pick a late day there and a hint appears noting that shorter months use their last day, so the deadline is never pushed later than the day you chose).
- Due window (days) — e.g.
7(when it starts warning before it is due). -
Responsible roles — add a role whose holders should be reminded (e.g. Quality Manager). Click Save.
-
Now complete it by producing the evidence. Still as
carla.fischer(who may release records here), create a New draft of type Quality Record in Cardio Monitor, title itEnvironment check — <this month>, and use the direct Release button (Part 3d) to release it. -
Open Evidence → Traceability, then the Obligations tile (the oversight page; switch the toolbar to Cardio Monitor if prompted). The summary reads N OK · N due soon · N overdue, and your obligation's row shows a freshness chip. Releasing the record set its Last execution and advanced Next due — the chip is now OK. Every released record of the completion type counts, and each one discharges one occurrence: the Quality Record you released in Part 3d counts too, so Next due here lands one occurrence further out than you might expect.
On the demo stack a ready example already exists in QMS-OPS: a Monthly infrastructure verification obligation, completed by a directly-released record, already showing OK on the Obligations oversight page — switch the project context to QMS-OPS to observe it.
✔ Checkpoint — On the Obligations oversight page, your obligation shows OK, with the record you just released named as its Last execution and a Next due date on the schedule. Depth: Recurring obligations.
Part 7 — Wrap-up: what you now know¶
You took a project from registration to a released, acknowledged, traced document — and kept an operational duty green. Here is the map from what you did to the reference chapter that goes deeper:
| You did this | Go deeper |
|---|---|
| Registered an organization and a project, chose its lane, and staffed yourself into it | How a new organization and project are born; The setup wizard's lanes; The project context |
| Set review, training and type-definition policies; staffed a role | Training & acknowledgements §4 |
| Created a draft, wrote it, and inserted a keyed requirement | Documents & the lifecycle; Trace items; Diagrams |
| Ran a four-eyes review round; direct-released a record | Documents & the lifecycle §3–§4a; Review comments |
| Acknowledged a released document as an addressee | Training & acknowledgements |
| Authored a trace link; read coverage, chains, the validation matrix, GSPR and risk; exported the proof | Trace links & the suspect cycle; The traceability workspace; PDF exports & the audit pack |
| Defined a scheduled obligation and completed it with a record | Recurring obligations |
| Switched personas through the user menu — which also names the build you are running | The project context & app version §4 |
From here, the reference chapters answer "why" and "every option"; this tutorial only walked the happy path.
This is a hands-on tutorial; the authoritative behaviour and the governing decisions live in the
reference chapters linked above and their ADR footers. The personas, projects and seeded content this
tutorial follows are described in deploy/DEMO.md. Operators standing up an
installation: see docs/operations/deployment.md.