Skip to content

Technical SEO and schema a machine can read on the first pass

Call 747-249-9821

Rankings, rich results and AI citations all start with the same thing: a page whose structure says what it is. We write the markup by hand, connect every entity in one JSON-LD graph, and remove whatever slows the page or wastes the crawl.

Wireframe of nested semantic HTML structural blocks tethered to a knowledge graph of emerald and amber JSON-LD entity nodes
Semantic HTML5 is the structure. JSON-LD is the graph that tells a machine what each block means.

Why does semantic HTML5 beat div-soup?

Semantic elements tell a parser what each part of a page is. An article, a section with a heading, a definition list or a table carries meaning that a stack of anonymous containers does not. Search engines and language models extract answers more reliably from pages whose structure already separates the question, the answer and the supporting detail.

Open the source of a typical page-builder site and you will find forty nested containers around a single sentence. It renders, but nothing in the markup says which block is the main content, which is navigation and which is a testimonial slider. The HTML standard has had an answer for years. The sections specification defines article, section, nav, aside, header and footer precisely so that software does not have to guess.

We build every template on that vocabulary. One h1. Headings that descend in order. A section with an id for every idea worth linking to, which is what makes the deep links on this site work. Glossaries as dl, comparisons as real tables with th scope, questions as details and summary so the answer is in the HTML whether or not it is expanded.

This is not purism. Clean structure is what lets Google lift a passage into a featured snippet and lets an AI system quote you, which we cover under direct-answer engineering. You can inspect this page's own structure with the Inspect Live Schema & Semantics button at the bottom left of a desktop screen.

Div-soup versus semantic markup, element by element
ContentTypical page-builder outputWhat we ship
Main contentdiv.container > div.row > div.colmain > article
A topic within the pagediv.section-wrappersection with an id and an h2
Terms and definitionsBold text and line breaksdl, dt and dd
ComparisonsColumns of divstable with thead and th scope
Questions and answersA script-driven accordion that injects the answer on clickdetails and summary, with the answer in the HTML
ImagesCSS background imagefigure, img with alt text and dimensions, figcaption

What does a nested JSON-LD @graph actually do?

A @graph puts every entity on the page in one JSON-LD block and connects them by @id. The organization, the local business, the founder, each service and the page itself become nodes that reference one another. Google reads a single consistent description of who you are instead of several disconnected snippets that may disagree.

Most schema on the web is a plugin's default: an Organization on the home page, a LocalBusiness somewhere else with a slightly different name, and an Article that points at nothing. Each is valid on its own. Together they describe three half-businesses. Schema.org is a vocabulary for describing things and the relationships between them, and the relationships are where the value is.

We write one graph per page. Four nodes are permanent and carry the same @id everywhere: the Organization, the LocalBusiness with its phone number, area served and price range, the founder as a Person with a knowsAbout list, and the WebSite. Page-specific nodes are added to those: a WebPage whose hasPart lists every anchored section, a Service, an Article, ImageObject entries for each figure, a BreadcrumbList and, where the page answers questions, a FAQPage.

Then we test it against what Google will actually use. The structured data documentation from Google Search Central is specific about which properties each rich result needs, and insists that markup describe content visible on the page. One candid note: Google now shows FAQ rich results for only a narrow set of government and health sites. We still mark up questions, because the same structure feeds entity understanding and AI answers, but we do not promise a rich result Google no longer gives.

For multi-location brands the graph scales by adding a LocalBusiness node per location under one parent, which is the backbone of our work on location-level schema graphs.

Nodes in the graph on this page

  • Organization, LocalBusiness, Person and WebSite, shared across the whole site
  • WebPage with about, mentions and a hasPart entry for each section anchor
  • Service with a provider that points at the local business
  • ImageObject, BreadcrumbList and FAQPage

How do crawl budget and Core Web Vitals affect calls?

Crawl budget decides how quickly Google finds and refreshes the pages that matter. Core Web Vitals measure whether those pages load, respond and hold still for a real visitor. On a phone, a slow or shifting page delays the moment the call button can be tapped, and some of those callers go to the next result.

