Review schema attributed to the site’s own author is rejected by Google and penalised in GEO audits — and audit.py caught it before Google did
Testimonial blocks on thegeolab.net were attributed to Artur Ferreira — the same person who wrote the pages they appeared on. That’s a self-review. Google rejects self-review schema for rich results — review schema guidelines show this clearly. The AI Visibility Diagnostics Console found it first — I built that check specifically because I knew I’d do this eventually. I replaced every instance during the v3 migration. There were more pages than I’d like to admit.
The rule is simple: the reviewer cannot be the author. The fix is equally simple — but only if something is checking.
The Story
Google Search Console flagged Review structured data on thegeolab.net as invalid because the reviews were self-authored, not third-party. The GEO Lab published testimonials using JSON-LD Review schema where the author and the reviewer were the same entity. That credibility signal is the entire point — for readers, for Google, and for AI systems parsing structured data.
The operative phrase is someone other than the author.
The original testimonial blocks on thegeolab.net were attributed to Artur Ferreira. The pages were written by Artur Ferreira. From Google’s perspective — and from the perspective of any AI system parsing the Review schema — that’s not a testimonial. That’s an author reviewing their own work and calling it external validation.
No frontend symptom. No GSC warning. No broken layout. The pages looked fine. The schema was syntactically valid. The problem only surfaced when the audit system checked what the Review blocks actually said about who was doing the reviewing.
How It Was Caught
I built two overlapping checks in audit.py to catch this — one in Module 5 (GEO Compliance), one in Module 6 (AI Visibility). The overlap is deliberate: the first time I found a self-review, one of the checks had missed it.
Module 5 checks whether Review schema present on a page has a third-party author. It looks for itemprop="author" + itemprop="reviewBody" as microdata, or "@type": "Review" as JSON-LD, and passes only if the reviewer is not the same entity as the page author.
Module 6 runs dedicated self-review detection across the full page set simultaneously. It scans every Review JSON-LD block for the site’s primary entity names — “Artur” or “The GEO Lab” — in the reviewer field. When found:
Penalty: -2 points per page
Affected: what-is-geo.html, retrieval-probability.html, geo-stack.html, brand-citation.html
This is the category of failure that no ranking tool catches — not because it’s technically difficult to detect, but because per-page SEO tooling doesn’t audit the semantic relationship between reviewer and author across the full page set. The AI Visibility Diagnostics Console runs this check as part of every audit.
Going deeper? The GEO Pocket Guide covers the full 30-check protocol, section-level audit checklist, and citation rate tracking template — free to download.
Going deeper? The GEO Authority Playbook covers advanced citation strategy — entity reinforcement, structural authority, and the long-term signals that compound AI visibility over months.
Why Google Rejects Self-Reviews
Google’s review schema guidelines require reviews to come from third parties — not the author, owner, or publisher of the content being reviewed. The reasoning is straightforward: a review from the person who created the content being reviewed is not an independent assessment. It is marketing copy with structured data applied to it.
Self-review schema is not eligible for rich results. In cases where Google determines that reviews are systematically self-serving, it can trigger a manual action for fake reviews. The threshold for that outcome is higher than a few testimonial blocks — but the direction of travel is the same.
For AI systems, the issue is credibility signal. A Review block where the reviewer and the author share an entity name carries no third-party validation signal. It’s noise in the structured data, and the audit system treats it as such: 2-point deduction, flagged for immediate fix.
The Fix: Third-Party Review Microdata
All self-review testimonials were removed from every page during v3 deployment and replaced with reviews from independent practitioners who had applied the GEO Stack methodology. Two reviewers, deployed with full Review microdata and Rating schema.
This is the clearest breakdown of how AI retrieval actually works at the section level. The five-variable model gave our content team a concrete framework to audit every page — we stopped guessing and started measuring. Our citation rate improved within six weeks of applying the heading and opening sentence protocol.
The distinction between page-level SEO ranking and section-level retrieval probability is something I hadn’t seen articulated anywhere else. The testing protocol is practical — no paid tools needed, just disciplined query testing. I’ve shared this with every SEO lead in our network.
The Microdata Pattern
Both reviews use the same schema structure — itemscope / itemprop microdata, not JSON-LD, so the structured data is embedded directly in the visible HTML rather than in a separate script block.
<div itemscope itemtype="https://schema.org/Review">
<div itemprop="reviewRating" itemscope itemtype="https://schema.org/Rating">
<meta itemprop="ratingValue" content="5">
<meta itemprop="bestRating" content="5">
</div>
<div itemprop="author" itemscope itemtype="https://schema.org/Person">
<span itemprop="name">Daniel Cardoso</span>
<span itemprop="jobTitle">Head of Content Strategy, SaaSMetrics.io</span>
</div>
<div itemprop="itemReviewed" itemscope itemtype="https://schema.org/Thing">
<meta itemprop="name" content="Retrieval Probability in the GEO Stack">
</div>
<blockquote itemprop="reviewBody">
This is the clearest breakdown...
</blockquote>
</div>Three things that differ from the self-review pattern: the reviewer (itemprop="author") is a named third party, not the page author. The itemReviewed is set to the specific content topic, not the site as a whole. And the ratingValue and bestRating are present — required for rich results eligibility.
Failure Registry Entry
GEO audit flags self-review schema on multiple pages. Module 6 output: “Self-review schemas found: X pages — Google rejects author reviewing own article.” 2-point penalty per affected page.
Review schema blocks attributed to the site’s primary author (Artur Ferreira / The GEO Lab) rather than independent third parties. Syntactically valid schema — invalid semantically. No frontend symptom, no GSC warning at time of detection.
Remove all self-attributed Review blocks. Replace with third-party testimonials using correct Review microdata: independent reviewer, itemReviewed scoped to specific content topic, ratingValue and bestRating present.
audit.py Module 5 + Module 6. Module 6 scans every Review JSON-LD block for primary entity names in the reviewer field across the full page set simultaneously.
Added: 2026-03-12 · Fixed: 2026-03-12 (v3 deployment)
Review schema requires a genuine third-party reviewer — not the author, not the site owner, not a brand synonym. The audit.py self-review check extracts only the author.name field from Review microdata and JSON-LD and flags any match against the site owner’s name. Two-point penalty per affected page until resolved.
Frequently Asked Questions
Why does Google reject self-review schema?
Google’s review schema guidelines require that reviews come from third parties — not the author, owner, or publisher of the content being reviewed. A Review schema where the reviewer is the same person or entity as the page author is considered a self-serving review and is not eligible for rich results.
How do you correctly implement Review schema on a content page?
Use Review microdata with a third-party reviewer — someone who is not the author or publisher of the page. Set itemReviewed to the specific content or topic being reviewed. Include ratingValue and bestRating. The reviewer’s name, job title, and organisation should be real and verifiable.
What is the difference between a self-review and a third-party review in schema?
A self-review has the same person or entity as both the content author and the reviewer. A third-party review has a reviewer who is independent of the content — a different person, at a different organisation, reviewing content they did not create. Only third-party reviews are valid for Google’s Review rich results.
Does AI treat self-review schema differently from third-party reviews?
Self-review schemas carry a credibility penalty in AI systems. AI systems parsing structured data can detect when the reviewer and the content author are the same entity. Self-review schemas carry a credibility penalty in GEO audit scoring — the audit system flags any Review block where the reviewer name matches the site’s primary entity, and applies a 2-point deduction per page.
What Practitioners Are Saying
“The self-review detection in audit.py is elegant — it extracts the reviewer name from schema rather than doing keyword matching across the whole page. That means it catches edge cases that broad regex would miss, like a review attributed to a company the author controls.”
— Daniel Cardoso, Head of Content Strategy, SaaSMetrics.io
“I’ve seen this mistake on client sites repeatedly. The issue isn’t understanding the rule — it’s that CMS testimonial blocks default to pulling the site author’s profile. Publishing the exact audit check pattern is the useful part here.”
— Marco Silva, Technical SEO Lead, VisibilityStack