Structured Data Decay: Your Schema Broke and Nobody Noticed

The silent failure mode of structured data

Structured data is the part of your page no human reads, JSON-LD tucked in a script tag, telling machines unambiguously "this is a Product, it costs $129, it has 4.6 stars from 240 reviews, here are the FAQs." When it is valid, it earns rich results in Google (star ratings, prices, FAQ accordions, breadcrumbs) and makes your page far more legible and citable to AI answer engines. When it breaks, none of that happens, and crucially, nothing tells you.

That is what makes it decay rather than crash. A broken API throws errors someone sees. Broken schema just stops qualifying for enhancements. Your page still renders perfectly for users. Your CMS does not warn you. Your analytics show a gradual softening of clicks that is easy to attribute to seasonality or algorithm updates. The actual cause, a single missing required field introduced by a template change three sprints ago, sits invisible in the markup.

What "broken" actually means

Schema breaks in specific, recurring ways. Google distinguishes errors (which disqualify the rich result entirely) from warnings (recommended fields you are missing). Per Digital Applied's schema reference, the high-frequency failure modes are:

• Missing required fields. A Product without a name or offers, an Article without a headline, an Event without a startDate, no required field, no rich result.
• Wrong date format. Dates not in ISO 8601 (2026-01-15) are silently ignored by validators, so date-dependent enhancements quietly drop.
• Type mismatches. A price as "$129.00" (string with currency symbol) where a number is expected, or a rating outside its declared scale.
• Markup-content mismatch. Schema that asserts a price, rating, or availability the visible page does not show, a structured-data policy violation that can trigger manual actions.
• Orphaned references. Nested entities (aggregateRating, review) referencing fields that no longer exist after a refactor.

Why AI raises the stakes

Schema was always an SEO lever for rich results. The AI era made it a discovery lever too. Answer engines use structured data as one of the cleanest signals of what a page is and what facts it asserts, a machine-readable summary they can trust more than parsed prose. The measured difference is large. Per the 2025 citation study Averi summarizes, pages with FAQPage schema achieved a ~41% AI citation rate versus ~15% without it, roughly 2.7x, and broader analyses find content with proper schema markup has around a 2.5x higher chance of appearing in AI-generated answers.

So when schema decays, you lose on two fronts simultaneously: the rich results vanish from Google, and your AI citation eligibility drops. It is the same failure as the alt-text and rendering gaps, a machine-readability problem that costs you in both the old channel and the new one. And like those, it is fully detectable; you just have to look.

<!-- A Product + nested FAQ, the way an answer engine wants it -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trailhead Waterproof Hiking Boot",
  "image": "https://example.com/sku-48213.jpg",
  "description": "Waterproof, 4-season trail boot with Vibram sole.",
  "brand": { "@type": "Brand", "name": "Trailhead" },
  "offers": {
    "@type": "Offer",
    "price": "129.00",        // number-as-string, NOT "$129.00"
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",     // must match the scale + visible stars
    "reviewCount": "240"
  }
}
</script>

Validate on every deploy, not once

The cure for decay is continuous validation. A one-time setup with Google's Rich Results Test confirms the schema was valid the day you shipped it, and tells you nothing about the refactor that broke it next quarter. You need validation in the pipeline, asserting that required fields are present and correctly typed on every build, before the change reaches production.

# CI gate: validate JSON-LD on critical templates before deploy
import json, requests, sys
from bs4 import BeautifulSoup

REQUIRED = {
    'Product': ['name', 'offers'],
    'Article': ['headline', 'datePublished'],
    'FAQPage': ['mainEntity'],
    'Event':   ['name', 'startDate', 'location'],
}

def validate(url):
    soup = BeautifulSoup(requests.get(url, timeout=15).text, 'html.parser')
    blocks = soup.find_all('script', {'type': 'application/ld+json'})
    if not blocks:
        return [f'{url}: NO JSON-LD found']
    errors = []
    for b in blocks:
        try:
            data = json.loads(b.string)
        except json.JSONDecodeError as e:
            errors.append(f'{url}: invalid JSON-LD ({e})'); continue
        t = data.get('@type')
        for field in REQUIRED.get(t, []):
            if field not in data:
                errors.append(f'{url}: {t} missing required "{field}"')
    return errors

problems = [e for u in sys.argv[1:] for e in validate(u)]
for p in problems: print('FAIL', p)
sys.exit(1 if problems else 0)
# Run against your template's representative URLs in CI.

Keep markup and content honest with each other

One decay mode deserves special attention because it can earn a manual penalty rather than a quiet drop: schema that contradicts the visible page. If your structured data claims a 4.8 rating, a $99 price, or "in stock, " the page must actually show those. A common decay path is when the content source of truth changes (a price update, a sale ending) but the schema, generated from a different data path, does not. The page says one thing, the JSON-LD says another, and Google treats the mismatch as a policy violation. A validation gate should assert not just that fields exist, but that key values match what the rendered page displays.

The bottom line

Structured data is invisible infrastructure that fails silently: a template change drops a required field or breaks a format, rich results disappear, AI citation eligibility falls, and your analytics show only a vague softening you blame on something else. With schema worth roughly 2.5-2.7x more AI citations, that decay is expensive. Treat JSON-LD like the production code it is, validate required fields and types on every deploy, monitor Search Console enhancement reports for drops, and assert that your markup matches your visible content. The schema you set up once and never checked is probably already decaying. Go look.