What Schema Actually Is - Name Tags for Your Website

Schema (or "schema markup") is a standardized vocabulary for labeling the important things on your website so machines don't have to guess what they mean. It was created in 2011 by Google, Microsoft (Bing), Yahoo, and Yandex, and it is maintained at Schema.org. The major search engines all read it.

Think of name tags at a conference. Without them, you see a room full of people and have to work out who is who from context. With them, you know instantly: this is an attorney, this is a client, this is the host.

Behind the scenes, schema says things like:

• This is a law firm.
• This is an attorney, and she works for this firm.
• This is a practice area, and this firm offers it.
• This is a location, and this service is available there.

Your visitors never see any of this. It is a layer of labels written for machines.

A Fact Sheet Every Search Engine Can Read

You never have to write this yourself, but seeing it removes the mystery. Schema is usually added as a small block of text in a format called JSON-LD, which Google recommends. In plain terms, it's a fact sheet about your firm:

Type: LegalService
Name: Smith & Jones Law Firm
Area served: Los Angeles, CA
Employee: John Smith (Partner)
Knows about: Personal injury law, Motorcycle accidents

The real version contains the same information in a stricter format, which the next section walks through. Schema.org includes types built for your world, such as LegalService, Attorney, Person, Service, Place, Article, and Review, and properties like areaServed, knowsAbout, worksFor, and sameAs that describe how things relate.

How AI Actually Reads JSON

It's Less Like Reading and More Like Filling Out a Form

Most people picture AI reading a website the way they do: top to bottom, absorbing the gist. Schema works differently, and that difference is why it's valuable. When you read a paragraph, you interpret it. When a machine reads JSON, it looks up labeled fields, the way you'd read a completed form. A form doesn't say "Well, I've lived in Los Angeles for a while now." It has a box labeled City, and the answer is in the box.

JSON (short for JavaScript Object Notation) is simply a way of writing information as labels paired with values. The label goes on the left, the value on the right:

"name": "Smith & Jones Law Firm"

That one line means: the name of this thing is Smith & Jones Law Firm. There is nothing to interpret.

A Real Example, Line by Line

Here is a simplified but realistic version of what sits behind a law firm's page:

{
  "@context": "https://schema.org",
  "@type": "LegalService",
  "@id": "https://www.smithjones.com/#firm",
  "name": "Smith & Jones Law Firm",
  "areaServed": {
    "@type": "City",
    "name": "Los Angeles"
  },
  "knowsAbout": [
    "Personal injury law",
    "Motorcycle accident claims"
  ],
  "employee": {
    "@type": "Person",
    "@id": "https://www.smithjones.com/attorneys/john-smith/#person",
    "name": "John Smith",
    "jobTitle": "Partner",
    "worksFor": { "@id": "https://www.smithjones.com/#firm" },
    "sameAs": "https://www.calbar.ca.gov/example-profile"
  }
}

It looks intimidating, but here is what each part says in plain English:

The curly braces { } group facts about one thing. Square brackets [ ] hold lists. Indentation shows which facts belong to which thing. That's the whole grammar.

Think of Your Website as a Map of Your Law Firm

A law firm's website can contain hundreds of pieces of information spread across dozens or even hundreds of pages.

For example:

• The law firm
• Individual attorneys
• Practice areas
• Types of cases
• Locations
• Courts
• Industries served
• Legal services
• Client resources
• Articles
• Case results
• Frequently asked questions

A person can read those pages and usually figure out how everything fits together. Search engines and AI systems have to figure it out from the information they find. Schema helps make those connections clearer.

For example, instead of simply saying that a law firm handles personal injury cases, schema can help communicate:

Law Firm → provides → Personal Injury Law → handles → Car Accident Cases → serves → Los Angeles → attorney → John Smith

Now the information isn't just a collection of words on different pages. It becomes a connected picture of the firm.

What Happens When a Machine Finds It

Here is the journey from your page to a machine's understanding:

1. A crawler visits your page. Search engine and AI crawlers download the page's code, not just the text you see.
2. It finds the schema block. JSON-LD sits in a clearly marked container in the page's code, so it's easy to locate.
3. A parser reads it. JSON has strict rules. A parser is a simple, reliable program that checks whether the block follows them and pulls out every label and value. This step involves no guessing.
4. It builds a connected picture. Using the IDs, the machine links the facts together: this attorney works for that firm, which serves that city. This is the knowledge graph taking shape.
5. It cross-checks. The machine compares what the markup claims with what the visible page says and with what it knows from elsewhere on the web, such as your Google Business Profile or bar listing.
6. It stores and uses the result. The facts feed search features, knowledge panels, and the information pools that AI systems draw from.

Why the Strictness Cuts Both Ways

Because JSON is rigid, it's unambiguous, which is its great strength. It is also unforgiving. A single missing comma or quotation mark can make the entire block unreadable, like a tax form with an illegible box. That's why validation tools matter, and why markup added by several plugins at once can quietly break.

