Two pages can say the exact same thing and Google will treat them completely differently in search results. One shows up as a plain blue link. The other shows a star rating, a price, a cooking time, or an FAQ dropdown right there on the results page. The difference almost never comes down to better writing. It comes down to whether the page told Google, in a language it can parse without guessing, what kind of content is actually on it.
That language is structured data, and the most common way to write it today is JSON-LD schema markup. This guide walks through what it does, which types are worth your time, how to generate it without hand-writing brittle JSON, and how to avoid the mistakes that get rich results silently rejected. It's part of the same practical toolkit approach behind the rest of EvvyTools, which builds free calculators and generators for exactly this kind of task.
Photo by Bastian Riccardi on Pexels
What schema markup actually does
Search engines read your visible text, but they also read a hidden block of code that describes the page's content in a standardized vocabulary. That vocabulary is maintained by Schema.org, a collaborative project backed by Google, Microsoft, and other major search providers. When you mark up a recipe with Recipe schema, you're not just repeating the ingredients list. You're telling the crawler "this specific block of text is the cook time" and "this one is the calorie count" in a format it can lift directly into a search result.
Without that markup, a search engine has to infer structure from raw HTML, which it does imperfectly and inconsistently. With it, the page becomes eligible for the enhanced result types, commonly called rich results, that occupy more visual space and tend to pull a higher click-through rate than a standard listing.
Why most sites still skip it
Schema markup has been part of the SEO conversation for over a decade, yet a large share of sites still ship none at all. The usual reason isn't that people don't know about it. It's that writing raw JSON-LD by hand is tedious and easy to get subtly wrong: a missing closing brace, a property name that doesn't match the current spec, or a date field in the wrong format. None of these throw a visible error on the page. They just quietly disqualify the markup from being used.
That's the gap a schema markup generator is built to close. Instead of hand-typing nested JSON, you fill in structured fields for your content type and the tool assembles valid, spec-compliant JSON-LD you can paste straight into the page.
The schema types worth prioritizing
Not every schema type is equally valuable. A handful cover the overwhelming majority of practical use cases.
Article
For blog posts and news content, Article schema (or the more specific BlogPosting and NewsArticle subtypes) tells search engines the headline, publish date, author, and featured image in a structured way. It's foundational for getting a byline and timestamp to appear correctly in results.
FAQ
FAQPage schema turns a question-and-answer section into an expandable dropdown directly in the search result. It's one of the highest-visibility rich result types available to ordinary content pages, not just ecommerce or local business listings.
Product
Online stores use Product schema to surface price, availability, and review ratings next to a listing. Getting this one wrong, usually by showing a price that doesn't match what's on the page, is a common reason product rich results get suppressed.
Local Business
For a business with a physical location or service area, LocalBusiness schema (and its more specific subtypes like Restaurant or Dentist) feeds hours, address, and phone number into search and map results consistently.
How-To
Step-by-step guides can use HowTo schema to break instructions into a numbered, sometimes image-illustrated sequence right in the results. It rewards content that's already structured as sequential steps.
Event
Concerts, webinars, and local happenings can use Event schema to surface date, time, and ticket availability without the user clicking through first.
Photo by George Diamanto on Pexels
Generating markup without hand-coding JSON
A generator like EvvyTools' free schema markup generator works by walking you through the fields that matter for a given type: title, author, date, FAQ pairs, price, availability, whatever the schema calls for. It then outputs a complete <script type="application/ld+json"> block that's already structured to the current Schema.org vocabulary, ready to paste into your page's HTML.
This matters more than it sounds like it should. The spec for each type has required and recommended properties, correct nesting for objects like author or aggregateRating, and formatting conventions (ISO 8601 dates, for instance) that are easy to get wrong by hand and hard to debug once they're wrong, because the failure mode is silent. The page still loads fine. It just never qualifies for the rich result.
Validating before you ship it
Generating the markup is only half the job. Before it goes live, run it through a validator to confirm it parses correctly and satisfies the requirements for the rich result type you're targeting. Schema.org's own validator checks that your JSON-LD is syntactically valid and structurally sound against the vocabulary.
It's worth doing this every time, even for markup you generated with a tool, because the validator also catches content mismatches a generator can't always see on its own, like an FAQ answer that got truncated when you pasted it in.
Google also runs its own Rich Results Test, which checks the same JSON-LD against the specific requirements for whichever rich result type Google currently supports, separately from the general Schema.org spec. The two tools catch slightly different problems: the Schema.org validator confirms the markup is well-formed, while Google's tool confirms it actually meets the bar for a rich result to render. Running a page through both before it ships catches the overwhelming majority of issues before they cost you weeks of a missing rich result.
Common mistakes that get rich results rejected
A few patterns show up again and again in markup that fails to produce a rich result even though it technically renders without errors:
Content that doesn't match the visible page. If your JSON-LD claims a 4.8-star rating and the page shows no reviews at all, that's a mismatch search engines actively watch for, and it can lead to the markup being ignored entirely, not just for that field.
Markup on the wrong page. FAQPage schema only works when the actual questions and answers are visibly rendered on that page. Marking up content that lives somewhere else, or that's hidden behind a click, doesn't qualify.
Incomplete required properties. Each schema type has a short list of properties that are functionally mandatory even if the spec lists them as optional. Recipe without a image or Product without a price, for example, tends to disqualify the whole block from the rich result even if it validates cleanly.
Duplicate or conflicting markup. Multiple JSON-LD blocks describing the same entity with different values, often left behind after a redesign, can cause the whole page's structured data to be ignored rather than merged.
"The pages that keep their rich results long-term are the ones where someone actually checks that the markup still matches the content after every redesign, not just the ones who set it up once and walked away." - Dennis Traina, founder of 137Foundry
JSON-LD versus microdata and RDFa
Schema.org's vocabulary can technically be implemented three different ways: JSON-LD, microdata, or RDFa. Microdata and RDFa work by adding attributes directly onto the HTML elements that already display the content, which means the markup is woven through your template rather than sitting in one separate block.
JSON-LD won out as the practical default for a simple reason: it's decoupled from the visual markup entirely. You can add, edit, or remove structured data without touching the HTML that controls how the page actually looks, and a CMS can generate the JSON-LD block dynamically without a developer needing to hand-edit template attributes for every content type. Google has recommended JSON-LD as its preferred format for years, and most modern generators, including schema markup tools, output JSON-LD by default for that reason.
If you're inheriting an older site, you may still run into microdata sprinkled through the templates from years back. It's not broken, but it's harder to maintain, and migrating it to a single JSON-LD block during a redesign is usually worth the effort the next time you're already touching that page.
Where the markup actually belongs in your page
JSON-LD is designed to be placed anywhere in the <head> or <body> since it's not tied to the visual DOM the way microdata is. The common convention is to place it in the <head>, either as a static block for content that doesn't change or generated dynamically at render time for content management systems that pull from a database.
One practical note: if your site is built on a CMS, check whether a plugin or theme is already injecting schema markup before you add your own. Duplicate Article or Organization blocks describing the same page is a more common problem than an empty page with none at all.
Photo by weCare Media on Pexels
Monitoring performance after you publish
Once markup is live and validated, the last step is confirming it's actually being picked up and, ideally, tracking whether it moves click-through rate. Search Console's structured data reports flag pages where markup is present but has errors or warnings, which is the fastest way to catch a mismatch before it costs you a rich result for weeks.
It's also worth revisiting older pages periodically. Content changes, prices update, FAQ sections get new questions added, and stale markup that no longer reflects the page is exactly the kind of mismatch that gets a rich result quietly dropped without any notification that it happened.
Photo by Negative Space on Pexels
Getting started
If you're marking up your first page, start with whichever type maps most directly to content you already have finished: an FAQ section that already exists, a how-to guide already broken into numbered steps, or a blog post that already has a clear author and date. Generate the markup, validate it, paste it in, and confirm it in Search Console before moving to the next page.
The Schema Markup Generator on EvvyTools covers Articles, FAQs, Products, Local Business, How-To, and Events with live validation built in, so the output is ready to use rather than something you still have to debug by hand. Pair it with Schema.org's vocabulary reference and Google's structured data documentation when you need to confirm exactly which properties a specific type expects, and you can have a page's markup generated, validated, and live in under fifteen minutes.
For more free tools like this one, browse the full EvvyTools directory, or check the EvvyTools blog for more practical SEO and content guides.
