Canon-First vs. Headless vs. Legacy CMS

WebriQ · Architecture brief

The operational and technical case, not the AI-visibility case. What breaks when a fact has no independently governed home, across three architectures, and what canon-first does differently.

The core failure mode

A

A fact — a price, a spec, a certification, a claim about your methodology — needs three things: an authoritative home, traceability to its source, and consistent propagation to everywhere it's used. Legacy CMS and headless both fail this in different ways.

Legacy CMS and headless CMS both improved something real — editability, and then delivery. Neither one made the underlying facts inside the system independently governable. That gap is what canon-first closes, by changing what the durable unit is: not the page, not the content entry, but the individual verified claim.

Eight dimensions, three architectures

B

Dimension	Legacy CMS	Headless CMS	Canon-first
Durable unit	The page — content and presentation fused	The content entry — still shaped like a page	The individual verified claim
Where a fact lives	Hand-typed into every page/template that mentions it	Structured, but usually duplicated across separate entries	Exactly once, bound to the entity it concerns
When a fact changes	Manual find-and-replace across every page that has it	Manual update per entry — nothing tells you which entries hold copies	Update the claim once; every bound composition regenerates automatically
Provenance / audit	None — authority is implicit, whoever had edit access	Workflow state per entry, not per fact — one wrong spec inside an approved entry isn't flagged	Source, confidence, approval state, and validity on every claim
Ownership boundaries	Blurred — dev, marketing, product often edit the same system	Cleaner content/front-end split, but product data is often re-entered or synced and can drift	Enforced: product system owns product truth, Canon owns claim truth, engine reads both, writes neither
Migration / replatform cost	High — content re-authored to fit new templates	Lower — front end decouples, but the content model still mirrors the old site's structure	Near-zero for the durable asset — pages are disposable and regenerable
Multi-language consistency	Each locale a separate copy, drifting independently	Localization fields exist, but each locale's entry is still separately maintained	Translations held alongside the claim; a change flags the exact affected line, per language
Editorial authority	Requires developer involvement to fix a fact baked into a template	Editors edit entries, but the CMS itself holds unaudited authority — a database with permissions	The build engine is architecturally forbidden from having editorial authority; it only assembles and publishes

Why headless specifically doesn't close this

C

This is the comparison worth being precise about, since headless looks solved. Delivering a product entry as JSON instead of HTML changes the format, not the governance. A headless workspace can still leave several questions structurally unanswerable: which evidence backs a given spec, who approved it, when it expires, and what else depends on it. Those relationships stay implicit because headless organizes content around what's needed to render something, not around the fact itself. The front end became independent. The knowledge inside the entries didn't.

What canon-first mechanically does instead

D

It moves the durable unit down to the claim, then enforces three boundaries that make the rest of the comparison true.

• Facts belong to domain systems, permanently. — The product system stays the one place product truth is edited — copied into the Canon one way only, never written back to. Publishing layers are consumers, and stay consumers.

• The engine orchestrates, never authors. — It assembles and deploys; it can't touch upstream data. That's what makes the ownership boundary real instead of a convention people are supposed to follow.

• The page is temporary, the claim is permanent. — Every composition — page, PDF, feed, translation — is regenerable from the claims underneath it. That's what makes migrations, redesigns, and new channels cheap instead of a re-authoring project.

Structured, source-bound claims also happen to be easier for an AI system to extract and cite than facts fused into unstructured prose. That's a real downstream effect of solving fact governance — not the reason to solve it. The architecture is built to fix where a fact lives, how it's audited, and how it propagates. AI legibility follows from getting that right; it isn't what canon-first is designed around.