Three Ways AI Bots Use It

Not every system treats JSON-LD the same way, and it helps to know the difference:

• Traditional search engines parse it directly. Google and Bing read schema with conventional, rule-based software. This is the most reliable path. The machine isn't interpreting anything, just reading fields. It's how features such as business details and knowledge panels get their facts.
• Knowledge graphs absorb it. The facts you provide get merged with what the system already knows about your firm from other sources. The IDs and sameAs links are how a machine decides that the John Smith on your site and the John Smith in the state bar directory are one person.
• AI language models can read it as text, with caveats. Large language models are trained on enormous amounts of code and structured data, so they read JSON fluently. Whether a particular AI assistant actually sees your schema is a different question. Some AI systems retrieve web pages in ways that strip out the code and keep only the visible text. Others keep it. Practices differ between companies and change often, and the companies rarely say exactly what they do.

Schema Is The Starting Point

The practical lesson is simple: schema and visible content should say the same thing. If an AI system reads only your visible text, your page needs to state clearly who your attorneys are, what you handle, and where you practice. If it reads your schema, that markup should confirm the same facts in a form that leaves no room for doubt. When both agree, you're covered whichever way a system reads your site. When they disagree, machines have reason to trust neither. Think of schema as the official record and your page as the conversation. A stranger is most convinced when both tell the same story.

Why Words on a Page Aren't Enough

The Fifty-Times Problem

A page can say "personal injury lawyer" fifty times. A search engine can count those words, but that doesn't tell it whether the firm actually handles motorcycle accident cases in Los Angeles, which attorney leads them, or what experience backs it up. Those facts may all be on your website, scattered across a practice page, an attorney bio, a blog post, and a results page. A person browsing would connect them. A machine may not.

From a Pile of Facts to a Chain of Them

Schema makes the connections explicit. Instead of a pile of separate facts, you get a chain:

Law Firm → practices → Personal Injury → handles → Car Accident Cases → serves → Los Angeles → attorney → John Smith

Each link is a fact a machine can rely on rather than infer.

From Keywords To Context: A Knowledge Graph

The technical name for this connected picture is a knowledge graph. Google introduced the idea publicly in 2012 with the phrase "things, not strings," meaning it wanted to understand the things behind a search rather than just match the text typed into the box. Picture an org chart, but instead of only showing who reports to whom, it shows how the firm, its attorneys, its practice areas, its cities, its courts, and its case types all relate.

The Cast of Characters: Your Firm's Entities

The "things" are called entities. For a law firm, they include:

The lines between them are relationships: practices, handles, serves, works for, is admitted in, is a member of.

Why the Connected Version Wins

• Without a knowledge graph: the phrase "personal injury lawyer" appears many times on the site.
• With one: Smith & Jones is a Los Angeles firm, John Smith is a partner there, he handles serious injury cases, and he is licensed and a member of these organizations.

The second version gives an AI far more to work with when deciding whether to recommend you.

Making Your Identity Unambiguous: Three John Smiths Are a Problem

Each entity in schema gets its own permanent identifier, the @id in the example above. That way, "John Smith" on the attorney page, the blog byline, and the homepage are recognized as the same John Smith, not three different people. Without this, a machine may treat them as separate strangers.

Vouching for Yourself Across the Web

"Same as" links let you say: this firm is the same one that appears at your Google Business Profile, your state bar listing, your LinkedIn page, Avvo, Justia, and so on. This tells machines to merge everything they know about you into one picture. For attorneys, links to state bar profiles are especially strong because they are authoritative confirmation that the person is who your site says they are.

This matters because AI systems don't form their view of your firm from your website alone. They draw on the whole web. Your website is the one place you control the story, and schema is how you tell it in a form machines trust.

The Goal Isn't Just Rich Search Results

Schema is often sold as a way to get fancy search listings, like expandable FAQs or star ratings. There are two reasons not to build a strategy around that.

1. The landscape has narrowed. Since 2023, Google shows FAQ rich results mainly for well-known government and health websites, so a law firm shouldn't expect them.
2. Google also limits star ratings when a business marks up reviews about itself.

The Real Prize: Being Understood by AI

Increasingly, people get answers to questions like "Who's a good motorcycle accident lawyer in Los Angeles?" from AI-generated summaries and assistants. To answer well, those systems must decide which firms are truly relevant. A firm whose identity, expertise, and relationships are clearly established gives them more reason to include it.

What Schema Will and Won't Do

Honesty here builds trust, so:

• Schema is not a magic ranking switch. Google has said structured data is not itself a ranking factor. It helps systems understand your content and makes you eligible for certain features.
• No one outside the AI companies knows exactly how AI assistants use it. What is clear is that clean, consistent, well-connected information is easier for any system to interpret, and schema is one of the few signals you can control directly.
• Schema can't create expertise that isn't there. It labels what your site actually shows. If the page doesn't demonstrate real experience, the markup has nothing true to point to.
• It's a foundation, not a finish line. Schema works best alongside strong content, real reviews, and consistent presence across the web.

