A green tick in Google's Rich Results Test does not mean your post will get a rich result. It means the markup is eligible, and the test only checks two of the five JSON-LD types this blog ships.
This blog is Markdown rendered by Next.js, with no CMS and no SEO plugin, so every line of its structured data is code I can show you. Person, WebSite, BlogPosting, BreadcrumbList and FAQPage, all generated from front matter.
This post walks through:
- the real code
- why generating it from one source prevents drift
- a bug I found while writing it
- what the test checks and ignores
- why FAQPage stays.
I don't have Search Console numbers worth publishing for these types yet, so I won't claim what Google "used".
The five JSON-LD types on every post
View the source of any post and there are two <script type="application/ld+json"> blocks. The root layout emits a Person and a WebSite on every URL, from siteJsonLd() in src/lib/seo.ts.
The post page emits the article, its breadcrumbs and its FAQs:
const blogPosting = {
"@type": "BlogPosting",
"@id": `${url}#article`,
isPartOf: { "@id": `${SITE_URL}/blog#blog` },
headline: post.title,
description: post.description,
datePublished: post.date,
dateModified: post.updated,
author: { "@type": "Person", "@id": `${SITE_URL}/#person`, name: site.name, url: SITE_URL },
mainEntityOfPage: url,
image: { "@type": "ImageObject", url: `${url}/opengraph-image`, width: 1200, height: 630 },
wordCount: post.words,
};
const jsonLd = {
"@context": "https://schema.org",
"@graph": [
blogPosting,
breadcrumbs([{ name: "Writing", path: "/blog" }, { name: post.title, path: `/blog/${post.slug}` }]),
...(post.faqs?.length ? [faqPage(post.faqs)] : []),
],
};(I trimmed the FAQ mapping into a faqPage call; the real file inlines it.)
The glue is @id. The Person is declared once as https://www.hisandeep.com/#person, and the post's author and the site's publisher point at that string instead of repeating it.
The author block still repeats name and url because Google's Article documentation asks for them on the article, and not every consumer resolves @id across script blocks.
Generate JSON-LD from front matter so it cannot drift
None of these values is typed into the markup. They come from the same front matter that renders the visible page:
| Front matter | JSON-LD | Also shown on the page as |
|---|---|---|
title |
headline |
the <h1> |
description |
description |
the standfirst under the title |
date |
datePublished |
the date in the byline |
updated |
dateModified |
"Updated …" next to the date |
faqs |
FAQPage |
the "FAQs" section |
| word count of the body | wordCount |
the reading time |
Google's structured data guidelines require markup to describe visible content.
The usual way to break that is not cheating but drift:
- someone edits a post
- the visible date moves
- a hand-written
dateModifiedstays put.
Rendered from one object, they cannot disagree.
I only set updated: when a post changes materially, because bumping it for a typo teaches crawlers to ignore your dates.
A series bug I found while writing this
Reading the code line by line for this post, I found this at the bottom of the BlogPosting object:
...(post.series && { isPartOf: { "@type": "CreativeWorkSeries", name: post.series }, position: post.part }),For a post in a series, the spread replaced the isPartOf that points at the blog, so series posts stopped saying they belong to it. No validator complains, because both shapes are legal.
The fix makes isPartOf an array, and the page ships it now:
...(post.series && {
isPartOf: [{ "@id": `${SITE_URL}/blog#blog` }, { "@type": "CreativeWorkSeries", name: post.series }],
position: post.part,
}),A markup mistake no tool flags is a better lesson than a clean example.
The Rich Results Test checks two of the five types
Google's Rich Results Test reports Article (BlogPosting is a subtype) and Breadcrumbs. It never mentions Person or WebSite, because it only validates types that can produce a rich result.
A green tick says the BlogPosting has the properties Google wants, not that the graph is coherent. For that, use the Schema Markup Validator, which shows every node and catches an @id that points at nothing.
Here's the catch: valid means eligible. Correct markup does not guarantee a rich result; Google decides per query and per page, and a new post on a small site is low on the list.
The tick is a permission slip, not a promise.
Check the markup after every deploy
Validators are manual, so I also run a cheap check that catches the worst failure, a script tag that no longer parses:
curl -s https://www.hisandeep.com/blog/json-ld-this-blog-ships \
| grep -o '<script type="application/ld+json">[^<]*' \
| sed 's/<script type="application\/ld+json">//' \
| while read -r block; do echo "$block" | jq -e '.' > /dev/null && echo ok; doneTwo ok lines means both blocks are valid JSON. It says nothing about meaning, which is what the Schema Markup Validator is for, but it turns a broken deploy into a red CI step instead of a silent one.
Is FAQPage still worth shipping in 2026?
This is the one I would have deleted. In August 2023 Google limited FAQ rich results to "well-known, authoritative government and health websites".
On 7 May 2026 it stopped showing them for everyone, and the FAQPage documentation now carries that notice. The question dropdown under a result no longer exists for anyone.
I still ship it, for three reasons:
- The questions are already visible on the page, so the markup describes real content, and it costs a few hundred bytes.
- Google is not the only reader. An explicit question with an explicit answer is about the cleanest unit a page can offer anything that summarises text, which is the bet in the llms.txt and GEO post. I have no measurement proving an answer engine reads FAQPage, and I won't pretend to.
- Google said in 2023 there was "no need to proactively remove it".
What I would never do is add filler FAQs to get the markup. With the rich result gone, the only reason left to write an FAQ is that readers ask those questions, which should always have been the reason.
Conclusion
Generate your JSON-LD from the same data that renders the page. Once structured data lives apart from it, it starts to lie slowly, and no test will tell you.
From scratch, I would add:
- a BlogPosting with honest dates
- then BreadcrumbList
- then one Person with a stable
@idand realsameAslinks.
Then stop there without guilt. Most of a blog's SEO comes from the technical SEO checklist, and the canonical tag bug shows what one wrong line in the <head> costs.
Which structured data types does your site ship, and could you say why each one is there?