Your website has a public face and a hidden one. The public face is what visitors see—your copy, design, and case studies. The hidden face is what search engines and AI systems read. And for most small business websites, it's almost entirely blank.
The reason most businesses don't appear in AI answers is straightforward: their websites were never structured for AI understanding. They're missing schema and structured data. Schema markup is how you fix that. It's structured data: a block of code that sits in your page's head and describes your business, your services, and your content in terms a machine can parse directly—without inferring, guessing, or extracting meaning from your prose. No schema means the engine has to guess. And when engines guess, they get things wrong, or they default to a source they're more confident about—like your competitor.
This is the plain-language, founder-facing guide to schema markup for small business—what it is, why it matters for AI search specifically, and what a minimum viable implementation looks like.
What schema markup actually is
Schema markup is structured data written in a format called JSON-LD—JavaScript Object Notation for Linked Data. It's a block of code placed in the head of your page that describes your content using a shared vocabulary called Schema.org, maintained by Google, Microsoft, Yahoo, and Yandex.
The reason it exists is simple: natural language is ambiguous. "Aimee Q Devlin is a Systems and Infrastructure Architect who helps established small businesses become visible to AI search engines" tells a human reader quite a lot. It tells a search engine almost nothing—it can't reliably extract who Aimee is, what her job title is, what kind of infrastructure she works on, or whether she's a person, a company, or a product.
JSON-LD removes the ambiguity. Instead of hoping the engine infers correctly, you declare it explicitly:
{
"@context": "https://schema.org",
"@type": "Person",
"name": "Aimee Q Devlin",
"jobTitle": "Systems & Infrastructure Architect",
"url": "https://aimeeqdevlin.com/about"
}
The engine reads this and knows—not guesses—who Aimee is and what she does.
Structured data and schema markup are terms used interchangeably in most contexts. JSON-LD is the implementation format Google recommends and the one used throughout this article.
Why schema matters more for AI search than traditional SEO
For traditional Google Search, schema markup has always been valuable—it powers rich snippets, knowledge panels, and enhanced search results. But for AI search, it's foundational in a different way.
AI engines—ChatGPT, Claude, Perplexity—don't rank pages. They build models of entities: people, businesses, services, and topics. When someone asks, "Who is a good AEO consultant for a small business?" the engine is looking for an entity it can confidently identify and attribute. Schema markup is how you declare yourself as that entity.
Without schema, the engine must infer your identity from unstructured text. Sometimes it gets it right. Often it gets it partially right. Sometimes it skips you entirely in favour of a source it can identify with confidence.
Schema markup for small business is often deprioritised by founders because it feels technical and invisible—it doesn't change what visitors see. But it's one of the highest-leverage infrastructure moves available because it directly affects whether AI engines can identify and cite you. It's the difference between being text and being a known entity.
The minimum viable entity graph for a founder
You don't need schema for every possible type. For a founder or small consultancy, three entity types do the essential work: Person, ProfessionalService, and Service. Together they form your entity graph—a connected set of declarations that tell engines who you are, what your business is, and what it offers.
Person schema
This declares you as an individual entity. The fields that matter most:
{
"@context": "https://schema.org",
"@type": "Person",
"@id": "https://yourdomain.com/#your-name",
"name": "Your Full Name",
"jobTitle": "Your Job Title",
"url": "https://yourdomain.com/about",
"image": {
"@type": "ImageObject",
"url": "https://yourdomain.com/your-headshot.jpg"
},
"sameAs": [
"https://www.linkedin.com/in/yourprofile/",
"https://www.youtube.com/@yourchannel"
],
"knowsAbout": [
"AEO",
"Technical SEO",
"Schema Markup",
"Systems Architecture"
],
"worksFor": {
"@id": "https://yourdomain.com/#organisation"
}
}
The @id is a unique identifier for this entity. It's how other schema blocks on your site reference you without repeating all your details. Use a URL that's stable and specific to you.
sameAs links to your verified external profiles—LinkedIn, YouTube, any platform where the same entity appears. The engine uses these to corroborate that all those profiles are the same person.
knowsAbout builds topical association between you and the subjects you want to be cited for.
worksFor points to your business entity using its @id.
ProfessionalService schema
This declares your business as an entity separate from you as a person, but connected to you via founder.
{
"@context": "https://schema.org",
"@type": "ProfessionalService",
"@id": "https://yourdomain.com/#organisation",
"name": "Your Business Name",
"url": "https://yourdomain.com",
"description": "One to two sentences describing what your business does and who it serves.",
"founder": {
"@id": "https://yourdomain.com/#your-name"
},
"areaServed": "Worldwide",
"logo": {
"@type": "ImageObject",
"url": "https://yourdomain.com/your-logo.jpg"
}
}
The @id here—https://yourdomain.com/#organisation—is what your Person schema's worksFor field points to. This link is what makes it a graph rather than two isolated declarations. The engine can follow: this person works for this business.
Service schema
One Service block per offering. Link each back to your ProfessionalService entity via provider.
{
"@context": "https://schema.org",
"@type": "Service",
"name": "The Infrastructure Audit",
"description": "A half or full-day audit that diagnoses what's wrong with your digital infrastructure and produces a prioritised fix list in plain language.",
"provider": {
"@id": "https://yourdomain.com/#organisation"
},
"url": "https://yourdomain.com/services/infrastructure-audit"
}
Repeat for each service, changing name, description, and url. The provider reference always points to your business entity.
Article schema
Every piece of content you publish should carry Article schema, with author linked back to your Person entity. This builds the connection between you and the things you write.
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your Article Title",
"author": {
"@id": "https://yourdomain.com/#your-name"
},
"publisher": {
"@id": "https://yourdomain.com/#organisation"
},
"datePublished": "2026-01-01",
"dateModified": "2026-01-01",
"url": "https://yourdomain.com/insights/your-article-slug"
}
datePublished and dateModified matter. AI engines favour fresh content, and these fields signal when the information was last verified. Keep dateModified current.
FAQPage schema—the highest-leverage AEO addition
If there's one structured data type with an outsized return for AI citation specifically, it's FAQPage. A page with FAQPage schema presents pre-chunked question-and-answer pairs directly to the engine—exactly the format AI systems use when extracting an answer to cite.
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is schema markup?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Schema markup is structured data code placed in a webpage's head that describes the page's content to search engines and AI systems using a shared vocabulary called Schema.org. It allows engines to understand what a page is about, who wrote it, and what entity it belongs to—without inferring those things from unstructured text."
}
}
]
}
Add FAQPage schema to every article and service page. The answers should be self-contained—each one citable on its own, without the reader needing context from the surrounding page.
Where schema goes and how to validate it
Where it goes: JSON-LD schema is placed inside a <script type="application/ld+json"> tag in your page's <head>. Multiple schema blocks can live on the same page—one for Article, one for FAQPage, one for BreadcrumbList. They don't need to be merged into one block.
How to validate: Google's Rich Results Test at search.google.com/test/rich-results accepts a URL or a code snippet and shows which schema types it detects, which fields are present, and any errors or warnings. Zero errors are the baseline.
The most common mistakes:
Missing @id values—without them, schema blocks are isolated and can't form a graph. The @id is what lets one block reference another.
Inconsistent identifiers—if your Person schema uses #aimee-devlin as its @id but your Article schema references #person, they don't connect. Use the same identifier everywhere, exactly.
Stale dates—dateModified left at the original publish date when the content has been updated. Keep it current.
Missing sameAs—the most commonly omitted field. Without it, your Person entity is unverified against any external source.
Schema as infrastructure, not decoration
The right way to think about schema markup is as infrastructure—not decoration, not a technicality to delegate and forget. It's the layer that tells engines who you are before they read a single word of your copy.
Most small business websites have no schema at all, or a few isolated schema blocks with no @id linking and no entity graph. Most AI systems are building their understanding of those businesses from whatever they can scrape from unstructured text—which is imprecise at best and wrong at worst.
An entity graph—Person linked to ProfessionalService linked to Service, with Article blocks pointing back to Person, with FAQPage on every content page—is a formal introduction. It says: this is who I am, this is what I do, this is what I've written, and here are the external profiles that confirm it.
It doesn't guarantee citation. But it removes the single most common reason for not being cited—the engine simply not knowing who you are with enough confidence to put your name in an answer.
If you'd rather have a schema markup consultant review and implement your entity graph than work through it alone, that's what the Infrastructure Audit covers.
Schema markup is the Recognition layer in practice. The entity graph is the structure. The sameAs links are the corroboration. The FAQPage blocks are the extraction targets. Together they make your business legible to machines—and legible businesses get cited.
What is schema markup?
Schema markup is structured data code placed in a webpage's head that describes the page's content to search engines and AI systems using a shared vocabulary called Schema.org. It allows engines to understand what a page is about, who wrote it, and what entity it belongs to—without having to infer those things from unstructured prose. JSON-LD is the recommended implementation format.
What is JSON-LD?
JSON-LD stands for JavaScript Object Notation for Linked Data. It is the format Google recommends for implementing schema markup. A JSON-LD block is placed inside a script tag in the page's head and describes the page's entities—person, business, article, service—using Schema.org vocabulary. Multiple JSON-LD blocks can live on the same page and reference each other using @id values to form a connected entity graph.
Does schema markup help with AI citations?
Yes. Schema markup—particularly Person, ProfessionalService, Article, and FAQPage types—gives AI engines the structured signals they need to identify and cite a source with confidence. Without schema, the engine must infer identity from unstructured text, which reduces attribution accuracy and citation likelihood. FAQPage schema is especially effective because it presents pre-chunked question-and-answer pairs in exactly the format AI systems use to extract citable answers.
What schema types does a small business need?
A minimum viable schema implementation for a small business founder includes: a Person entity (your name, job title, sameAs links to verified profiles, knowsAbout topics), a ProfessionalService or Organization entity (your business, linked to your Person entity via founder), Service schema on each individual offering (linked to your ProfessionalService entity via provider), Article schema on every piece of content (author linked back to your Person entity), and FAQPage schema on every content page. These five types form a connected entity graph.
How do I validate my schema markup?
Use Google's Rich Results Test at search.google.com/test/rich-results. It accepts a URL or a code snippet and shows which schema types are detected, which fields are present, and any errors or warnings. Zero errors are the baseline. The most common errors are missing @id values (which prevent entity graph linking), inconsistent identifiers across schema blocks, stale dateModified values, and missing sameAs fields on Person entities.
What is an entity graph in schema?
An entity graph is a connected set of schema declarations where each entity references the others using @id values. For a founder or small business, the graph links Person to ProfessionalService via worksFor and founder, ProfessionalService to Service via provider, and Article to Person via author. This linking lets engines follow the connections—this article was written by this person, who founded this business—rather than treating each schema block as an isolated declaration.
What is the difference between schema markup and meta tags?
Meta tags—title, description, Open Graph—are plain text instructions for browsers and social platforms. They control how a page is displayed in search results and when shared on social media. Schema markup is structured data that describes the meaning and relationships of content to search engines and AI systems. Both sit in the page head, but schema declares entity identity and relationships rather than display preferences, making it significantly more valuable for AI citation.
Aimee Q Devlin is a Systems and Infrastructure Architect based in San Miguel de Allende, Mexico. She works with founders and operators of established businesses who are ready to rebuild their systems properly—including the infrastructure that makes those systems discoverable. The Infrastructure Audit is where most engagements begin.
→ What Is Entity SEO? (coming soon)
→ What is an AEO Audit? (coming soon)