Check Strategy · Product information
Who decides which value counts: roles of product information from source to answer
From three placeholders to roles a check rule can name — for every system and every person a value passes on its way
The system that writes first is not the system that decides.
- By
- By Saina Veigel · Communications Specialist · Senior Technical Writer
- Edition
- 1
- First published
- Reviewed
The home page of this site looks at documentation through three placeholders: the source, the person and the third reader — everything that meets the information between the two. That is a thinking model, and a useful one. With three placeholders a team sees in minutes who has a stake in a value and which questions a check method has to ask: Is it decided? Can the person act on it? Does every system in between know which value counts?
A thinking model helps to design a check method. It doesn’t check anything yet. As soon as a team writes its own check processes and check rules, each placeholder has to become something that can be named, checked and signed off: a system, a subsystem, a function, a subfunction — and the role it plays for one value.
Take the door assembly of the fictional test cell DS-3. Engineering has released revision C. The business system, the content system, the translation, the spare parts list and the dashboard still show earlier states. There is no single “third reader” to blame here. There are seven systems, and each does something different with the value: one decided it, two copied it, one assembled it into a manual, one counted it, one answered from it — and a person ordered the wrong part.
This blueprint opens all three placeholders. The source becomes the roles that create and decide a value. The person becomes the use of the value, with the qualification and authority the role grammar describes. The third reader becomes the systems that move, derive, assemble, package, show and act on it — and some of them write. One test runs through all of them: who may change it here — and how does the next system know which value counts?
It is written for technical writers, technical project managers and documentation systems developers who have to say, for a value in a document, where it came from, which system decided it and what the systems and people after it were allowed to do with it. The check rules that follow from it are in the method tool “The check rule grammar”.
Why three placeholders were enough — and where they stop
Three placeholders are enough as long as the task is to find the questions. They keep a check method small enough to design: one column for the decided content, one for the person who acts on it, one for everything in between. Each column asks one question, and together they show where a document can go wrong.
Figures · The placeholders in the earlier blueprints
How the earlier blueprints used the three placeholders
Every earlier blueprint on this site looked through these placeholders — and each one opened a different one. The figures show, blueprint by blueprint, which placeholder was in focus, what stood in each column and where the lens stops. None of them is wrong: each was a lens for one question. Read side by side, they show what a check strategy has to add.
| The source | The person | The third reader | |
|---|---|---|---|
| 1Thinking models for technical writers | In focus | Present, kept closed | Not in view |
| 2Cognitive psychology for technical communication | Present, kept closed | In focus | Not in view |
| 3AI-enabled information systems for technical writers | Present, kept closed | Present, kept closed | In focus |
| 4AI systems and the machine: levels and boundaries | Not in view | Not in view | In focus |
| 5The content lifecycle under AI: stages, gates and boundaries | In focus | Present, kept closed | Present, kept closed |
| 6Who decides which value counts | In focus | In focus | In focus |
Legend
Each cell of the table shows how much of a placeholder a blueprint worked out:
- In focus
- The blueprint works this placeholder out — it is the subject of the blueprint and its tables.
- Present, kept closed
- The placeholder appears, but as one block: the blueprint names it without opening it into roles.
- Not in view
- The placeholder doesn’t appear in the blueprint at all.
Read a row from left to right: it shows how one blueprint looked at the three placeholders. Read a column from top to bottom: it shows which blueprints took up that placeholder — and that only the last row has all three in focus.
- 1
Thinking Model · the writer’s stack
The source, seen as one technical writer who structures complexity before writing.
The sourceIn focus- one technical writer
- the mental model stack of ten layers
- the operating-mode analysis grid
The person- the reader the page is written for
The third readerNot in view
What the lens showed
How a writer thinks a topic through — task, risk, variant, metadata, publication — before a sentence is written.
Where it stops for a check
A text has several writers: the expert who supplies the values, the translator, the reviewer, the person who releases, and systems that draft. A check has to name which of them decided a value.
- 2
Thinking Model · the reader’s stack
The person, seen as one reader who notices, finds, understands, decides, acts and recovers.
The personIn focus- one reader
- the reader’s stack: noticing … recovering
- situation and prior knowledge in one grid
The source- the page, as the writer left it
The third readerNot in view
What the lens showed
What happens in the reader’s mind between seeing a page and acting on it.
Where it stops for a check
The same page is read by an instructed operator, an operator trained on the machine and a skilled person — in routine operation, faults and emergencies. A warning can only be checked for one of them.
- 3
Thinking Model · the machine’s stack
The third reader, seen as the machine — one actor between the source and the answer.
The third readerIn focus- the machine, as one actor
- one AI agent
- the machine’s stack of ten layers
The source- the source the answer serves
The person- four job groups
- one reader
What the lens showed
How documentation becomes knowledge that people and AI systems can use — bounded, anchored, traced and governed.
Where it stops for a check
An agent can consume, answer or write back — three roles with three risks — and the machine is a web of systems that read, compile and write in different ways. A rule has to say which of them it addresses.
- 4
Thinking Model · the cascade
The third reader, ordered by levels of who decides — from the global AI environment down to one AI function.
The third readerIn focus- global AI environment
- contracted access
- company AI estate
- AI systems
- AI function
- the machine, through every level
The sourceNot in view
The personNot in view
What the lens showed
Where a company decides about the machine, and where it only depends on it.
Where it stops for a check
It says who decides at each level, not what each part does with the information: an index holds it, a retrieval selects it, a model composes a new text from it, an agent acts on it.
- 5
Thinking Model · the stages
The content lifecycle under AI: stages, gates and boundaries
The source, followed through eleven stages from analysis to withdrawal, with one gate passed at several of them.
The sourceIn focus- eleven stages, from analyse to archive
- one gate type, passed at several stages
The person- “the reader” and “the user”, used as one
The third reader- the answer function, in the stage “Answer”
What the lens showed
Where a decision about content is taken, and which ones a tool may prepare but never pass.
Where it stops for a check
The answer function doesn’t read the documentation for the user — it compiles a new text that nobody released. That is a different role, and it needs a check of its own.
- 6
Check Strategy · this blueprint
Who decides which value counts
All three placeholders opened into roles, ordered by the five activity families.
The sourceIn focus- Writing: the source
- Deciding: system of record, master data
The personIn focus- Using: the person — with qualification, authority and situation
The third readerIn focus- Compiling: integration, derived data, document assembly, exchange package
- Using: consuming system, system of engagement
- Writing back: acting system
What the lens showed
For every value: which system or person writes it, decides it, compiles it, uses it or writes it back.
Where the check rule begins
Here the check rule begins: each role sits in a unit — system, subsystem, function, subfunction — that a rule can name.
Each lens found its question. None of them gave a check rule an address — that is the step this blueprint takes.
They stop being enough the moment a check has to be run. “The source” can’t be asked for a release record; a named system of record can. “The person” can’t be given a warning that fits; an instructed operator in routine operation can. “The third reader” can’t be told to name its sources; a document assembly function can. A check rule needs an address, and a placeholder has none.
Of the three, “the third reader” hides the most. Most of what it stands for doesn’t read at all: systems decide, move, derive, assemble, package and show values, an answer function compiles a new text, an agent writes back. Calling all of them readers hides the one difference that matters most for a check: who may change a value here.
Behind the three placeholders of a single line in a spare parts table there are usually:
- the engineer who designed the part and the person who released it
- a released design revision in an engineering system
- a material master record and a bill of materials in a business system
- an interface or a scheduled job that copies them
- a topic in a content system that names the part
- a published document assembled for one order or variant
- an export into a spreadsheet that service keeps
- a dashboard that counts the open changes
- an answer function that compiles an answer from all of them
- an agent that may write a status back
- a technician with a qualification and an authority of their own
Each of them holds the value, and only one of them decides it.
Technical writers don’t need to own the landscape. They need to know which system decides each value they publish and who uses it, so that the document can say it, a change finds its way into the document — and a check rule can test it.
The core problem
As long as the placeholders stay closed, a check has nothing to hold on to — and the most recent copy wins over the decided value.
- A spreadsheet export is newer than the system of record and is believed because it is newer.
- A dashboard is read as a source, although it only counts what other systems report.
- A scheduled synchronization overwrites a released value with an older one.
- Marketing wording in a product information system replaces the released technical value.
- Variants move out of step: the bill of materials, the document and the spare parts list describe three different machines.
- A translation is made from a revision that has already been replaced.
- An AI function answers from two revisions at once and sounds certain.
- An agent that was meant to read writes a value back, and the next synchronization spreads it.
- Nobody can say which revision a published value came from.
- A check rule says “the manual shows the current value” and can’t be run, because it names no system, no function and no value.
When the roles stay hidden behind placeholders, documentation copies the wrong value faithfully — and a check that names no unit can’t catch it.
Blueprints
Three placeholders, five families, eleven roles
The roles in the order of the activity families — writing, deciding, compiling, using, writing back — with stewardship and lineage across them
The roles open the three placeholders. The source opens into writing and deciding (source, system of record, master data); the third reader into compiling (integration, derived data, document assembly, exchange package) and into using (consuming system, system of engagement) and writing back (acting system); the person into using, with qualification and authority. Each role answers one test question, and each answer leaves a decision behind that documentation — and a check rule — can carry. Stewardship and lineage run through all of them.
Scroll sideways to see every column.
| Role | Test question | Documentation decision |
|---|---|---|
| Source | Who created this value, and is it released yet? | The source of each value · its release status · its creating discipline |
| System of record | Which system decides this value — for this object? | The system of record per value · its owner · the revision that counts |
| Master data | Is this the agreed version — or only the consolidated one? | The golden record used · its data owner and steward · the engineering revision behind it |
| Integration | When was this value taken over, and from where? | Interfaces and schedules · mappings · what happens when a transfer fails |
| Derived data | What was this derived from — and when? | Derivations used · their sources and dates · where documentation must not take values from |
| Document assembly | Which object revisions was this document assembled from? | Assembly rules · the objects and revisions behind each document · the metadata of the topics |
| Exchange package | What state of the source does this package hold? | Package version and scope · what it was built from · who receives it |
| Consuming system | May this system show the value — and how does it learn that it changed? | Values a consumer may use · how changes reach it · where it must refer to the source |
| System of engagement | Is what a person sees here what was released? | What is shown with its source · what may be adapted · what may never be left out |
| Person | Which person uses this value — with which qualification and which authority, in which situation? | The roles of the people who use it · their qualification and authority · the situations it is used in |
| Acting system | Who authorised this system to write — and what? | Write authorities · their gate · the record of every write-back |
| Stewardship and lineage | Can the next person see where this value came from? | Data owners and stewards · the catalogue of systems of record · the lineage record |
The roles are not a product category, an architecture or a description of one company’s landscape. They are a way to say, for one value, which system or person does what with it. The activity families are those of the blueprint “The role grammar of technical information”.
The system that writes first is not the system that decides.
Decisions, changes and losses · Reference
The role table
Each role with the placeholder it opens, its activity family, who decides, who may change the value, what it holds, what gets lost and the typical confusion
Every row names the placeholder the role opens and its activity family, who decides the value in that role, who may change it there, what the role holds, what gets lost when the value passes through it, the typical confusion and the documentation decision. The column “What gets lost” sets the priorities: where meaning, evidence or lineage are lost, documentation — and its check rules — have to carry them on.
Scroll sideways to see every column.
| Role | Placeholder it opens | Activity family | Who decides | Who may change it here | What it holds | What gets lost | Typical confusion | Documentation decision |
|---|---|---|---|---|---|---|---|---|
| Source | The source | Writing | The discipline that creates the value: engineering, the supplier, the test bench | Only the creating discipline, through its own change process | The first version of a value, often before it is released | Nothing yet — but an unreleased value can already leave | The first system to hold a value is taken for the one that decides it | Name the source of every value that documentation uses |
| System of record | The source | Deciding | The owner of the data object, by name | Only through the owner’s release | The value that counts, with its revision and status | Nothing, as long as the revision travels with the value | A system of record for one object is taken for one for every object | Name the system of record per value, not per system |
| Master data | The source | Deciding | The data owner, with the data steward | Data stewards, under agreed rules | The agreed, consolidated version of a business object — the golden record | The reason for a value: the record keeps what, rarely why | Consolidated is taken for released | Use master data where it is decided; carry the engineering revision with it |
| Integration | The third reader | Compiling | The interface owner, with both sides | Nobody — an integration maps and moves, it doesn’t decide | Mappings, schedules, transformations, error queues | Units, qualifiers and the moment of change | A synchronization is taken for a decision | Say when a value was taken over, from where, and what happens when it fails |
| Derived data | The third reader | Compiling | Whoever builds the derivation: an analyst, a team, a function | Only the derivation — the values themselves must not change here | Calculations, aggregations, exports, spreadsheets, reports | Lineage: a derived value rarely says what it was derived from and when | A newer derivation is taken for a newer source | Never take a value for documentation from a derivation; take it from its system of record |
| Document assembly | The third reader | Compiling | The content owner, for the assembly rules | Authors in their topics; the assembly only selects | Topics, metadata, assembly rules, the assembled document | Which value in a topic depends on which object and revision | The document revision is taken for the revision of everything in it | Record which object revisions a document was assembled from |
| Exchange package | The third reader | Compiling | The publication owner, with the receiving side | Nobody after it was built — a package is a fixed state | A packaged set of content and metadata for another system | The connection to the source once the package has left | A package is taken for a live source | Give every package its version, its scope and what it was built from |
| Consuming system | The third reader | Using | The owner of the consuming system — for its own use only | Nobody, for the received value | Copies of values for search, display, service or ordering | Whether the copy is still current | A consumer is taken for a source by the next consumer | Say which values a consumer may show and how it learns that they changed |
| System of engagement | The third reader | Using — and compiling, when it answers | The owner of the channel: portal, app, chat, service desk | Nobody, for the product value — only its presentation | What a person sees and asks; usage and feedback | The difference between released and shown | What is shown is taken for what is released | Mark what is shown with its source and revision where a decision rests on it |
| Person | The person | Using | The manufacturer, for the information a person in this role needs; the employer, for the qualification and the authority | Nobody, for the value — the person acts on it within their authority | What one role of person needs to act safely: an instructed operator, a person trained on the machine, a skilled person | The difference between qualification and authority, and the situation the information is used in | “The user” is taken for one person, and the information for one level of knowledge | Name the role, its qualification, its authority and its situation; never leave out safety-related information for any of them |
| Acting system | The third reader | Writing back | The owner of the system that is written to — never the agent | Only within a delegated, recorded authority | Actions: tickets, status changes, orders, write-backs | Who authorised the change, and on what basis | A reader that writes back is still taken for a reader | Treat every system that writes back as a source, with an owner and a gate |
| Stewardship and lineage | All three | Across all families | The data owners and data stewards, decided once for the company | Stewards maintain rules and records; they don’t change released values | Ownership, rules, lineage records, the catalogue of systems of record | Everything, if nobody keeps it | Lineage is taken for a technical log | Keep a lineage record wherever documentation rests on a value |
The column “Who decides” names roles, not job titles. In a small company one person can hold several of them; the decision still has to be named. The qualification levels of the row “Person” are explained in the role grammar with their established terms.
Every value has someone who decides it — and every system after that only holds a copy.
Crosswalk · Thinking model, roles, check rule
From placeholder to check rule
Each placeholder of the home page with the families and roles it opens, the unit a check rule names and an example check question
The crosswalk reads the three stages side by side. The placeholders find the question, the roles assign it, the unit gives a check rule its address. The units and the full rule — value, condition, evidence, owner and trigger — are explained in the method tool “The check rule grammar”.
Scroll sideways to see every column.
| Placeholder (thinking model) | Activity family | Roles | Unit a check rule names | Example check question |
|---|---|---|---|---|
| The source | Writing | Source | PLM › change management › release function | Does a released revision carry its change notice and reason? |
| The source | Deciding | System of record · Master data | ERP › material master › bill of materials update | Does the bill of materials follow the released revision on the day of release? |
| The third reader | Compiling | Integration · Derived data · Document assembly · Exchange package | CCMS › publishing subsystem › assembly function › revision lookup | Does the order manual name the revision of every assembly it was built from? |
| The third reader | Using — and compiling, when it answers | Consuming system · System of engagement | Service portal › retrieval chat › answer function › source selection | Does the answer take each value from one revision and name it? |
| The person | Using | Person, with qualification and authority | The operator panel › fault display › acknowledge function | Does the instructed operator get what is needed to acknowledge the fault — and nothing that invites a bypass? |
| The third reader | Writing back | Acting system | Service agent › ticket handling › status update › write-back | Is every write-back recorded with its authority and approved before it takes effect? |
The units are examples at the fictional reference system DS-3. In a real landscape each team names its own — at the level a rule needs, and no deeper.
The placeholder asks. The role assigns. The unit makes it checkable.
Trade-offs · Reference
Where the roles work against each other
Each conflict with the roles it sets against each other, who decides and what prevails
A shortcut that helps one role can harm another. The conflicts are decided in every landscape, only often by whoever touches the value last. Each row names a conflict, the roles it concerns, who decides it and what prevails when in doubt.
Scroll sideways to see every column.
| Conflict | Roles | Who decides | What prevails when in doubt |
|---|---|---|---|
| A newer spreadsheet against the system of record | Derived data · System of record | The data owner | The system of record · a derivation is corrected from it, never the other way round |
| A dashboard figure against the systems it counts | Derived data · Source · System of record | The owner of the report, with the data owners | The counted systems · the dashboard says what it counts and what it doesn’t |
| A scheduled synchronization against a released value | Integration · System of record | The interface owner, with the data owner | The released value · an integration that would overwrite it stops and reports |
| Marketing wording against the released technical value | Master data · System of record · Consuming system | The data owner for the technical attribute | The released value · wording may adapt, the value may not |
| Variants out of step | System of record · Document assembly · Derived data | Configuration management, with the content owner | The configured variant of the system of record · documents and lists follow it |
| An answer from several revisions | System of engagement · Consuming system | The owner of the answer function, with the content owner | One revision · an answer that can’t name it refers to the source instead |
| A reader that writes back | Acting system · System of record · Integration | The owner of the system that is written to | The gate · a write-back without recorded authority is rejected or held |
The column “Who decides” names roles, not job titles. A conflict that isn’t decided in the table is decided in the landscape anyway, by whoever acts first.
A value that two systems decide is decided by neither.
The roles, and stewardship and lineage
Each entry explains one role or stewardship and lineage across them: its test question, what it covers, where it ends and what documentation has to decide about it.
- Source
- System of record
- Master data
- Integration
- Derived data
- Document assembly
- Exchange package
- Consuming system
- System of engagement
- Person
- Acting system
- Stewardship and lineage
1. Source
Core question: Who created this value, and is it released yet?
A source system creates a value for the first time: a design in engineering, a measurement on the test bench, a supplier’s data sheet, a requirement.
Questions to ask in this role:
- Which discipline created the value, and in which system?
- Is the value released, or only saved?
- Which change process does it follow there?
Being first doesn’t make a system the one that decides. Engineering systems hold work in progress next to released revisions, and both can be read by the next system if nobody says which is which.
For documentation, the source is where a question about a value goes. A document that names only the system it copied from sends every question to the wrong place.
- Created is not released.
- The first system is not the deciding system.
A value without a named source is answered by whoever has a copy.
Documentation decision
- The source of each value
- its release status
- its creating discipline
2. System of record
Core question: Which system decides this value — for this object?
The system of record is the system that holds the value that counts, with its revision and status, for one data object — and sometimes only for one attribute of it.
Questions to ask in this role:
- For which objects and attributes is this the system of record?
- Who owns the object, by name?
- How does a released revision become visible to the systems after it?
A landscape rarely has one system of record. Engineering decides the design, the business system decides the material and the order, the content system decides the topic. The question is never “which system is the source of truth?” but “which system decides this value?”.
Documentation needs that answer for every value it publishes. Where it can’t give it, it copies a value that nobody can confirm.
- A system of record is decided per object, not per system.
- Holding a value is not deciding it.
Name the deciding system per value — the rest of the landscape holds copies.
Documentation decision
- The system of record per value
- its owner
- the revision that counts
3. Master data
Core question: Is this the agreed version — or only the consolidated one?
Master data management consolidates the versions of a business object — a material, a product, a customer — into one agreed version, the golden record, and keeps it in step across systems.
Questions to ask in this role:
- Which attributes of the golden record are decided here, and which are taken over from engineering?
- Who may change them, and under which rules?
- Which engineering revision does the record reflect?
A golden record makes a value consistent across systems. It doesn’t make it released: the technical attributes still come from the discipline that decides them, and the record has to carry their revision.
For documentation, master data is the shared name and number of things. It is a reliable place to take an identifier from, and a poor place to take a technical value from when its revision is missing.
- Consistent is not released.
- A golden record keeps what, rarely why.
Master data agrees on the thing. The discipline behind it still decides its values.
Documentation decision
- The golden record used
- its data owner and steward
- the engineering revision behind it
4. Integration
Core question: When was this value taken over, and from where?
Integration moves values between systems: interfaces, middleware, scheduled jobs, low-code flows, synchronizations, extract-transform-load pipelines.
Questions to ask in this role:
- Which values does this integration move, in which direction and how often?
- What does it change on the way — units, codes, qualifiers?
- What happens to a value that fails or arrives late?
An integration doesn’t decide. It maps, transforms and schedules, and each of these is a place where a value can lose its unit, its qualifier or the moment it changed. A nightly job means that for a day, two systems disagree on purpose.
Many integrations are invisible: a flow built by one person, a script on a server, a list that is copied every Monday. They move values just the same.
- A synchronization is not a decision.
- An invisible flow is still an integration.
Where nobody knows when a value was taken over, nobody knows which value is current.
Documentation decision
- Interfaces and schedules
- mappings
- what happens when a transfer fails
5. Derived data
Core question: What was this derived from — and when?
Derived data combines values from several sources into something that none of them holds: a calculation, an aggregation, a spreadsheet, a report, a dashboard.
Questions to ask in this role:
- Which sources does this derivation read, and when was it last refreshed?
- Who built it, and who maintains it?
- Who uses it as if it were a source?
Derivations are useful because they combine. They are risky for the same reason: a figure on a dashboard or a row in a spreadsheet looks finished, and it rarely says what it was derived from. Spreadsheets and shared lists kept outside the governed systems — end-user computing — often become the de facto source for a team.
Documentation can describe a derivation, refer to it or warn about it. It should not take a value from it.
- A newer derivation is not a newer source.
- A dashboard counts; it doesn’t decide.
A derivation without its sources is a value without a past.
Documentation decision
- Derivations used
- their sources and dates
- where documentation must not take values from
6. Document assembly
Core question: Which object revisions was this document assembled from?
Document assembly builds a document from topics and data: an order-specific manual from a configured bill of materials, a variant from metadata, a data sheet from attributes.
Questions to ask in this role:
- Which values in a topic depend on which object, and is that in the metadata?
- From which revision of the bill of materials was the document assembled?
- What happens to an assembled document when one of its objects changes?
An assembled document is a compilation with a release of its own. Its revision says when the document was released. It doesn’t say which revision of each part, assembly or value is in it — unless the assembly records it.
This is the role closest to the writer. It is also the role where the landscape becomes visible: every dependency the metadata doesn’t name is a change the document will miss.
- A document revision is not the revision of everything in it.
- Assembly selects; it doesn’t decide.
A document that knows what it was built from can follow a change.
Documentation decision
- Assembly rules
- the objects and revisions behind each document
- the metadata of the topics
7. Exchange package
Core question: What state of the source does this package hold?
An exchange package carries content and metadata to another system in a fixed state: a delivery package for a portal, a translation package, a package for a digital product record or a service system.
Questions to ask in this role:
- Which version, scope and source revisions does the package hold?
- Who receives it, and what do they do with it?
- How does the receiver learn that a newer package exists?
A package is a snapshot. Once it has left, it no longer follows its source, and the receiver may keep it for years. That is its purpose, and it has to be visible in the package itself.
Translation packages are a common example: a revision is sent out, the source changes, and the translation that comes back belongs to a revision that no longer counts.
- A package is not a live source.
- A package that left can’t be corrected — only replaced.
Give every package its past, so that its receiver can see its age.
Documentation decision
- Package version and scope
- what it was built from
- who receives it
8. Consuming system
Core question: May this system show the value — and how does it learn that it changed?
A consuming system uses values from other systems without being allowed to change them: a search index, a service system, an ordering system, a customer’s system, a register.
Questions to ask in this role:
- Which values does it take over, and from which system?
- How does it learn about a change or a withdrawal?
- Who else reads from it?
Consumers are rarely the last link. A consumer is read by the next consumer, who no longer sees where the value came from. After two steps, a copy looks like a source.
For documentation, every consumer is a place where a published value lives on after it was replaced. The question is not whether it is read, but how it is told.
- Received is not decided.
- A consumer’s consumer can’t see the source.
A copy that isn’t told about a change keeps the old value with full confidence.
Documentation decision
- Values a consumer may use
- how changes reach it
- where it must refer to the source
9. System of engagement
Core question: Is what a person sees here what was released?
A system of engagement is where people meet the information: a portal, an app, a service desk, a chat, an assistant on an operator panel.
Questions to ask in this role:
- Which sources does it show or answer from, and in which revision?
- What may it adapt — wording, order, length — and what may it not?
- What does it record about what people asked and saw?
Systems of engagement change how a value is shown. They should never change the value. An answer function in a system of engagement doesn’t read for the person: it compiles a new text from several sources that nobody released as such, and it is the function most likely to combine values from different revisions in one sentence.
They are also where feedback starts. What people ask and miss is a signal for the source — not a change of it.
- Shown is not released.
- An answer is compiled, not read.
Where a decision rests on what is shown, the source has to be shown with it.
Documentation decision
- What is shown with its source
- what may be adapted
- what may never be left out
10. Person
Core question: Which person uses this value — with which qualification and which authority, in which situation?
The person who acts on the information is not one reader. An instructed operator, a person trained on the machine and a skilled person who may open the control cabinet use the same page for different tasks, with different authority and in different situations.
Questions to ask in this role:
- Which roles of people use this value, and what may each of them do with it?
- Which qualification does each role have — and which authority, which is not the same?
- In which situations is it used: routine operation, a fault, an emergency, maintenance?
The role grammar names the qualification levels with their established terms — ordinary, instructed and skilled person, qualified and competent person — and keeps qualification apart from authority: knowing how to bypass an interlock doesn’t mean being allowed to.
For a check rule, “the reader” becomes a role in a situation. A rule can then ask whether the information this role needs in this situation is there and findable — and whether nothing required or safety-related was left out for anyone.
- A reader is a role, not a person.
- Qualified is not authorised.
Name the role and its situation — and the information can be checked against it.
Documentation decision
- The roles of the people who use it
- their qualification and authority
- the situations it is used in
11. Acting system
Core question: Who authorised this system to write — and what?
An acting system changes something in another system: it opens a ticket, sets a status, places an order, corrects a value. Agents that were built to read and now write back belong here.
Questions to ask in this role:
- Which values may it write, in which system, under whose authority?
- Which writes need a person’s approval before they take effect?
- What is recorded about each write — the value before, the basis, the authority?
The moment a reader writes back, it becomes a source. It needs what every source needs: an owner, a scope and a gate. Without them, its value enters the next synchronization like any other and is copied as if someone had decided it.
For documentation, an acting system is a new author that nobody invited. Its writes can change a value that a document rests on.
- A reader that writes is a source.
- Delegated is not authorised unless it is recorded.
Every system that writes back needs a gate — or the landscape has a new source that nobody owns.
Documentation decision
- Write authorities
- their gate
- the record of every write-back
12. Stewardship and lineage
Core question: Can the next person see where this value came from?
Stewardship and lineage run through all roles: who owns which data, who keeps its rules, and the record of where each value came from and what was derived from it.
Questions across the roles:
- Who is the data owner of each object, and who is its data steward?
- Where is it written down which system decides which value?
- Can a document name the origin of the values it rests on?
Lineage is often treated as a technical log of an integration. It is a documentation concern: it is the answer to the question a reader, an auditor or an engineer asks about a value in a document — where does this come from?
Stewardship is decided once for the company, not per project. A catalogue of systems of record that nobody maintains is the next copy.
- Lineage is not a log file.
- Ownership that isn’t written down is a guess.
A landscape with lineage can be corrected. A landscape without it can only be repeated.
Documentation decision
- Data owners and stewards
- the catalogue of systems of record
- the lineage record
Why this matters for documentation
The roles turn a landscape of copies into places where decisions can be documented:
- every published value names the system that decides it
- documents record the object revisions they were assembled from
- derivations are referred to, never copied from
- integrations say when a value was taken over
- packages carry their version, scope and age
- consumers are told when a value changes or is withdrawn
- every system that writes back has an owner and a gate
- the conflicts between the roles are decided, not left to whoever acts last
A value that knows its source can follow a change.
Distinctions to keep
The roles depend on a few distinctions that are easy to blur in everyday language. Each of them is a boundary between two roles, or between a value and a copy of it.
- The system that writes first is not the system that decides.
- A copy is not a source.
- Holding a value is not deciding it.
- Consistent is not released.
- A synchronization is not a decision.
- A newer derivation is not a newer source.
- A document revision is not the revision of everything in it.
- A package is not a live source.
- Shown is not released.
- A reader that writes back is a source.
- Semantics are not governance.
- A role is not a product.
- A placeholder is not a role.
- A role is not a unit.
- An answer function compiles; it doesn’t read.
- Qualified is not authorised.
- A check question is not a check rule.
Each distinction names a system that decides — and one that only holds a copy.
Evidence that is enough
Tracing every value through every system is no answer; it is the reason nothing is traced. The smallest lineage record that lets a published value be checked and corrected holds:
- the identifier and the value — part number, attribute, text
- the system of record that decides it, and its revision and status there
- who released it, by name, and when
- what it was derived from, if it is derived — source and revision
- for which scope it is valid — variant, order, configuration, language
- when it was taken over into the document or package, and by which integration
- for a write-back: which system wrote it, under whose authority, the value before and who approved it
The record is needed for the values a decision rests on: identifiers, technical values, statuses, intervals, warnings and their translations. Wording, layout and order can be traced through the document’s own versions.
Much of the record already exists in the systems: revisions, change numbers, release dates. What is usually missing is the connection between them — the line that says this value in this document came from that revision in that system.
A small record that travels with the value beats a complete one that stays in the system.
Case studies · Fictional
Two case studies at DS-3
One company, one kind of change — once without AI and once with it
Both case studies take place at the same fictional manufacturer of special-purpose machines and its reference system DS-3, a configurable assembly and test cell built to order. They use only patterns that have been common in the industry for years. Each case walks through the chain system by system, shows the roles each system plays, follows the day of an engineering change and names what was lost, what would have been enough and what does not change.
The company, DS-3 and every value in these cases are fictional. They are not based on a particular company, product or project.
Case 1 · Without AI
An order becomes a manual
Document assembly from the configured bill of materials, and an engineering change that arrives late
The company and the chain
The manufacturer builds DS-3 cells to order. Every cell is configured from a modular product: stations, safety guarding, options. Engineering releases designs in a PLM system. The business system holds the material master, the bill of materials and the variant configuration of each order. Technical writers keep XML topics with metadata in a component content management system, which assembles the order-specific manual from the configured bill of materials.
The manual is published as a PDF and in the service portal. A translation agency receives XLIFF files and returns the language versions. Service keeps a spare parts list in a spreadsheet, filled by a manual export from the business system every few weeks. A dashboard counts the open documentation changes per order.
The change: the supplier discontinues the safety interlock switch on the guard door. Engineering releases revision C of the door assembly with a successor switch — a new part number, different wiring and a different interval for the functional test in the maintenance plan.
The chain
Seven systems for one door assembly
Legend of the chain diagrams
- Governed interface
- Export or copy outside a governed interface
- A reader that writes back
- Translation agency · XLIFF · Rev. B
- Translates the maintenance chapter of revision B, with the old test interval. It sees sentences, not the reason they changed.
- PLM · Rev. C · released
- System of record for the design. Revision C of the door assembly is released with a change notice.
- ERP · BOM · Rev. B
- Master data for material and order. The new part number exists, but the bill of materials keeps revision B until next week’s planning run.
- CCMS · Manual · Rev. B
- Assembles the order manual from the bill of materials as the business system has it — revision B, with the old switch and the old interval.
- Service portal · PDF · Rev. B
- Shows the PDF of the order and the spare parts list. Only the document revision is printed on it.
- Dashboard · 3 changes open
- Counts open documentation changes from the business system and the content system. The change in engineering isn’t among them yet.
- Spare parts list · Export · Rev. A
- A spreadsheet exported three weeks ago, uploaded to the portal by service. Only its file name says when.
Roles · Case 1
Which system plays which role
Most systems play more than one role — for different values
For the door assembly of one order, every row names the roles a system plays, what it holds after the change, who may change it there and what gets lost when the value passes through it.
Scroll sideways to see every column.
| System | Roles it plays | What it holds after the change | Who may change it there | What gets lost |
|---|---|---|---|---|
| PLM | Source · System of record for the design | Revision C of the door assembly, released | Engineering, through the change process | Nothing yet — the reason for the change is recorded here |
| ERP | Master data · System of record for material, order and configuration | The new part number; the bill of materials still at revision B | The material master team; planning for the bill of materials | The reason: the change number travels, the reason doesn’t |
| CCMS | Document assembly · System of record for the topics | Topics released for revision B; the order manual assembled from it | Technical writers | Which topic depends on which part — the metadata names the assembly, not its revision |
| Translation agency | Derived data (language versions) · Exchange package received | XLIFF of revision B, in progress | The agency, for its language version only | The context of the change |
| Service portal and PDF | Exchange package · Consuming system · System of engagement | The PDF of revision B and the spare parts list | The publication owner, for what is shown | Which design revision the PDF was built from |
| Spare parts list | Derived data · end-user computing · in practice treated as a system of record by service | An export three weeks old, with the old part number | Whoever has the file | Lineage, completely |
| Dashboard | Derived data (aggregation) | “3 documentation changes open” | The report owner | That it doesn’t count changes that haven’t reached the business system |
No system in this chain does anything wrong by its own rules. Each one holds the state it was given.
Seven systems hold the value. One decides it.
The day of the change, step by step
The change is released on a Monday morning. The cell for order 4711 is configured the same afternoon.
Monday, 08:10
Engineering releases revision C of the door assembly in the PLM system. A change notice goes to the business system.
Monday, 09:30
The business system creates the new part number. The change to the bill of materials is scheduled for next week’s planning run, as every change is.
Conflict: A scheduled synchronization against a released value
Monday, 14:00
Order 4711 is configured. The content system assembles the manual from the bill of materials as the business system has it: revision B, with the old switch and the old test interval.
Conflict: Variants out of step
Monday, 16:45
The manual is released and published. The translation agency receives the XLIFF files for revision B.
Tuesday, 10:00
The dashboard shows three open documentation changes. The change from Monday morning is not among them, because it hasn’t reached the business system.
Conflict: A dashboard figure against the systems it counts
Six weeks later
The cell is in operation. A technician looks up the interlock switch in the spare parts list in the portal and orders the discontinued part. The maintenance chapter gives the old test interval.
Conflict: A newer spreadsheet against the system of record
The same day
Service asks which state is current. PLM says revision C, the business system says revision C since last week, the manual says revision B, the spare parts list says revision A, the dashboard says nothing is open.
What was lost
- Meaning: the reason for the change stayed in the PLM system; every later system received a number without a reason.
- Evidence: nobody can show which design revision the published manual was assembled from.
- Lineage: the spare parts list doesn’t say what it was exported from or when.
- Scope: the change applied to every order from Monday on; the systems after PLM learned that at different times.
What would have been enough
- The system of record named for the door assembly and for the test interval: PLM.
- The assembled manual recording the revision of every assembly it was built from.
- A rule that a released change holds back the assembly of affected documents until the bill of materials follows.
- The spare parts list derived from the business system with its date and revision on every page — or not kept at all.
- The dashboard counting changes from the PLM system, not only from the systems after it.
What does not change
- Engineering decides the design and its revision.
- The manual is released by its content owner and answers for its order.
- Required and safety-related information — here the functional test of the interlock — stays complete in every version.
- Following the roles doesn’t make a manual compliant or a machine safe. It shows where a decision was made.
Nothing was hidden. Everything was copied — and the copies didn’t know their source.
Case 2 · With AI
The same company, years later
A knowledge graph, a retrieval chat and an agent that writes back — and the same kind of change
What has changed at DS-3
The manufacturer has learned from the first case. The bill of materials now follows a released engineering change on the same day, and manuals record the revisions they were assembled from. The spare parts spreadsheet still exists, because service likes it.
Three systems are new. A knowledge graph connects product, material and document data from the PLM system, the business system and the content system, synchronised every night. A retrieval chat in the service portal answers technicians from the manuals and the graph. A service agent reads incoming tickets and may set the availability status of spare parts in the business system, so that the portal shows alternatives.
The change: revision D of the door assembly replaces the successor switch once more, with a new part number and a shorter test interval.
The chain
The same chain with a graph, a chat and an agent
Legend of the chain diagrams
- Governed interface
- Export or copy outside a governed interface
- A reader that writes back
- PLM · Rev. D · released
- System of record for the design. Revision D is released in the morning.
- ERP · BOM · Rev. D
- Follows the change the same day now. It also receives the status that the agent writes back.
- CCMS · Manual · Rev. C
- The writers are working on the change; the released manual is still revision C, and it says so.
- Service portal · PDF · Rev. C
- Shows the manual of revision C and the alternatives that the business system reports.
- Spare parts list · Export · Rev. C
- Still exported by hand. Still believed by some.
- Knowledge graph · Nightly · Rev. C
- Connects parts, assemblies, documents and orders. Until tonight’s sync it holds revision C.
- Retrieval chat · Answers from C + D
- Answers from the manual (revision C) and the graph — and, through the portal, from the business system’s alternatives (revision D).
- Service agent · Writes part status
- Reads tickets and sets the availability status of spare parts in the business system. Built as a helper, it is now a source.
Roles · Case 2
The same roles, played faster
The new systems play roles that were already in the table
Every row names the roles a system plays for the door assembly after revision D, what it holds, who may change it there and what gets lost.
Scroll sideways to see every column.
| System | Roles it plays | What it holds after the change | Who may change it there | What gets lost |
|---|---|---|---|---|
| PLM | Source · System of record for the design | Revision D, released | Engineering, through the change process | Nothing — the reason is recorded |
| ERP | Master data · System of record for material and order · written to by the agent | Bill of materials at revision D; a part status set by the agent | The material master team — and, in practice, the agent | Who decided the part status, and on what basis |
| CCMS | Document assembly · System of record for the topics | The manual of revision C, with its revisions recorded | Technical writers | Nothing, as long as the manual names its revision |
| Knowledge graph | Derived data · Integration | Relations between parts, documents and orders, at revision C until the night | Nobody, for the values — the graph connects them | Which value is released: the graph knows how things relate, not which version counts |
| Retrieval chat | System of engagement · Consuming system | Answers built in the moment from revisions C and D | Nobody — it adapts wording, it must not change values | The revision behind each part of the answer |
| Service agent | Acting system · a reader that writes back | Status changes in the business system | Within its delegated authority — if that is recorded | The authority behind the write, unless it is recorded |
| Spare parts list | Derived data · end-user computing | An export at revision C | Whoever has the file | Lineage, as before |
The graph, the chat and the agent are not a new kind of system for this table. They are a derivation, a system of engagement and an acting system.
The roles stay the same. They run faster, and with less visibility.
The day of the change, step by step
Revision D is released on a Thursday morning. The first technician asks the chat about it before lunch.
Thursday, 08:05
Engineering releases revision D in the PLM system. The business system takes over the new bill of materials within the hour.
Thursday, 09:00
The writers start on the maintenance chapter. The released manual stays at revision C and says so on every page.
Thursday, 11:20
A technician asks the chat which interlock switch the cell needs and how often to test it. The chat takes the part number from the business system’s alternative (revision D) and the test interval from the manual (revision C), and answers in one confident sentence.
Conflict: An answer from several revisions
Thursday, 11:40
The technician opens a ticket: the part in the manual is not available. The service agent reads the ticket and sets the revision C switch to “superseded — use alternative” in the business system.
Conflict: A reader that writes back
Thursday night
The graph synchronizes. It takes over the status that the agent wrote as if it were master data and connects it to every order with a revision C door.
Conflict: A scheduled synchronization against a released value
Friday morning
Older cells that are still allowed to use the revision C switch now show it as superseded. Nobody in engineering decided that.
What was lost
- Meaning: the graph connected the values correctly and still couldn’t say which of them was released.
- Evidence: the answer in the chat names no revision, so nobody can check it afterwards.
- Lineage: the status written by the agent entered the business system without the authority behind it — and the graph spread it.
- Scope: a status meant for one ticket became a status for every order.
What would have been enough
- The chat answering from one revision per part, and naming it — or referring to the source when it can’t.
- The graph carrying the revision and release status of every value it connects.
- The agent’s write authority recorded: which status, for which scope, approved by whom before it takes effect.
- A gate in the business system for values written by an acting system, owned by the data owner.
- The lineage record of case 1 — the same record, now also for answers and write-backs.
What does not change
- Engineering decides the design and its revision; the data owner decides the material status.
- An answer is not a source, and an agent is not the owner of what it writes.
- The chat may adapt wording, never leave out required or safety-related information — here the functional test.
- Connecting data semantically doesn’t replace the governance of content: versions, releases and variants still need an owner.
Faster copies are still copies. The question of who decides doesn’t go away — it arrives sooner.
From roles to check rules
Thinking models help to develop a check method: they find the questions and show where to look. Building the actual check processes and check rules needs more — a grammar that turns every placeholder into a role, and every role into a unit a rule can name: a system, a subsystem, a function, a subfunction.
That grammar is the method tool “The check rule grammar”. It gives a check rule its seven parts — unit, role, value, condition, evidence, owner and trigger —, templates for each activity family, a worked example at DS-3 and a checklist. This blueprint supplies the roles; the tool turns them into rules.
Tools in the landscape can make the roles visible: a PLM system with change records, master data management with ownership and rules, integration platforms that log what they moved, content systems with metadata on every dependency, lineage tools, retrieval that returns its sources, agent frameworks that record their actions. They don’t decide which system is the system of record, who owns a value or which system may write back. That decision stays with people, and it has to be written down where documentation and its check rules can refer to it.
With the roles, a check rule can:
- name the unit that decides, compiles, shows or writes back a value
- measure a value against its system of record instead of against “current”
- ask a compiling unit for its sources, not for a decision
- check the information against a person’s role, qualification, authority and situation
- treat a reader that writes back as the source it has become
The roles say who decides. The check rule grammar says how you can tell.
The core principle
The core principle is short: the system that writes first is not the system that decides.
Every value in a document has passed through a landscape of systems and people. Most of them held it, copied it, combined it or showed it. One of them decided it. Documentation that can name that system can follow a change, and a check rule can test it; documentation that can’t copies the last value it saw.
The roles support documentation decisions. They never replace the manufacturer’s risk assessment, configuration management, the safety information required for a product or the review by the people responsible for the documentation. No role may leave out or adapt away safety-related or required information.
Cut complexity — create clarity
Explained in context
Context cards explain the general, checkable background of some of the questions this blueprint raises. They are written by knowledge.aitechdoc.world and are not part of the blueprint.
- Who decides which value counts: which system decides a value of product information?When product information passes through PLM, ERP, content systems, spreadsheets, portals and AI functions, how do you tell which system decides a value and which one only holds a copy?Read the card
- From three readers to check rolesThe home page names three readers — the source, the person and the third reader. Why is that enough to design a check method, and what has to change before a check can run?Read the card
Reference updates
The glossary references, the terms under “Related established methods” and the context cards are attached to this blueprint, not part of it. They are checked and updated on their own, without a new edition.
The references haven’t been updated since the first edition.
How to cite
Saina Veigel (2026). Who decides which value counts: roles of product information from source to answer. Blueprint, edition 1. knowledge.aitechdoc.world. https://knowledge.aitechdoc.world/uk/blueprints/who-decides-which-value-counts
Edition and changes
Edition 1 · Reviewed
Corrections (something was wrong) and additions (something was missing) since the first edition.
No corrections or additions since the first edition.
About this blueprint
This Check Strategy leads from a thinking model to a check method. It is not a standard, a certified method or a compliance framework. Naming a standard, a law or an established method does not mean that a product, a system or its documentation conforms to it.
The check rules a team builds with it are documentation and data checks. They do not replace the manufacturer’s risk assessment, configuration management, the verification and validation of safety functions or the review by the people responsible for the documentation.
Copyright © 2026 Saina Veigel. All rights reserved. Copyright notice