How to audit whether your schema is doing anything at all

A client called me last year convinced her site was "SEO-proof" because her developer had installed a schema plugin two years earlier. I opened her source code on a call. The FAQ schema was there, formatted correctly, sitting on a page that had quietly changed its FAQ copy four times since — and the markup still described questions nobody was asking anymore. It validated. It had never once triggered a rich result, and Search Console had been trying to tell her that the whole time. She just hadn't opened the report.

That conversation is the reason this article exists. "We have schema" and "our schema is doing anything" are two completely different claims, and almost nobody checks the second one. Plugins install markup once and never revisit it. Agencies bill for "schema implementation" as a line item and move on. Nobody comes back six months later to ask whether Google actually reads it, whether it matches what's still on the page, or whether an AI engine trusts it enough to use it in an answer.

Why "it validates" is the wrong bar

Google's own structured data documentation is explicit about this: adding valid structured data makes a page eligible for a rich result. It does not guarantee one. Google evaluates the underlying content quality, checks that the markup matches what's visible on the page, and reserves the right to ignore markup entirely if it looks manipulative, is thin, or doesn't reflect reality. A JSON-LD block that passes a validator is a well-formed letter. Whether anyone reads it is a separate question.

That gap is exactly where most sites get stuck. They pay for or install the letter, confirm it's spelled correctly, and never check whether it was ever opened.

Check one: does it parse?

Start with Google's Rich Results Test. Paste in the URL, not a code snippet — testing the live, rendered page catches problems a static code review misses, like markup that gets stripped by a JavaScript framework before it ever reaches the DOM Google crawls.

• Errors mean the markup is broken and Google will likely ignore that type entirely on that page.
• Warnings mean it's readable but missing recommended fields — usually still usable, but weaker.
• A clean pass with detected items means the letter is spelled right. It still says nothing about whether it gets opened.

Run this on one of every page template you have — homepage, a blog post, a product or service page, a location page if you have multiple. A single spot-check tells you nothing about the other 400 pages built from the same broken template.

Check two: is Google actually using it?

This is the check almost everyone skips, because it requires owning Search Console access and actually reading a report nobody assigned as a task. Under Search > Enhancements in Google Search Console, you'll find a report for each structured data type Google has detected across your site — FAQ, Product, Article, Breadcrumb, whichever types apply.

Each report shows a count of valid items, valid with warnings, and invalid items — measured across your whole site, not one page. If you shipped FAQ schema on 80 pages and the report shows 12 valid items, something broke on the other 68, likely a template that only renders correctly in some conditions. This report is also where you'll see Google quietly drop a type it decided to stop trusting — the valid count trending toward zero over a few months is the tell.

Check three: does it still match the page?

This is the one that broke my client's FAQ schema, and it's the one plugins can never catch because it's not a technical error — it's a content drift error. Schema.org's own getting-started documentation frames structured data as a description of what's actually on the page. When the page changes and the markup doesn't, you now have a page lying about itself, and Google's guidelines are explicit that mismatched structured data is grounds for ignoring it — or in serious cases, a manual action.

Do this by hand, once a quarter, on your highest-value pages:

1. Open the live page. Read the FAQ, product details, or article info a visitor actually sees.
2. Open the JSON-LD in view-source or a validator. Read the same fields.
3. Compare them side by side. Did a price change? Did an FAQ get rewritten in the CMS but not in the code? Did a product get discontinued but its Product schema is still live, still claiming "availability": "InStock"?

Sites that publish daily accumulate this drift fastest, because content changes constantly and schema templates rarely get touched after launch. If you're running the kind of publishing cadence we recommend in the case for daily content, put a schema-match check on the same calendar as your technical crawlability audit — both fail silently, and both get caught by the same discipline of actually looking.

The AI engine angle: schema as ground truth

Structured data doesn't feed AI Overviews, ChatGPT, or Perplexity the way it triggers a classic rich snippet — there's no equivalent "AI rich result" report to check. But it still matters to those engines for a more basic reason: it's the least ambiguous version of your facts on the page. An Organization schema block with a correct name, sameAs, and address removes any guesswork about who you are. A Product block with an accurate price removes any guesswork about what you charge. FAQ schema phrased as a real question and a direct, complete answer is close to the exact shape a language model is trying to extract when it decides what to quote.

We cover the structural side of that in the content that gets quoted — schema is the machine-readable half of the same discipline: say the true thing clearly, in a format nothing has to guess at. If your schema is stale or mismatched, you're not just risking a lost rich result. You're handing an AI engine a wrong fact about your own business, in the one format it's built to trust as structured ground truth.

What "doing nothing" actually costs you

Stale or broken schema rarely causes a visible penalty. That's exactly why it survives for years unnoticed — nothing breaks loudly. What happens instead is quieter and more expensive: a competitor's clean FAQ schema wins the featured snippet your outdated one used to hold. An AI engine cites the business down the street because their Product schema states the current price and yours states one from eighteen months ago. Your Rich Results Test still passes. Your dashboard still says "structured data: installed." Nobody ever gets an alert that it stopped working, because from a pure validation standpoint, it never broke.

The 20-minute version, if you do nothing else

If you only have time for one pass this week: pull up Search Console's structured data reports today, not the Rich Results Test. That single screen tells you, at scale, whether Google is reading what you shipped. If the valid count is healthy and climbing, move on. If it's flat, shrinking, or you don't recognize the numbers, that's your actual signal to go do the page-by-page match check — and it's a far better use of twenty minutes than re-running a validator on a page you already know parses.

Building this into a recurring habit

Schema audits fail for the same reason most technical SEO work fails: it's a one-time project instead of a standing habit. Put a recurring calendar reminder — quarterly is enough for most sites, monthly if you publish daily or run e-commerce with changing prices — to run all three checks on your top templates. Pair it with the broader discipline in why your best-performing page is invisible to AI crawlers, since a page that's unreachable to a crawler makes its schema irrelevant regardless of how clean the markup is. Treat the two checks as one habit, not two separate projects, and you'll catch both failure modes before they cost you a citation.

Italo Campilii

Founder, Acromatico · runs AI visibility & brand systems across 10+ live brands