Commercial pillar · Nested schema · Schema-graph integrity
Schema conflict detection: when three schema types on one page disagree, rich results break — detect the conflicts before publish
Schema App, Yext, Merkle, Google Rich Results Test, SchemaPro, and RankRanger ship strong per-block schema validation. Each block passes Schema.org compliance in isolation. The combined page-level @graph can still produce conflicts that break the rich result — mainEntity collision, aggregateRating duplication, orphan-graph nodes, identifier collision. Cross-schema graph integrity is the operator-side layer that catches the combined-graph conflicts at PR time.
Published May 30, 2026
Six canonical schema-conflict classes
mainEntity collision. Two or more schemas on the same page declare mainEntity, producing ambiguous page-canonical-entity. Google drops both rich results.
aggregateRating duplication. Two or more schemas declare different aggregateRating values. Google sees the contradiction and drops the rating snippet.
Orphan-graph nodes. Entity referenced by @id, but the referenced node is missing from the @graph.
Identifier collision. Two distinct entities share the same @id, causing graph merging that produces wrong type assignments.
Circular reference. Entity A references entity B via @id, entity B references entity A — cycle that breaks downstream consumers.
Per-page-type completeness gap. Product pages without BreadcrumbList; LocalBusiness pages without FAQPage when a FAQ section is present; Article pages without datePublished even though the article has a publish date elsewhere on the page.
PR-time detection in the operator engineering pipeline
The detection layer runs as a CI check on every PR that modifies a page-emitting template or a per-page-data file.
The check renders the affected page-sample (one representative page per affected template), extracts the JSON-LD blocks, builds the combined @graph, applies the conflict-class detection logic, and posts a PR comment that names: which page (URL), which conflict class, which schema blocks are involved, and the proposed fix.
Failures block PR merge. Operators who run schema validation at production-deploy time discover conflicts after they have shipped; the rich result breaks; recovery requires another deploy. Operators who run detection at PR time catch the conflict in code review.
Conflict detection composes with schema auto-remediation
Schema auto-remediation generates pull requests that fix per-error-class block-level issues. Schema conflict detection runs on every PR — including the auto-remediation PRs — and validates combined-graph integrity.
If an auto-remediation PR introduces a cross-schema conflict (the proposed fix adds aggregateRating to Product but a Review schema on the same page also declares aggregateRating), the detection layer catches it and either rejects the PR or annotates it with the conflict description for human review.
The two layers compose: auto-remediation handles per-error-class fix-generation; conflict detection handles cross-block integrity verification. Either alone is insufficient at multi-location scale.
Frequently asked
What is a schema conflict and why is per-schema validation not enough to catch it?
A schema conflict happens when two or more structured-data blocks on the same page are individually valid Schema.org but produce a contradictory or ambiguous combined graph. Each block passes Google Rich Results Test in isolation. The combined page fails to render the rich result Google would otherwise show, or worse, renders an unintended one. Three canonical conflict patterns recur. First: mainEntity collision — a page declares mainEntity on a Product schema and also declares mainEntity on a FAQPage schema; Google does not know which entity is canonical for the page and drops both rich results. Second: aggregateRating duplication — a Product schema declares aggregateRating and a separate Review schema declares aggregateRating with a different value; Google sees the contradiction and drops the rating snippet. Third: orphan-graph nodes — a Product schema references an Offer schema via @id but the Offer schema does not exist in the page @graph, or vice versa. Per-schema validation catches block-level Schema.org compliance. Cross-schema graph integrity is the operator-side layer that catches the combined-graph conflicts.
Why do Schema App, Yext, Merkle, Google Rich Results Test, SchemaPro, and RankRanger not catch this?
Each ships per-schema validation strongly. Schema App + Yext run JSON-LD at the CDN edge and validate what they emit per-block. Merkle audits structured data on third-party sites per-block. Google Rich Results Test validates per-rich-result-eligibility per-block. SchemaPro emits schema markup from a config UI per-block. RankRanger surfaces schema-coverage as a dashboard. The platforms excel at the block-level validation primitive. They do not ship the cross-block graph-integrity detection that catches mainEntity collision + aggregateRating duplication + orphan-graph nodes + identifier collision + circular reference + per-page-type completeness gap. Building this detection requires parsing the full per-page @graph, building a logical graph of entity references, applying per-page-type integrity rules, and surfacing conflicts as actionable PR blockers before publish. The operator-side wiring composes on top of the per-block validation primitive.
What are the canonical schema-conflict classes worth detecting at PR time?
Six classes recur. First: mainEntity collision — two or more schemas on the same page declare mainEntity, producing ambiguous page-canonical-entity. Second: aggregateRating duplication — two or more schemas declare different aggregateRating values; Google sees contradiction. Third: orphan-graph nodes — entity referenced by @id but the referenced node is missing from the @graph. Fourth: identifier collision — two distinct entities share the same @id, causing graph merging that produces wrong type assignments. Fifth: circular reference — entity A references entity B via @id, entity B references entity A, producing a cycle that breaks downstream consumers. Sixth: per-page-type completeness gap — Product pages without BreadcrumbList; LocalBusiness pages without FAQPage when a FAQ section is present; Article pages without datePublished even though the article has a publish date elsewhere on the page. Each class has class-specific detection logic and a class-specific PR-blocker message that names the offending blocks + the proposed fix.
How does PR-time detection actually fit into the operator engineering pipeline?
The detection layer runs as a CI check on every PR that modifies a page-emitting template or a per-page-data file. The check renders the affected page-sample (one representative page per affected template), extracts the JSON-LD blocks, builds the combined @graph, applies the conflict-class detection logic, and posts a PR comment that names: which page (URL), which conflict class, which schema blocks are involved, and the proposed fix (the operator-side wiring that resolves the conflict). Failures block PR merge. Operators who run schema validation at production-deploy time discover conflicts after they have shipped; the rich result breaks; recovery requires another deploy. Operators who run detection at PR time catch the conflict in code review and ship a clean PR.
How does cross-schema detection interact with schema auto-remediation?
Schema auto-remediation generates pull requests that fix per-error-class block-level issues (missing-required-property, invalid-enumeration, type-mismatch, orphan-graph at block level). Schema conflict detection runs on every PR — including the auto-remediation PRs — and validates the combined-graph integrity. If an auto-remediation PR introduces a cross-schema conflict (the proposed fix adds aggregateRating to Product but a Review schema on the same page also declares aggregateRating), the detection layer catches it and either rejects the PR or annotates it with the conflict description for human review. The two layers compose: auto-remediation handles per-error-class fix-generation; conflict detection handles cross-block integrity verification. Either alone is insufficient at multi-location scale.
What is the typical engagement model for building schema conflict detection?
Tier 1 AI Readiness Assessment ($10k, 2-3 weeks) audits the current schema-emission surface, identifies which conflict classes are present today versus need new detection, and produces the conflict-detection specification. Tier 2 AI Swarm Setup Sprint ($25-50k, 4-8 weeks) builds the detection layer end-to-end: per-page sample rendering, JSON-LD extraction, @graph building, per-class conflict-detection logic, CI integration, PR-comment formatting, per-template confidence-threshold tuning. Tier 3 Fractional CMO with AI Swarm ($15-25k/month, 6-month minimum, 1-2 days/wk embedded) operates the layer in production + extends per-class detection as new Schema.org features arrive + tunes per-template confidence thresholds + coordinates the detection layer with the schema auto-remediation layer. Operator team owns the template tree, the CI pipeline, the page-sample selection, and credentials. Completions owns the orchestration knowledge.
Engage Completions
Start with the AI Readiness Assessment (Tier 1, 2-3 weeks, $10k). Hand off to Tier 2 AI Swarm Setup Sprint ($25-50k, 4-8 weeks). Continue under Tier 3 Fractional CMO with AI Swarm ($15-25k/month, 6-month minimum, 1-2 days/wk embedded).