David Bynon

Most Schema case studies show off what worked. This one shows what didn’t — and why that matters more than people think.

Here’s what happened when I deployed Dataset Schema to MedicareWire.com — without fully aligning it with visible citations and structured content blocks:

What you’re seeing here is a correction.
An early spike in valid datasets… followed by a sharp decline, a rising stack of invalid items, and a steady loss of Schema trust.

Why am I showing this?

It comes down to this one fact. You can’t learn what works until you discover what doesn’t work. So I have been using my MedicareWire site as a punching bag.

To be fair, Google relegated MedicareWire to the trash heap anyway. It couldn’t fall much lower. So, using it as a test platform makes perfect sense. And it has been teaching me a lot.

---

The Mistake: Schema Without Trust

The initial Dataset Schema was technically valid. It passed markup checks and included CMS.gov source URLs.
But it lacked supporting structure in the page body.

Specifically, it had:

• No linking of data points to their sources
• No human-readable citations visible on the page
• No semantic structure around data values

In short, it was Schema… without a trust layer. Google’s response was to call bullshit on what I was publishing.

---

How Google Responded

At first, it accepted the markup — 131 valid items were indexed. But over time, as the algorithm deeply evaluated the content and schema, it found a misalignment and started pulling back.

The result: 131 invalid items, and a stall in dataset visibility.

Google didn’t just stop crawling. It re-evaluated the trust signal — and demoted it.

---

The Lesson: Trust Must Be Visible and Verifiable

You can’t publish Dataset Schema in a vacuum. If Google can’t see the proof — it stops believing the markup.

That’s why TrustStacker now enforces:

• Inline TrustTags™ for every key fact
• Matching Dataset Schema with identical human-readable citations
• Semantic layout (TrustBlocks) to deliver content Google and AI systems can understand

This Proof Drop isn’t a loss. It’s a warning — and a reminder that trust must be engineered across every layer.

— David W. Bynon

This isn’t a theory post. It’s not about what Schema might do.
It’s about what Google just did.

As of June 2025, Google has indexed 828 valid Dataset Schema items across Medicare.org — with zero errors and in the past 30 days.

Every one of those datasets points directly to a structured content block built with TrustStacker™ and backed by CMS.gov source data.

---

Why This Matters

Google isn’t just crawling these pages. It’s recognizing the Dataset Schema, parsing the CMS citations, and validating the structure at scale. And it’s doing it on a templated publishing system.

This is rare in YMYL. Most competing publishers are:

• Skipping Dataset Schema entirely
• Showing tables of thin data
• Not citing the plan carrier’s phone numbers or URLs
• Using generic text without source attribution
• Using repetitive template paragraph garbage without search intent facts

But the plan pages I’m crafting on Medicare.org are:

• Structurally consistent
• Source-backed with CMS.gov URLs
• Displaying human readable citations that match the Schema’s dataset reference
• Showing a wide variation of smart template content enriched with search intent facts
• Including the plan provider’s contact information and plan page information URLs

—

What This Proves About Trust at Scale

This isn’t a few hand-coded test cases. This is across a live production environment — all passed by Google, all traceable to federal source material.

It proves that:

• Dataset Schema works — even in regulated content environments like Medicare
• Google rewards source-backed structure over generic Schema injections
• Trust can be engineered at scale — page by page, plan by plan
• EEAT isn’t just a ranking theory — it’s a system you can operationalize

---

How It Works

Each dataset was generated using TrustStacker™ methods that specifically tie a creator’s dataset (in this case from CMS.gov) to machine readable, structured data, on a self-hosted API endpoint.

No tricks. No affiliate hype. Just transparent, machine-parsable Medicare data tied to its real source.

—

This Is EEAT in Data Form

You can’t fake this. You can’t buy this.
You either have structured trust, or you don’t.

Google knows the difference. And with every dataset it indexes, it’s making a decision:
“This data can be trusted.”

That’s what I’ve built. And this GSC report proves it.

— David W. Bynon

In June 2025, I opened up Search Console and saw something rare — especially for a regulated healthcare domain.

1,160+ valid Review Snippets.
0 errors.
Climbing impressions — in a YMYL category.

This isn’t a fluke. It’s a signal: Google trusts this structure enough to feature it in live search results.

---

Why Review Schema Is Rare in YMYL

In healthcare and finance, Google aggressively filters out `Review` and `AggregateRating` markup — especially when it:

• Comes from affiliate sites
• Is auto-generated or thin
• Lacks citation or author credibility

But my review data isn’t generic:

1. It’s structured
2. It’s source-backed
3. It was published in a trust-layer

That’s why it passed — and why it continues to grow.

---

How This Works

Every plan page on the Medicare content sites I manage are powered by my TrustStacker™ system, which handles:

• Fact-level attribution using TrustTags™
• Defined glossary context with TrustTerms™
• Helpful summaries and FAQs with TrustBlocks™
• Organization + author clarity via TrustOrg™
• Review markup injected only when verifiable, attributed, and relevant

There’s no gaming it. No template spam. No plugin bloat.
Just a clean, intentional, structured trust system.

---

What This Tells Us About EEAT

Google isn’t just crawling this markup — it’s validating it, indexing it, and displaying it.

That means:

• EEAT isn’t just page-level. It’s data-level.
• Google will trust reviews — if they’re structured and source-backed.
• This site isn’t just trusted. It’s trustworthy by design.

