Schema Markup Isn't a One-Time Job. Here's the Proof.

Quick read: Structured data (JSON-LD schema markup) can become invalid after a website is updated — a theme change, a plugin update, or a template edit can break it without producing any visible error on the page itself. Google's own documentation instructs site owners to check structured data validity both during development and again after deployment, since pages "might break after deployment due to templating or serving issues" (Google Search Central). An April 2026 audit of 5,000 production sites by Digital Applied found 71% deploy at least one schema type, but only 22% pass Google's Rich Results Test cleanly across every type detected — a 49-point gap between sites that have schema and sites that have schema that actually works (Digital Applied). Separately, a controlled Ahrefs study tracking 1,885 pages that added JSON-LD schema found no meaningful increase in AI Overview, AI Mode, or ChatGPT citations from the addition alone (Ahrefs).

I get a version of the same question every few months: "the schema thing you set up on our site — is that still working?" It's a fair thing to wonder, and the honest answer more often than not is: probably not exactly. Not broken in a way that throws an error banner. Just quietly out of date — a phone number that changed eight months ago, an hours block that never got updated for the new holiday schedule, a price that moved and took the visible page with it but left the JSON-LD sitting underneath untouched.

Nobody notices, because nothing looks wrong. The page renders fine. The business owner has no reason to suspect that the block of code search engines and AI tools actually read is telling a different story than the page a human sees.

What a structured-data audit actually is (and isn't)

Structured data is the JSON-LD block on a page that spells out, in a format machines parse exactly, what a business is, where it operates, what something costs, or what a page is answering. Setting it up is a one-time task: write the block, validate it, ship it. That's the part most guides — including one of our own, on a 20-minute LocalBusiness setup — cover, and it's genuinely useful groundwork.

An audit is a different, recurring task: going back later and confirming the block still matches reality and still validates, after the site has changed underneath it. Google is explicit that this isn't a one-and-done step — its own developer documentation says to check structured data with the Rich Results Test during development, and then keep watching the Rich result status reports after deployment, "to monitor the validity of your pages, which might break after deployment due to templating or serving issues" (Google Search Central). That's Google telling site owners, in its own documentation, that this is an ongoing check, not a launch-day checkbox.

Why this is easy to miss if you're running the business, not the website

A website isn't static. Prices change. Hours change for a season. A plugin updates itself over a weekend and quietly restructures how a page template renders. A redesign swaps out a review widget. None of that necessarily breaks anything a visitor would notice — the page still looks right, still loads, still takes orders. But the structured data sitting in the page's source, unseen by anyone scrolling through it, can drift out of sync with the actual page or break outright, and there's no banner that tells you when it happens.

That gap is exactly what Digital Applied's audit measured at scale: across 5,000 production sites spanning eight content management systems, 71% had deployed at least one schema type, but only 22% passed Google's Rich Results Test cleanly across every type the site emitted. Nearly half the sample — 49% — sat in what the audit called the "deployed but broken" tier: schema that exists, was presumably set up correctly at some point, and no longer validates (Digital Applied). That's not a story about businesses skipping schema. It's a story about schema being set up once and never checked again.

I ran a dog grooming salon for years before any of this, so I know exactly how much time there was at the end of a day of appointments to go double-check a block of code nobody could see. None. That's not a knock on any business owner — it's the actual, honest math of running a small business. This is the part of the website nobody warns you gets stale on its own, not something you forgot to do.

The mechanics: what a quarterly audit actually checks

A structured-data audit isn't complicated, but it has to be recurring to catch anything, since drift happens gradually and invisibly:

• Re-run the Rich Results Test against a real page from every template, not just the homepage. Digital Applied's finding that only 22% pass cleanly "across every type detected" matters here — a single clean homepage doesn't mean the service pages, the blog template, or the contact page are clean too. Template-level errors repeat on every page built from that template.
• Cross-check the schema's actual field values against what's true on the site right now — phone number, hours, price ranges, address details. This is the drift Google's own guidance flags: nothing about a passing validator test proves the data inside is current, only that it's syntactically correct.
• Check for new schema requirements or deprecations. Google has changed what it does with structured data before — FAQ rich results themselves were removed from search in May 2026, which meant markup that used to earn a visible dropdown stopped doing anything for that purpose overnight, even though the code itself was never broken. An audit is what catches "this used to matter and doesn't the way it did" as much as it catches outright errors.
• Confirm nothing from a recent plugin, theme, or page-builder update reshaped the templates that emit the JSON-LD. This is the most common real-world cause of schema quietly breaking, and it's invisible from the front end — the page still renders correctly for a human visitor even when the markup underneath it doesn't.

What won't help

• Treating initial setup as the finish line. A schema block that validated on launch day tells you nothing about whether it still validates six months and four plugin updates later.
• Expecting schema fixes alone to move AI citations. Ahrefs' controlled test — adding JSON-LD to 1,885 pages that were already being cited heavily — found no meaningful citation lift from the addition by itself (Ahrefs). Clean structured data is table stakes for being read correctly, not a lever that pulls in more AI visibility on its own.
• Trusting a plugin's "schema enabled" toggle without ever validating what it actually outputs. A toggle being switched on is not the same claim as a page passing the Rich Results Test.
• Checking one page and assuming the whole site is fine. Errors introduced by a shared template show up everywhere that template is used — checking a single URL can miss the pattern entirely.

FAQ

What is a structured-data audit?

It's a recheck of the JSON-LD schema markup already on a site — confirming it still validates and still matches what's actually true about the business (hours, pricing, contact details) — done on a recurring basis rather than once at launch.

How is this different from setting up schema markup the first time?

Setup is writing and validating the code once. An audit is checking it again later, after the site has changed, since updates to themes, plugins, or content can invalidate structured data without producing any visible error on the page.

How often should a small business audit its structured data?

There's no universal rule, but quarterly is a reasonable baseline for a site that gets regular content or plugin updates — frequent enough to catch drift before it's been live and wrong for the better part of a year.

Will fixing structured data errors get me cited more by AI search tools?

Not automatically. A controlled Ahrefs study found adding schema markup to pages that were already heavily cited produced no meaningful increase in AI Overview, AI Mode, or ChatGPT citations. Clean schema helps machines read a page accurately — it isn't a citation lever on its own.

What actually breaks structured data on a small business site?

Most commonly a theme update, a plugin update, or a page-builder change that alters how a template renders — none of which necessarily change how the page looks to a visitor, which is exactly why the break goes unnoticed.

Do I need to hire someone to do this, or can I check it myself?

Google's Rich Results Test is free and public, so a one-time check is doable solo. The part that's easy to let slip is doing it again next quarter, and the quarter after that, once the business gets busy.

What's the fastest way to check if my schema is still working right now?

Run a live page from each major template on your site through Google's Rich Results Test and compare the parsed output against what's actually true about the business today — that's the whole audit, just done on a schedule instead of once.

---

A quarterly structured-data check is one of the smaller, more overlooked pieces of what an ongoing website Care engagement actually does month to month — not glamorous, but it's the kind of thing that only matters when nobody has to think about it.