What is Structured Schema? A Plain-English Guide to Structured Data

The label on the tin

Your homepage makes sense to a human in about two seconds. A visitor sees your logo, your headline, a photo of your work, and knows exactly what you do.

A crawler sees 4,000 lines of HTML with no labels. Is this a plumbing company or a blog about plumbing? Is "R450" a price, a product code, or part of an address? Machines guess, and they guess conservatively.

Structured schema removes the guessing. It's the schema.org vocabulary, usually written as JSON-LD, added to your pages to declare what each one is: a local business, a product, a service, an article, an FAQ. Visitors never see it. Machines rely on it.

Three terms get mixed freely here, so one sentence each. Schema.org is the vocabulary: a shared list of types and properties maintained by the search engines. Structured data is the practice of adding that information to your pages. JSON-LD is the format most people write it in, and the one Google recommends.

Our position up front: this is the cheapest high-leverage SEO work available on most sites. It changes nothing your visitors see and requires no new copy. It's pure machine clarity, and most of your competitors have done it badly or not at all.

What it looks like

Here's a minimal, real example for a fictional Cape Town plumber:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "Atlantic Plumbing",
  "url": "https://atlanticplumbing.example",
  "telephone": "+27-21-555-0100",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "12 Main Road",
    "addressLocality": "Sea Point",
    "addressRegion": "Western Cape",
    "postalCode": "8005",
    "addressCountry": "ZA"
  },
  "areaServed": "Cape Town",
  "openingHours": "Mo-Fr 07:00-17:00"
}

Reading it line by line: @context says "we're using the schema.org vocabulary." @type declares what this thing is, and note that it's Plumber, a specific type, not the generic LocalBusiness. Everything else is properties: name, phone, address, service area, hours. All facts a machine can now store as facts rather than infer from prose.

The whole block lives in a <script type="application/ld+json"> tag, usually in the page head. Browsers ignore it. Crawlers read it. Your visitors will never know it's there.

What you get for it

Rich results. With the right markup, Google can show your listing with extras: star ratings, FAQ accordions, breadcrumb trails, product prices, event details. These take up more vertical space in results and consistently earn higher click-through rates than plain blue links; industry studies have measured the uplift at anywhere from 20% to well over 50% depending on the result type.

The honest caveat, before anyone oversells this: schema makes you eligible for rich results. Google decides whether to show them, query by query. Correct markup with no rich result is common. No markup with a rich result is nearly impossible. You're buying a ticket, not a guarantee.

The 2026 bonus: AI engines. This is the part that changed recently. Generative engines like ChatGPT and Perplexity, and Google's own AI Overviews, lean on entity data when deciding who you are and whether to cite you. Schema is the closest thing to a verified ID card your business has on the open web. We cover the bigger picture in How to Write for SEO, AEO and GEO in 2026, but the short version: the same markup that earns rich results also feeds AI answers.

Entity consistency. Schema that matches your Google Business Profile, directories, and social profiles reinforces one coherent identity. That coherence is what knowledge panels and AI citations are built from.

The schema types that actually matter

Schema.org defines over 800 types. Most businesses need five or six. Here they are:

Three footnotes that vendors tend to skip:

Choose the specific subtype. Plumber beats LocalBusiness. Attorney beats ProfessionalService. The vocabulary has hundreds of specific business types; using the precise one is free specificity.

FAQ rich results are restricted. Since 2023, Google only shows FAQ rich results for well-known, authoritative government and health sites. The markup still matters, because answer engines and AI systems read it regardless. Just don't expect the accordion in search results.

Review markup has rules. Self-serving reviews (markup about your own business, hosted on your own site, with no third-party source) are against Google's guidelines. Fabricated rating counts are worse; more on that below.

And the "ignore these" list: obscure niche types, marking up every paragraph, and schema for things with no search presence. Time spent there is time wasted.

Why generic plugin schema falls short

Most WordPress sites get their schema from an SEO plugin. Yoast and Rank Math emit sensible defaults: a WebSite, a WebPage, an Organization with your name and logo, an Article on posts. As a floor, that's genuinely fine.

