How review schema actually works
Search engines don't read your page the way a homeowner does. They read code. When a browser renders your testimonials section, a person sees five gold stars and a name. Google's crawler sees HTML, and unless that HTML is wrapped in a specific structured-data format, the crawler has no reliable way to know "4.8 stars" is a review aggregate versus a decorative graphic or a made-up claim.
Review schema solves that by adding a JSON-LD script (a plain-text data block, invisible to visitors, sitting in the page's code) that names the business, states the review count, states the average rating, and often nests the individual reviews themselves. Google's algorithm parses that block against its own trust rules before it decides whether to render stars in the search snippet. The two schema types that matter here are AggregateRating (the rollup: rating value, review count) and Review (individual review objects, each with an author and a rating).
This is separate from whatever review widget your website vendor bolted on. A widget can display stars beautifully on the page and still ship zero structured data underneath it. That's the trap: the page looks right to a human and is invisible to the algorithm.
- AggregateRating without correct itemReviewed linkage: often ignored
- Reviews pulled live via JavaScript with no server-rendered schema: frequently missed by crawlers
- Self-serving schema (a business marking up its own claimed rating with no third-party source): against Google's guidelines and a fast way to lose rich results sitewide
The mechanics aren't exotic. What's inconsistent is whether the contractor's site (or the reputation software running behind it) actually implements them, keeps them in sync with the live Google Business Profile number, and avoids the shortcuts that get snippets revoked.
Why contractors specifically lose this one
Most contractor websites are built by a general web shop, a WordPress theme, or a DIY builder. Review schema is a backend detail with no visible payoff in the page preview, so it's the first thing skipped on a deadline. A roofer or an electrician can go years with a strong reputation and a site that has never once told Google what that reputation is.
There's a second failure mode specific to trades: multi-location and multi-crew businesses. A plumbing company with three service branches, or an electrical contractor running review requests through a CRM after every job, ends up with review data scattered across a Google Business Profile, a review-request platform, and a testimonials page that was hand-typed by whoever built the site in 2019. None of those three sources talk to each other, so even if one of them has correct schema, the other two don't, and Google sees conflicting numbers for the same business.
A third failure is staleness. Google can grant a rich snippet, then quietly pull it weeks later if the schema's review count or rating stops matching what's actually on the business's public review profiles. A site that hardcoded "127 reviews, 4.9 stars" in January and never touched it again is showing a number that drifts further from true every month new reviews come in. Search engines cross-check this. Stale schema is a common reason a contractor had stars in results last year and doesn't now.
| Common contractor setup | What usually goes wrong |
|---|---|
| WordPress theme's built-in "testimonials" widget | Displays text and a graphic; no schema markup generated at all |
| Third-party review widget embedded via JavaScript | Schema loads client-side only; crawler never sees it render |
| Hand-coded static site, reviews added by hand | Schema written once, never updated as new reviews come in |
| Multi-location trade business | Each location page shows a different, unsynced rating |
What a rich snippet is actually worth to a contracting business
A rich snippet is the gold stars, the review count, and sometimes a price range that appear directly under a search result's blue link, before anyone clicks through. It's the single most visible piece of real estate Google gives a local business in a results page that costs nothing to bid on.
For a home-service business, the practical effect is a comparison happening in a fraction of a second. A homeowner searching "emergency plumber near me" is scanning five to eight results. Two show stars. Three show plain text links. The two with visible stars get looked at first, purely on pattern recognition, before a single word of the listing is read. That's not a ranking-position advantage (schema does not move a page up or down the results), it's a click-through advantage at whatever position the page already holds.
This matters more in trades where the buying decision is urgent and comparison-shopped fast: plumbing, HVAC, electrical, garage door, and locksmith searches skew toward same-day intent. A homeowner with water on the floor is not reading five listings closely. They're picking the one that visually signals "other people vouched for this" fastest.
It also compounds with how AI answer engines source information. When a homeowner asks ChatGPT or a Google AI Overview "who's a good electrician near me," those systems lean on structured, verifiable data over prose they'd have to interpret. A clean AggregateRating block is a citeable fact. A paragraph on a testimonials page claiming "hundreds of five-star reviews" with no schema behind it is a claim the engine has less reason to trust and repeat.
- Rich snippets do not change ranking position, they change click-through rate at the position you already have
- The effect is strongest on urgent, same-day trade searches
- Structured review data is also what AI answer engines prefer to cite over unmarked prose claims
The setup that keeps schema accurate over time
The fix isn't a one-time code snippet pasted into a site and forgotten. It's a system that keeps the schema's numbers matched to what's actually true on Google, month after month, as new reviews land.
The pieces that need to work together:
- A live source of truth. The Google Business Profile rating and count, pulled on a schedule, not typed in by hand.
- Server-rendered JSON-LD. The schema block has to be present in the HTML a crawler receives, not injected after the page loads via JavaScript the crawler may not execute.
- A refresh cadence. Every new review changes the aggregate. The schema on the page should update on a routine cycle, not sit static for a year.
- Genuine reviews only. AggregateRating markup for reviews that don't actually exist on a public, verifiable platform violates Google's structured-data guidelines and risks a manual action, not just a lost snippet.
- Consistency across every location page. A multi-branch contractor needs each location's schema tied to that location's actual Google Business Profile, not one company-wide number pasted everywhere.
This is where review schema stops being a one-off developer task and becomes part of an ongoing reputation system: the same system that's requesting reviews after every completed job, monitoring for new ones, and drafting responses to the occasional bad one. The schema is the last mile, the part that takes reviews already being earned and makes them visible where a homeowner is searching.
Get this wrong (fabricated numbers, stale counts, self-attributed ratings with no third-party source) and the risk isn't just a missing snippet. Google has pulled rich-result eligibility from entire sites over schema abuse. Get it right and it's maintenance, not a project: a rating that stays true because it's pulled from source, not typed once.
Where this sits next to the rest of your reputation work
Schema is a display layer sitting on top of a business that already has to be earning and managing reviews for schema to matter at all. It's worth being clear about where the line falls, because contractors often ask a reputation shop to fix "the stars" when the real gap is upstream of the code.
Getting more reviews in the first place (asking every customer after a completed job, timing the request right, making it a one-tap process from a phone) is what builds the review count and rating that schema then reports. No amount of correct markup helps a business with twelve reviews and a 3.6 average. Schema doesn't inflate a number, it reports one honestly. If the underlying rating needs work, that's a review-generation and response problem to solve first, not a code problem.
Responding to reviews, especially the rare bad one, is a related but separate discipline. A thoughtful public response to a 2-star review doesn't change the schema's average, but it does change how a homeowner reads the full picture once they click through past the stars. The stars get the click. The reviews themselves, and how the business responded, close the job.
Monitoring is the third leg: knowing the moment a new review lands, across every platform a customer might have used, not just the one the owner happens to check. A business getting reviews on Google, Facebook, and a trade-specific directory needs someone watching all three, because schema built off Google alone will understate a business that's also earning reviews elsewhere.
Put together, review schema is the last of four connected jobs: generate the reviews, monitor where they land, respond to the ones that need it, and then mark all of it up so search engines and AI answer engines can see it accurately. Fixing only the schema on a business that isn't generating new reviews buys a short-term snippet and a long-term stale number. Fixing only the review generation without the schema means the reviews exist and nobody searching sees the proof.
What to check on your own site right now
You can get a rough read on where your site stands without waiting on anyone. It won't tell you everything a full audit would, but it'll tell you if there's an obvious problem, and every one of these checks takes under five minutes.
- Search your own business name on Google and look at your own listing. No stars under the link is the first sign something's missing.
- Right-click your homepage, view page source, search for "AggregateRating." If it's not there, no schema exists for reviews on that page at all, no matter how the stars look visually on the page.
- Run your URL through Google's Rich Results Test (a free tool Google itself provides). It will tell you plainly whether it detects valid review markup or flags an error on what's already there.
- Check if the number on your site matches your live Google Business Profile. A mismatch, even a small one like 4.8 shown against a true 4.9, is a sign the schema was hand-set once and never refreshed since.
- Check every location page separately if you run more than one branch or service area. Rich-result eligibility is evaluated per page, not company-wide, so one clean location doesn't cover the rest.
If any of those checks come back negative, the schema either doesn't exist, is broken, or is stale. All three are common on contractor sites, and all three are fixable without touching the actual review-generation process underneath. The reviews already earned don't need to change. The code around them does.