Skip to the indexed answers
Digital Marketing Index

usdigitalmarketingindex.com SEO

How can a plugin update introduce structured data errors across an entire site?

Because structured data on a content management system is produced by a template, not written page by page. A plugin holds one piece of code that builds the markup for every post, product, or recipe. When an update changes that code, every page generated from it changes at the same moment. A renamed property, a field that no longer maps to its source, a second block emitted alongside the first: each is a single change that appears on every URL of that type. Nothing was edited on any individual page, which is why the fault can go unnoticed. The reverse is also true, and it is the useful part. One fix, or one rollback, corrects every page at once.

Template-generated markup

How the markup reaches the page:

Content fields (title, price, author, date)
        |
        v
Plugin template code  --->  one JSON-LD block per page
        ^
        |
Plugin settings and theme hooks

An update can alter any of the three inputs.

What the update changes Resulting fault
Output code A required property is dropped or renamed; a type changes
Field mapping A property is filled from the wrong field, or left empty
Settings A default resets, switching a feature off or on
Interaction with the theme The theme and the plugin both emit markup for the same item
Interaction with another plugin Two plugins describe the same entity differently
Escaping or encoding Characters in content break the JSON, so the block cannot be parsed
Loading method Markup moves from the served HTML to script-inserted, or the reverse

None of these needs a mistake by the site’s editors. The site did what it did the day before, with different code.

Change detection

Two sources show that something changed.

Reports. Search Console’s enhancement reports, one per supported rich result type, show counts of valid and invalid items over time. A step change in invalid items that begins near the update date, across many URLs, with one error type, is the signature of a template fault. These reports depend on Google recrawling pages, so they trail the change.

Direct inspection. This does not wait for recrawling.

  1. Pick one URL from each template: a post, a product, a category, the home page.
  2. Run each through the Rich Results Test.
  3. View the page source and find the JSON-LD blocks. Count them and read them.
  4. Compare with a copy from before the update, if one exists.

The fourth step is where preparation pays. A site that keeps a saved sample of each template’s markup can compare old and new directly.

A comparison for one template, as an illustration with invented values:

Property Before update After update
Type Product Product
name Present Present
image Present Present
offers.price 24.00 Missing
offers.priceCurrency USD USD
aggregateRating Present Present, emitted twice

Scope diagnosis

Establish how far the fault reaches before fixing it.

Question How to answer
Which templates? Test one URL per template
Every page of the template, or some? Test several pages with different content: with and without a price, an image, a rating
Which property? Read the error in the Rich Results Test and find it in the source
Since when? Match the first error date in the report against the update log
Which component? Read the plugin's changelog; disable the suspect on a staging copy and retest
Is the markup duplicated? Count blocks of the same type on one page
Served or script-inserted? Compare the raw source with the rendered HTML

A fault that appears only on pages with a certain kind of content, such as products with no reviews, points to a field mapping problem. A fault on every page of a template points to the output code.

Rollback and verification

A sitewide error incident record, with assumed values:

Incident:        Product markup missing offers.price
Detected:        Day 3 after update, Search Console merchant listings report
First affected:  Day 0 (plugin update applied)
Scope:           All product pages (template: single product); 1,840 URLs
Not affected:    Posts, categories, home page
Cause:           Update changed the price field name read by the schema module
Evidence:        Rich Results Test on 3 products; source comparison with saved sample
Action:          Rolled back plugin to previous version on Day 3
Verification:    3 products retested, price present; saved sample matches
Follow-up:       Report vendor issue; hold update until fixed release; retest on staging
Search Console:  Validation requested on Day 3; monitor until invalid count falls

Recovery steps:

  1. Restore the previous version of the plugin, or apply the vendor’s fix if one exists. Do this on staging first where possible.
  2. Clear caches, so pages are regenerated with the corrected markup.
  3. Retest the same sample URLs. Confirm the property is back and that there is one block per item.
  4. In Search Console, use the validate fix option on the affected issue.
  5. Watch the invalid count. It falls as pages are recrawled.

On consequences, stay with what is documented. Google’s documentation says “You must include all the required properties for an object to be eligible” for a rich result (Google’s introduction to structured data), so pages missing one are not eligible while the fault lasts. What that does to clicks on a particular site is a question for that site’s own performance data.

Prevention:

Practice Effect
Staging site with updates applied first Faults seen before they reach visitors
Saved markup sample per template A baseline to compare against
Test one URL per template after every update Detection at the time of the update, before the reports show it
Automatic updates off for schema-producing plugins, or scheduled with a check No unobserved changes
One component responsible for each type of markup No duplicates from theme and plugin together
An update log with dates The cause can be matched to the start of errors

Structured data is not the only thing a release can change without anyone intending it. Comparing two full crawls of the site, taken before and after, shows the other differences, and that method is described in the guide to how two site crawl snapshots reveal unintended changes after a code release.

The order of work: confirm on sample pages, find the template and the property, roll back or fix once, retest the samples, then let the reports catch up.

Link trail

Reader comments on this answer

Add your comment to this answer

Your email address will not be published. Required fields are marked *