The problem is that a plugin can't know how your business actually works. It doesn't know that you're a service business with three locations, that one brand owns two trading names, or that your money pages are services that deserve Service markup with areaServed and real descriptions. So it emits the same generic shell it emits for everyone, and generic markup earns generic nothing.

The difference is between a plugin-default WebPage blob and a modelled graph: a Plumber entity, its Service offerings, the areas it serves, all connected. That connection is the part most implementations miss entirely, and it's done with the @id property. Give your Organization a stable @id, then reference that same @id from every article's publisher field and every service's provider field. Now the machine sees one entity with many pages, not many pages that mention a similar name. That's what entity clarity actually means at the code level.

This is why we hand-model JSON-LD on the sites we build rather than leaning on plugin defaults: markup that matches how the business actually works, kept valid and in sync with the content.

How to implement it (three routes)

Route 1: plugin defaults. For a simple blog or brochure site, turn on your SEO plugin's schema, fill in the organisation settings properly, and move on. Acceptable floor. Just know the ceiling: you'll have identity markup and little else.

Route 2: hand-written JSON-LD. Our approach on most builds. In WordPress, a small function hooked into the head outputs your modelled JSON-LD. In Next.js, the same block goes into your layout or page component:

export default function Page() {
  const schema = {
    "@context": "https://schema.org",
    "@type": "Plumber",
    "@id": "https://atlanticplumbing.example/#org",
    name: "Atlantic Plumbing",
    areaServed: "Cape Town",
  };
 
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Route 3: professional modelling. For multi-location businesses, mixed product-and-service catalogues, or anything where the entity graph gets genuinely complicated, have someone model it who has done it before. This is hours of work, not weeks, and it's done once.

Whichever route: validate. Run pages through Google's Rich Results Test and the Schema Markup Validator, fix what they flag, and re-test whenever the page content changes meaningfully.

That last part matters more than people think. Schema that drifts out of sync with the visible page is worse than no schema at all, because markup that misrepresents page content violates Google's spam policies. Structured data is a maintenance commitment, not a one-time install.

Common mistakes we find in audits

When we run site audits, structured data problems come up constantly. The same four mistakes account for most of them:

Marking up content that isn't on the page. Ratings, FAQs, or offers that appear in the markup but nowhere a visitor can see them. This is the misleading-markup violation, and it risks a manual action rather than just being ignored.

Two plugins fighting. An SEO plugin and a schema plugin both emitting Organization markup with slightly different details. Conflicting signals are worse than one imperfect signal; the machine can't tell which version of you is true.

Half-empty required fields. A LocalBusiness with no address or hours, which forfeits exactly the local-search benefits the markup exists for.

Fabricated aggregate ratings. An AggregateRating claiming hundreds of reviews on a site with no visible review system. At best it's ignored. At worst it's the spam policy again.

The cheap fix for all four: pick one source of schema, model it honestly against what's actually on the page, and validate it.

Does it move rankings? The straight answer

No, not directly. Google has said plainly that structured data is not a ranking factor, and anyone selling schema as a rankings hack is selling you a story.

Here's what it does move. Eligibility for rich results, which lifts click-through rate, which lifts qualified traffic from positions you already hold. And entity clarity, which is quietly becoming the more valuable half: it's what AI engines read when deciding whether your business is a citable, recommendable entity or just another URL.

Our position: in 2026, schema is table stakes, not a growth hack. It won't rocket you up the rankings. But skipping it hands SERP real estate and AI citations to whichever competitor bothered.

Where to start on your site

For a typical SME, the priority order is:

1. Organization or LocalBusiness sitewide, with the specific subtype, full contact details, and a stable @id
2. BreadcrumbList across the site
3. Article markup on the blog, with real author information
4. Service or Product markup on the pages that make you money
5. FAQPage where genuine, visible FAQs exist

Then validate everything and put a reminder in the calendar to re-check quarterly.

Not sure what your site currently emits? Our free audit includes a structured-data check: we'll show you exactly what machines currently believe about your business, and what's missing.

Related reading

• How to Write for SEO, AEO and GEO in 2026
• Does Google Penalize AI Content? What Hurts Rankings
• The Website Redesign Playbook