---

Proof in Practice

Review Schema is live now across 1,160+ plan pages — and climbing.
You can see them in GSC or find them on MedicareWire and Medicare.org directly.

This is what happens when you stop chasing Schema tricks… and start engineering trust.

— David W. Bynon

Ever since I started down this EEAT discovery path I’ve had a morning ritual. With my coffee I look to see how my content and structure experiments influence search results.

In Medicare, a massively difficult Your Money or Your Life (YMYL) topic, people frequently search using the government’s plan identifier. So I do the same.

This morning, when I searched a Medicare Advantage plan ID I’ve published about for years, H8003-007, what I found wasn’t just a blue link or a snippet.

It was a full-blown Google AI Overview — citing my content, extracting real copay amounts, and confidently displaying them to users before they even visit the site.

This is what structured trust looks like in the wild.

Google’s AI Overview stated, in plain language:

• In-Network Specialist Visit: You pay a $30 copay per visit.
• Out-of-Network Specialist Visit: You pay a $45 copay per visit.

That data came directly from the Medicare.org plan page — a page powered by TrustStacker™, structured with TrustBlocks™, and backed by fact-level TrustTags™.

There was no structured table Schema (Microdata). Just clean, modular, machine-readable content Google could verify.

How is Google verifying the content? Simple. The page provides proof of the source of the data. Plus, the pages uses high user interest data in natural language (paragraphs).

---

What This Tells Us About Google’s Trust Model

Google didn’t just parse the plan page. It understood it. And it surfaced content in one of the most risk-sensitive areas in search — Medicare plan information.

This tells us five things:

1. Google can extract structured facts from content without Schema, if the format is clear
2. AI Overview inclusion is about confidence, not keyword density
3. Brand trust — like Medicare.org — amplifies data reliability
4. Semantic structure matters more than visual layout
5. You don’t get included in an AI Overview unless you’re provable

---

This Is the Real Proof of EEAT

Most sites are still chasing “helpful content” updates with generic summaries and lazy Schema. Meanwhile, Google just used my TrustStacker-powered content to speak for Medicare plan information.

This is EEAT in practice:

• Content that maps to real-world questions
• Facts that are precise and easily labeled
• Pages that carry enough to appear in AI-generated responses

And this wasn’t a fluke. This was structured trust in production, at scale.

I didn’t write about Medicare — I built systems to publish verified Medicare facts, at scale.

Google sees experience in:

• Accuracy of values
• Contextual phrasing
• Local and plan-level nuance
• Consistent terminology

Expertise is demonstrated structurally.

It’s not “David knows Medicare.”

It’s: “This framework generates, verifies, and explains data that experts would trust.”

I’m showing expertise through:

• Clean layouts that match how users search
• Accurate summaries of complicated plan rules
• Dataset Schema aligned with CMS sources

---

What Comes Next

This is just one example. TrustStacker is now powering thousands of plan pages across MedicareWire.com and Medicare.org. And each week, I’ll publish more insights like this — here on EEAT.me.

The AI Overviews are here. The algorithm is shifting. And the only thing that cuts through now… is proof.

— David W. Bynon

March 2024 hit me like a freight train.

One morning I woke up and found that MedicareWire.com — my decade-old, compliance-first, medically reviewed publishing machine — had been gutted by Google’s “Helpful Content” update.

No warnings.

No penalties.

Just gone.

Traffic collapsed. Rankings disappeared. And not because the content was wrong. It was accurate. It was helpful. But it wasn’t structured. It wasn’t provable. It wasn’t engineered for trust.

---

What the Crash Revealed

That update showed me the hard truth: Google doesn’t care what you say — it only trusts what it can prove.

My content had all the facts… but no proof.

It had experience… but no traceable provenance.

It had authority… but no semantic trust signals.

And that’s when I realized: EEAT isn’t a checklist. It’s infrastructure.

---

Rebuilding the Site — and the System

I didn’t chase traffic. I didn’t fire off AI spam. I started engineering trust. From the bottom up.

• I built TrustTags™ to make every claim, stat, and number provable — right at the data-atom level.
• I created TrustTerms™ to define glossary concepts using Schema.org’s DefinedTerm — because vague language isn’t trustworthy.
• I built TrustBlocks™ to publish helpful content (summaries, FAQs, takeaways) in a way that machines and humans could both digest.
• I layered in TrustOrg™ to tell Google exactly who we are, what we know, and why we’re publishing.
• And I developed TrustFeed™ to distribute unique, platform-optimized content across X, LinkedIn, newsletters, podcast feeds — even PR drops.

I didn’t just fix a site. I wrote the framework Google was waiting for.

—

Introducing: Trust Publishing

I call it Trust Publishing — a modular framework designed to structure trust across and entire content stack.

It powers everything I now do at MedicareWire.com and Medicare.org. Thousands of plan pages, glossary terms, and FAQ blocks now ship with structured citations, ADA-ready markup, and platform-specific GPT pipelines.

This isn’t theory. It’s already running. It’s protected. And starting today, I’m publishing the entire system — right here, on TrustPublishing.com.

—

What Comes Next

Each week, I’ll break down a piece of the system:
From fact-level Schema injection to speakable voice blocks to AI-safe trust distribution at scale.

Because if EEAT is going to mean anything… it needs to be something we can build, measure, and repeat. Together.

The code is coming. One byte at a time.

— David W. Bynon