9 Schema Mistakes That Make Google Ignore Your Markup

1. Orphan nodes that reference nothing

The most common structural failure. A page emits an Article, a Person and an Organization in three separate script blocks, none referencing the others.

Every block validates. But Google now has three unrelated facts: an article exists, a person exists, an organisation exists. Nothing says the person wrote the article or runs the organisation.

How to spot it: count the @id references in your markup. If no node points at another node’s @id, you have orphans.

The fix: one @graph, stable @ids, and every relationship stated as a reference:

"author":    { "@id": "https://example.com/#jane" },
"publisher": { "@id": "https://example.com/#brand" },
"isPartOf":  { "@id": "https://example.com/#website" }

2. No @id, so every page invents a new entity

A fully-described Person block copy-pasted onto 120 pages, with no @id anywhere. Google sees 120 mentions of someone with that name and no basis for merging them.

This is the highest-leverage fix in this whole article and it takes one line per node. The @id is what makes 120 mentions into one node mentioned 120 times.

How to spot it: search your rendered HTML for "@id". If it is absent from your Person and Organization nodes, this is your problem.

The fix: a permanent fragment URI on each entity node, identical site-wide. Never change it afterwards — changing an @id creates a new entity and abandons the old one’s accumulated confidence.

3. The same @id with contradictory values

The opposite failure, and subtler. You have @ids, but different pages give the same node different values:

// /about/
"@id": ".../#jane", "jobTitle": "Founder"

// /blog/some-post/
"@id": ".../#jane", "jobTitle": "Senior Consultant"

Google merges by @id, so it ends up holding both job titles with no way to know which is current. Not an error — a soft contradiction, and contradictions reduce confidence.

How to spot it: pull the same node from three or four different page types and diff them. They should be byte-identical.

The fix: emit entity nodes from one shared template so they cannot drift. If a property genuinely has several values, put them all in an array, on every page.

4. Marking up content nobody can see

This is the one that carries actual risk. Google’s structured data policies require markup to represent content visible on the page. Violations include:

• FAQPage markup for questions that do not appear on the page.
• AggregateRating with no genuine reviews behind it.
• Product pricing that differs from the displayed price.
• Recipe or HowTo steps that exist only in the markup.
• Event dates for events that were never scheduled.

The consequence is not a shrug. It is a structured data manual action, which can remove rich result eligibility across the entire site, and it takes a reconsideration request to lift.

The fix: for every marked-up value, confirm a human can find it by reading the page. Fabricated ratings are the most common version and the most reliably penalised.

5. Wrong type for the property

Properties expect particular types, and validators do not always object when you supply the wrong one.

The example I hit most often is isPartOf on a WebPage pointing at an Organization:

// wrong: a page is not part of an organisation
"isPartOf": { "@id": "https://example.com/#brand" }

// right: a page is part of a website
"isPartOf": { "@id": "https://example.com/#website" }

Others worth checking: author should be a Person or Organization, not a string, if you want it to resolve to an entity. publisher should be an Organization. address should be a PostalAddress, not a single flat string. datePublished should be a date, not prose.

The fix: when a reference does not resolve to a node of the expected type, the relationship is silently discarded. Read the schema.org page for any property you are unsure about — the expected types are listed.

6. Two blocks describing the same thing differently

Common when a theme emits schema and an SEO plugin emits schema. The page ends up with two Article blocks with different headlines, or two Organization blocks with different logos.

Google has to pick, and you have handed it a contradiction on a page you control — which is worse than having emitted nothing.

How to spot it: count the JSON-LD blocks in your rendered HTML and list the types. Two of the same top-level type on one page almost always means duplication.

The fix: pick one source of truth. Disable your theme’s schema or your plugin’s, not both. If you hand-write schema alongside a plugin, make sure they are not both describing the same entity.

7. Plugin furniture markup

Many SEO plugins emit large volumes of markup for page furniture: SiteNavigationElement for menus, WPHeader and WPFooter, ImageObject for every decorative image, SearchAction for a site search that does not exist.

None of this produces a rich result and none of it helps Google understand your business. It is not harmful in itself, but it obscures the markup that matters and creates the impression that schema is handled when the entity nodes are missing entirely.

The fix: judge your schema by what it says about your entities and content, not by its size. If you have 200 lines of navigation markup and no @id on your Organization, your priorities are inverted.

8. Dates and formats

Small, mechanical, surprisingly common:

• Dates must be ISO 8601. 2026-09-01, not 1 September 2026 and not 01/09/2026 — which is ambiguous anyway.
• Prices are numbers without symbols. "price": "499" with "priceCurrency": "INR", not "₹499".
• Durations use ISO 8601 too. PT30M for thirty minutes.
• URLs must be absolute. Relative URLs in schema resolve unpredictably.
• dateModified should be true. Bumping it on every build to look fresh is a signal you are training Google to distrust.

9. Never testing the rendered page

The final failure is procedural. Schema is emitted by templates, and templates break. A changed variable name, a failed loop, a plugin update, a caching layer stripping a script block — and markup disappears from thousands of pages with no visible symptom on the page itself.

Build these habits:

1. Test the rendered HTML, not your template source. Especially with client-side injection.
2. After any template or plugin change, re-test one page of each type.
3. Watch Search Console’s Enhancements reports — they reflect real crawls across your whole site, not one URL.
4. Use both the Rich Results Test (eligibility, Google’s view) and the Schema Markup Validator (vocabulary correctness).

The pattern behind all nine: validators check whether your JSON is well-formed and your types exist. They cannot check whether your markup means what you intended, matches your page, or agrees with your other pages. That part is on you.

FAQ