Why Law Firms Face a Higher Bar

Law is what Google calls a "Your Money or Your Life" (Y.M.Y.L>) topic, where a bad answer can seriously harm someone. Systems apply extra scrutiny to trust signals in these areas, which is why clearly verifiable attorneys, credentials, and firm identity matter so much.

Identify Entity Gaps

Once you draw the map of who your firm is and what it should be known for, you can compare it against what your website actually communicates. The differences are called entity gaps.

Say your firm wants to be known for Los Angeles motorcycle accident cases. You have a motorcycle accident page, and it's a good one. Mapping it out might look like this:

From "You Need More Content" To Turning Entity Gaps Into a Content Strategy

Traditional SEO advice would say, "You need more content." An entity gap analysis says something far more useful:

"Your site establishes that you're a personal injury firm in Los Angeles, but it has limited connections between your attorneys, motorcycle cases, local geography, insurance claims, and client questions."

That is a entity strategy roadmap, not a vague instruction.

How AI Agents Help Find the Gaps To Organize by Meaning

Modern AI can analyze the meaning of your content, not just the keywords. It does this with vector embeddings. You don't need the math. Imagine a giant library where books aren't shelved alphabetically but by meaning, so books about similar ideas sit near each other. Embeddings turn each page into a location in that library.

Measuring the Distance Between Who You Are and Who You Want to Be

That lets AI measure the distance between what the firm wants to be known for and what the website actually communicates. If the firm wants to be the Los Angeles motorcycle accident firm but the site mostly reads as "general personal injury," that distance is a semantic gap.

AI agents can weigh several things at once:

1. The entities that matter to the firm
2. The relationships between them
3. The schema already in place
4. The topics the site covers
5. The connections that appear to be missing

The output is a prioritized list of what to build, in the order that will most strengthen the picture. Those gaps guide what to create, and not only on the site:

• On the site: practice pages, location pages, attorney bios, articles, client guides, FAQs, case results
• Beyond the site: videos, podcasts, interviews, legal publications, press coverage, community involvement, directory profiles

Quality of Connection Beats Quantity of Content

The point isn't volume. Publishing more for its own sake just adds noise. The point is a consistent, connected body of information, where every piece reinforces the same story about who you are and what you do.

Consistency extends to the basics. Your firm name, address, phone number, and attorney names should read the same everywhere: website, Google Business Profile, directories, and bar listings. Inconsistencies force machines to wonder whether they're looking at one firm or several.

Keep It Compliant

Schema makes claims in a machine-readable way, so those claims should meet the same standards as your visible marketing. Attorney advertising rules vary by state, and many restrict how terms like "specialist" or "expert" are used and require certain disclaimers on case results. Schema should describe only what the page truthfully shows. Have whoever handles your firm's ethics compliance review the language, especially for expertise and results.

Common Mistakes

Five Ways Schema Goes Wrong

1. Marking up things visitors can't see. Schema should match what's on the page. Hidden or exaggerated claims can be ignored or penalized.
2. Fake or self-serving reviews. Both violate search engine guidelines and, in many cases, advertising rules.
3. Conflicting markup. Multiple website plugins can each add their own schema, producing duplicates or contradictions.
4. Set and forget. When an attorney joins or leaves, or an office moves, the markup must change too.
5. One-size-fits-all markup. Generic "LocalBusiness" schema tells machines far less than markup describing specific attorneys, services, and areas served.

How to Know It's Working

Look for steady signals, not overnight jumps. Schema effects are gradual. Better signals include:

• Clean reports in Google Search Console with no structured data errors
• Your firm showing up more accurately in search panels and map results
• Being AI mentioned or cited when you test relevant questions in AI assistants
• Improved visibility for the specific case types and locations you targeted
• Higher-quality inquiries for those practice areas

The Question Every Firm Should Be Asking

Traditional SEO asks: "What keywords are we ranking for?"

A more modern question is: "Do Google and AI actually understand who this firm is, what it does, where it practices, who its attorneys are, and which cases it handles?"

That's the shift from keyword optimization to entity optimization, from being found to being understood.

Make Your Firm Easy to Understand

Schema is the starting point: the labels that let machines see the connections you already know exist. Content supplies the depth. AI analysis shows what's missing. Consistency across the web makes the whole picture believable. Traditional SEO asks: "What keywords are we ranking for?" A more modern GEO question is: "Do Google and AI actually understand who this firm is, what it does, where it practices, who its attorneys are, and which cases it handles?"

The goal isn't more schema, more pages, or more articles. It's a firm that is easy to understand, so that when someone asks the right question, the search engine or AI system has the context to know your firm is the answer.