Skip to content
Sandeep Kumar
5 min read

The JSON-LD this blog ships, and why each piece is there

Person, WebSite, BlogPosting, BreadcrumbList and FAQPage on a static Next.js blog: the real code, what the Rich Results Test checks, and why FAQPage stays.

Sandeep Kumar, Full-stack EngineerSandeep KumarFull-stack Engineer
The JSON-LD this blog ships, and why each piece is there: Google's test validates two of the five types
On this page
  1. The five JSON-LD types on every post
  2. Generate JSON-LD from front matter so it cannot drift
  3. A series bug I found while writing this
  4. The Rich Results Test checks two of the five types
  5. Check the markup after every deploy
  6. Is FAQPage still worth shipping in 2026?
  7. Conclusion

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:

src/app/blog/[slug]/page.tsxts
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 dateModified stays 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:

ts
...(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:

src/app/blog/[slug]/page.tsxts
...(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.

5JSON-LD types on every postPerson, WebSite, BlogPosting, BreadcrumbList, FAQPage
2reported by the Rich Results TestArticle and Breadcrumbs
Google's test validates two of the five types

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:

bash
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; done

Two 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 @id and real sameAs links.

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?

FAQs

Which JSON-LD types should a personal blog use?

BlogPosting (or Article) on each post, BreadcrumbList for the trail, and a Person node for the author that every post references by @id. WebSite ties the site together. Add FAQPage only if the page shows real questions and answers to the reader.

Are FAQ rich results still shown in Google?

No. Google restricted them to well-known government and health sites in August 2023 and stopped showing them for every site on 7 May 2026, according to its own structured data documentation. FAQPage is still a valid Schema.org type and Google has said unused structured data does not cause problems.

Does the Rich Results Test validate all of my JSON-LD?

No. It only checks the types Google supports for rich results, such as Article and Breadcrumb, and ignores the rest. Use the Schema Markup Validator at validator.schema.org to check the whole graph, including Person and WebSite.

Should JSON-LD be generated or written by hand?

Generated, from the same data that renders the page. Hand-written markup drifts: a post gets updated, the visible date changes, and dateModified in the script tag does not. Google's guidelines expect structured data to match the visible content.

Found this useful?Share on XShare on LinkedIn

Related reading