Glossary Updates16 new terms added to the glossaries · 12 November 2026, 21:23 CET
AI TechDocKnowledge
  • English (US)
  • English (UK)
  • Deutsch
All blueprints

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.

At a glance: which placeholder each blueprint opened
The sourceThe personThe third reader
1Thinking models for technical writersIn focusPresent, kept closedNot in view
2Cognitive psychology for technical communicationPresent, kept closedIn focusNot in view
3AI-enabled information systems for technical writersPresent, kept closedPresent, kept closedIn focus
4AI systems and the machine: levels and boundariesNot in viewNot in viewIn focus
5The content lifecycle under AI: stages, gates and boundariesIn focusPresent, kept closedPresent, kept closed
6Who decides which value countsIn focusIn focusIn 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. 1

    Thinking Model · the writer’s stack

    Thinking models for technical writers

    The source, seen as one technical writer who structures complexity before writing.

    The source
    In 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 reader

    Not 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. 2

    Thinking Model · the reader’s stack

    Cognitive psychology for technical communication

    The person, seen as one reader who notices, finds, understands, decides, acts and recovers.

    The person
    In 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 reader

    Not 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. 3

    Thinking Model · the machine’s stack

    AI-enabled information systems for technical writers

    The third reader, seen as the machine — one actor between the source and the answer.

    The third reader
    In 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. The third reader, ordered by levels of who decides — from the global AI environment down to one AI function.

    The third reader
    In focus
    • global AI environment
    • contracted access
    • company AI estate
    • AI systems
    • AI function
    • the machine, through every level
    The source

    Not in view

    The person

    Not 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. The source, followed through eleven stages from analysis to withdrawal, with one gate passed at several of them.

    The source
    In 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. 6

    Check Strategy · this blueprint

    Who decides which value counts

    All three placeholders opened into roles, ordered by the five activity families.

    The source
    In focus
    • Writing: the source
    • Deciding: system of record, master data
    The person
    In focus
    • Using: the person — with qualification, authority and situation
    The third reader
    In 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.

Three placeholders, five families, eleven roles
RoleTest questionDocumentation decision
SourceWho created this value, and is it released yet?The source of each value · its release status · its creating discipline
System of recordWhich system decides this value — for this object?The system of record per value · its owner · the revision that counts
Master dataIs this the agreed version — or only the consolidated one?The golden record used · its data owner and steward · the engineering revision behind it
IntegrationWhen was this value taken over, and from where?Interfaces and schedules · mappings · what happens when a transfer fails
Derived dataWhat was this derived from — and when?Derivations used · their sources and dates · where documentation must not take values from
Document assemblyWhich object revisions was this document assembled from?Assembly rules · the objects and revisions behind each document · the metadata of the topics
Exchange packageWhat state of the source does this package hold?Package version and scope · what it was built from · who receives it
Consuming systemMay 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 engagementIs what a person sees here what was released?What is shown with its source · what may be adapted · what may never be left out
PersonWhich 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 systemWho authorised this system to write — and what?Write authorities · their gate · the record of every write-back
Stewardship and lineageCan 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.