Small sites rarely run out of crawl budget. They waste it. Tag archives, internal search results, filtered URLs, staging copies and five versions of the same page with different parameters all compete with the twelve pages that bring in business. We decide what deserves to be indexed, canonicalize or block the rest, and keep the XML sitemap limited to URLs we want ranked. The same discipline applies to large catalogs: the spec pages we build for manufacturers' RFQ searches only work if Google can reach them.

Core Web Vitals are three field measurements from real Chrome users. Largest Contentful Paint should land within 2.5 seconds, Interaction to Next Paint within 200 milliseconds, and Cumulative Layout Shift should stay under 0.1. Most failures have boring causes: an unsized hero image, a tag manager loaded with scripts nobody remembers adding, fonts that block rendering, a chat widget that shifts the page as it loads.

We fix them at the template. Images get explicit dimensions and modern formats. The largest image is preloaded and everything else is lazy. Third-party scripts are audited and deferred. Call tracking is loaded in a way that swaps the number without moving the layout. For a business that depends on emergency calls from the map pack, that first second is where the lead is won.

Index hygiene checklist

  • One canonical URL per page, self-referencing, with redirects for every variant
  • A sitemap that lists only indexable, canonical URLs
  • No orphaned service or location pages: each one is linked from body copy somewhere
  • Server-rendered HTML for all content and schema, never an empty shell waiting for JavaScript
  • A robots.txt that blocks waste without blocking the resources a page needs to render

Technical glossary

Entity
A distinct, identifiable thing such as a business, a person, a place or a service, as opposed to a string of keywords.
JSON-LD
JavaScript Object Notation for Linked Data. The format Google recommends for structured data, placed in a script element separate from the visible HTML.
@graph
A JSON-LD container that holds several nodes in one block so they can reference each other.
@id
A stable identifier for a node, written as a URL with a fragment such as #organization. Other nodes point to it instead of repeating its details.
Canonical URL
The single address a page declares as its preferred version, so duplicates and parameter variants consolidate their signals.
Largest Contentful Paint (LCP)
The time until the largest visible element, usually the hero image or headline, has rendered. Good is 2.5 seconds or less.
Interaction to Next Paint (INP)
How long the page takes to respond visibly after a tap or click. Good is 200 milliseconds or less. It replaced First Input Delay in March 2024.
Cumulative Layout Shift (CLS)
A score for how much visible content moves unexpectedly while loading. Good is 0.1 or less.

Where this work pays off first

The same method, pointed at the call that counts in each vertical.

Technical SEO & Schema: questions owners ask

Can't an SEO plugin handle schema?

A plugin can output valid types. It cannot know that your founder, your three locations and your service pages are the same business, so it rarely connects them. We often keep the plugin for basics and replace its schema output with a hand-built graph.

Will schema markup improve my rankings?

Structured data is not a direct ranking boost. It makes your content eligible for rich results and removes ambiguity about who you are, which affects how you appear and how often you are clicked or cited. Treat it as clarity, not as a trick.

Do I need to rebuild my site?

Usually not. Most of the gain comes from fixing templates: the heading structure, the main service and location layouts, image handling and script loading. We rebuild only when the platform cannot produce clean, server-rendered HTML.

How do you check that Google can render my pages?

We compare the raw HTML response with the rendered DOM, test pages in Search Console's URL Inspection tool, and review server logs to see what Googlebot actually requests. If content or schema only appears after JavaScript runs, we move it into the server response.

How does this connect to phone calls?

Faster, clearer pages rank for more of the searches that lead to calls and convert more of the visitors they get. They also improve landing page experience in Google Ads, which lowers what you pay for the same position.

Talk to the person who will actually do the work

No account coordinator, no discovery deck. Call and describe what the phone should be ringing for, or send the site and we'll trace where the signal is leaking.

Call 747-249-9821
Call 747-249-9821