The role table
RolePlaceholder it opensActivity familyWho decidesWho may change it hereWhat it holdsWhat gets lostTypical confusionDocumentation decision
SourceThe sourceWritingThe discipline that creates the value: engineering, the supplier, the test benchOnly the creating discipline, through its own change processThe first version of a value, often before it is releasedNothing yet — but an unreleased value can already leaveThe first system to hold a value is taken for the one that decides itName the source of every value that documentation uses
System of recordThe sourceDecidingThe owner of the data object, by nameOnly through the owner’s releaseThe value that counts, with its revision and statusNothing, as long as the revision travels with the valueA system of record for one object is taken for one for every objectName the system of record per value, not per system
Master dataThe sourceDecidingThe data owner, with the data stewardData stewards, under agreed rulesThe agreed, consolidated version of a business object — the golden recordThe reason for a value: the record keeps what, rarely whyConsolidated is taken for releasedUse master data where it is decided; carry the engineering revision with it
IntegrationThe third readerCompilingThe interface owner, with both sidesNobody — an integration maps and moves, it doesn’t decideMappings, schedules, transformations, error queuesUnits, qualifiers and the moment of changeA synchronization is taken for a decisionSay when a value was taken over, from where, and what happens when it fails
Derived dataThe third readerCompilingWhoever builds the derivation: an analyst, a team, a functionOnly the derivation — the values themselves must not change hereCalculations, aggregations, exports, spreadsheets, reportsLineage: a derived value rarely says what it was derived from and whenA newer derivation is taken for a newer sourceNever take a value for documentation from a derivation; take it from its system of record
Document assemblyThe third readerCompilingThe content owner, for the assembly rulesAuthors in their topics; the assembly only selectsTopics, metadata, assembly rules, the assembled documentWhich value in a topic depends on which object and revisionThe document revision is taken for the revision of everything in itRecord which object revisions a document was assembled from
Exchange packageThe third readerCompilingThe publication owner, with the receiving sideNobody after it was built — a package is a fixed stateA packaged set of content and metadata for another systemThe connection to the source once the package has leftA package is taken for a live sourceGive every package its version, its scope and what it was built from
Consuming systemThe third readerUsingThe owner of the consuming system — for its own use onlyNobody, for the received valueCopies of values for search, display, service or orderingWhether the copy is still currentA consumer is taken for a source by the next consumerSay which values a consumer may show and how it learns that they changed
System of engagementThe third readerUsing — and compiling, when it answersThe owner of the channel: portal, app, chat, service deskNobody, for the product value — only its presentationWhat a person sees and asks; usage and feedbackThe difference between released and shownWhat is shown is taken for what is releasedMark what is shown with its source and revision where a decision rests on it
PersonThe personUsingThe manufacturer, for the information a person in this role needs; the employer, for the qualification and the authorityNobody, for the value — the person acts on it within their authorityWhat one role of person needs to act safely: an instructed operator, a person trained on the machine, a skilled personThe 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 knowledgeName the role, its qualification, its authority and its situation; never leave out safety-related information for any of them
Acting systemThe third readerWriting backThe owner of the system that is written to — never the agentOnly within a delegated, recorded authorityActions: tickets, status changes, orders, write-backsWho authorised the change, and on what basisA reader that writes back is still taken for a readerTreat every system that writes back as a source, with an owner and a gate
Stewardship and lineageAll threeAcross all familiesThe data owners and data stewards, decided once for the companyStewards maintain rules and records; they don’t change released valuesOwnership, rules, lineage records, the catalogue of systems of recordEverything, if nobody keeps itLineage is taken for a technical logKeep 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.

From placeholder to check rule
Placeholder (thinking model)Activity familyRolesUnit a check rule namesExample check question
The sourceWritingSourcePLM › change management › release functionDoes a released revision carry its change notice and reason?
The sourceDecidingSystem of record · Master dataERP › material master › bill of materials updateDoes the bill of materials follow the released revision on the day of release?
The third readerCompilingIntegration · Derived data · Document assembly · Exchange packageCCMS › publishing subsystem › assembly function › revision lookupDoes the order manual name the revision of every assembly it was built from?
The third readerUsing — and compiling, when it answersConsuming system · System of engagementService portal › retrieval chat › answer function › source selectionDoes the answer take each value from one revision and name it?
The personUsingPerson, with qualification and authorityThe operator panel › fault display › acknowledge functionDoes the instructed operator get what is needed to acknowledge the fault — and nothing that invites a bypass?
The third readerWriting backActing systemService agent › ticket handling › status update › write-backIs 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.

Where the roles work against each other
ConflictRolesWho decidesWhat prevails when in doubt
A newer spreadsheet against the system of recordDerived data · System of recordThe data ownerThe system of record · a derivation is corrected from it, never the other way round
A dashboard figure against the systems it countsDerived data · Source · System of recordThe owner of the report, with the data ownersThe counted systems · the dashboard says what it counts and what it doesn’t
A scheduled synchronization against a released valueIntegration · System of recordThe interface owner, with the data ownerThe released value · an integration that would overwrite it stops and reports
Marketing wording against the released technical valueMaster data · System of record · Consuming systemThe data owner for the technical attributeThe released value · wording may adapt, the value may not
Variants out of stepSystem of record · Document assembly · Derived dataConfiguration management, with the content ownerThe configured variant of the system of record · documents and lists follow it
An answer from several revisionsSystem of engagement · Consuming systemThe owner of the answer function, with the content ownerOne revision · an answer that can’t name it refers to the source instead
A reader that writes backActing system · System of record · IntegrationThe owner of the system that is written toThe 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.

  1. Source
  2. System of record
  3. Master data
  4. Integration
  5. Derived data
  6. Document assembly
  7. Exchange package
  8. Consuming system
  9. System of engagement
  10. Person
  11. Acting system
  12. 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

DERIVED DATATranslation agencyXLIFF · Rev. BSYSTEM OF RECORDPLMRev. C · releasedMASTER DATAERPBOM · Rev. BDOCUMENT ASSEMBLYCCMSManual · Rev. BSYSTEM OF ENGAGEMENTService portalPDF · Rev. BDERIVED DATADashboard3 changes openDERIVED DATASpare parts listExport · Rev. ASeven systems for one door assembly. Engineering has released revision C. The business system, the content system, the translation, the spare parts list and the dashboard still show earlier states. Dashed connections are exports or copies outside a governed interface.Governed interface · Export or copy outside a governed interface · A reader that writes back

Legend of the chain diagrams

  • Governed interface
  • Export or copy outside a governed interface
  • A reader that writes back
Engineering has released revision C. The business system, the content system, the translation, the spare parts list and the dashboard still show earlier states. Dashed connections are exports or copies outside a governed interface.
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.

Which system plays which role
SystemRoles it playsWhat it holds after the changeWho may change it thereWhat gets lost
PLMSource · System of record for the designRevision C of the door assembly, releasedEngineering, through the change processNothing yet — the reason for the change is recorded here
ERPMaster data · System of record for material, order and configurationThe new part number; the bill of materials still at revision BThe material master team; planning for the bill of materialsThe reason: the change number travels, the reason doesn’t
CCMSDocument assembly · System of record for the topicsTopics released for revision B; the order manual assembled from itTechnical writersWhich topic depends on which part — the metadata names the assembly, not its revision
Translation agencyDerived data (language versions) · Exchange package receivedXLIFF of revision B, in progressThe agency, for its language version onlyThe context of the change
Service portal and PDFExchange package · Consuming system · System of engagementThe PDF of revision B and the spare parts listThe publication owner, for what is shownWhich design revision the PDF was built from
Spare parts listDerived data · end-user computing · in practice treated as a system of record by serviceAn export three weeks old, with the old part numberWhoever has the fileLineage, completely
DashboardDerived data (aggregation)“3 documentation changes open”The report ownerThat 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.

  1. Monday, 08:10

    Engineering releases revision C of the door assembly in the PLM system. A change notice goes to the business system.

  2. 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

  3. 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

  4. Monday, 16:45

    The manual is released and published. The translation agency receives the XLIFF files for revision B.

  5. 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

  6. 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

  7. 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

SYSTEM OF RECORDPLMRev. D · releasedMASTER DATAERPBOM · Rev. DDOCUMENT ASSEMBLYCCMSManual · Rev. CSYSTEM OF ENGAGEMENTService portalPDF · Rev. CDERIVED DATASpare parts listExport · Rev. CDERIVED DATAKnowledge graphNightly · Rev. CSYSTEM OF ENGAGEMENTRetrieval chatAnswers from C + DACTING SYSTEMService agentWrites part statusThe same chain with a graph, a chat and an agent. Engineering and the business system are at revision D. The graph syncs at night and still holds revision C, the manual is at revision C, and the agent writes a status back into the business system. The dotted line is a reader that writes back.Governed interface · Export or copy outside a governed interface · A reader that writes back

Legend of the chain diagrams

  • Governed interface
  • Export or copy outside a governed interface
  • A reader that writes back
Engineering and the business system are at revision D. The graph syncs at night and still holds revision C, the manual is at revision C, and the agent writes a status back into the business system. The dotted line is 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.

The same roles, played faster
SystemRoles it playsWhat it holds after the changeWho may change it thereWhat gets lost
PLMSource · System of record for the designRevision D, releasedEngineering, through the change processNothing — the reason is recorded
ERPMaster data · System of record for material and order · written to by the agentBill of materials at revision D; a part status set by the agentThe material master team — and, in practice, the agentWho decided the part status, and on what basis
CCMSDocument assembly · System of record for the topicsThe manual of revision C, with its revisions recordedTechnical writersNothing, as long as the manual names its revision
Knowledge graphDerived data · IntegrationRelations between parts, documents and orders, at revision C until the nightNobody, for the values — the graph connects themWhich value is released: the graph knows how things relate, not which version counts
Retrieval chatSystem of engagement · Consuming systemAnswers built in the moment from revisions C and DNobody — it adapts wording, it must not change valuesThe revision behind each part of the answer
Service agentActing system · a reader that writes backStatus changes in the business systemWithin its delegated authority — if that is recordedThe authority behind the write, unless it is recorded
Spare parts listDerived data · end-user computingAn export at revision CWhoever has the fileLineage, 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.

  1. Thursday, 08:05

    Engineering releases revision D in the PLM system. The business system takes over the new bill of materials within the hour.

  2. Thursday, 09:00

    The writers start on the maintenance chapter. The released manual stays at revision C and says so on every page.

  3. 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

  4. 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

  5. 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

  6. 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.

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