The short answer
Manual markup is a writing task: a person who understands the page adds the structured data that describes it. A generated entity graph is a modeling task: the entities and their relationships are defined once, and each page's markup is produced from that model.
Neither changes what schema is. They change who, or what, keeps it true as the site changes.
For a handful of stable pages, manual markup is honest, fast, and sufficient. The case for generation appears with scale and change: many pages describing the same entities, facts that move, and more than one hand editing. That is where page-by-page truth quietly becomes several truths.
Decision criteria
- How many pages describe the same entities: the business, its products, its locations?
- How often do the underlying facts change: names, offers, addresses, people?
- How many people or tools produce and edit pages?
- What happens when two pages disagree about the same entity, and who would notice?
- Can you validate the whole graph at once, or only one page at a time?
- What will this site look like after the next redesign or migration?
Side by side
| Dimension | Manual markup | Generated entity graph |
|---|---|---|
| Source of truth | Each page's markup, edited in place | One entity model; pages rendered from it |
| Consistency | Depends on every editor remembering every page | Enforced by the model; conflicts surface at generation |
| Cost of a changed fact | Find and edit every affected page | Change the model; regenerate the affected pages |
| Validation | Per page, mostly syntax | Whole graph: identifiers, relationships, contradictions |
| Startup cost | Low; the first page can be marked up today | Higher; the model has to be designed first |
| Failure style | Quiet drift between pages | A model error propagates, visibly, until fixed |
Tradeoffs that decide it
Manual markup fails quietly. Nothing breaks; the graph simply stops agreeing with itself, one forgotten edit at a time, and the disagreement is usually discovered by a machine resolving the wrong entity. A generated graph fails loudly: a modeling error appears everywhere at once, which is uncomfortable and useful, because it is found in validation instead of in production behavior.
Most real sites land in between. Recurring entities (the business, products, locations, people) belong in a model where they can be kept consistent. One-off pages can carry careful hand-written markup. The discipline is knowing which is which, and auditing the result as one graph either way.
The schema markup guideA worked comparison on one page
Take one service page. The manual way is to write the JSON-LD by hand: a WebPage node, a Service node, the Organization, and a BreadcrumbList, each field filled in from the page. A careful pass takes about an hour, and the result is exact — because a person who understands the page wrote it. The cost arrives later: every change to the service means editing the block, and every new page means writing another one.
The graph way is to define the entities once. The service, the business, and the relationship between them are stated in a model. Each page’s markup is then produced from that model, so the service page, the services index, and the related guides all describe the same service in the same words. A change to the service is one edit to the model, and every page that references it updates. The cost arrives first: the model has to be built, and it has to be right, before any page benefits.
Manual wins when the site is small and stable — one page, a few entities, content that rarely changes. The graph wins when the site is large, when entities are shared across pages, or when the content changes often. The migration path is to start with the manual block, extract the entities into a model, generate from the model, and keep the manual block as the reference until the generated output matches it. SchemaGraph examines the graph the pages describe, whichever way the markup was produced, so drift and contradiction are visible before you choose an approach.
The choice is not about which method is more correct. Both produce the same structured data when they are done well. The choice is about where the work is paid: a little at a time, on each page, or once, in the model, and then never again for that entity.
The model also outlives any single page. When a page is redesigned or a service is renamed, the model stays, and the new page is generated from it. The manual block is rewritten from scratch.
Common questions
Does generated markup rank better?
Markup describes; it does not rank by itself. The gain from generation is consistency and maintainability across many pages, not a more powerful tag.
Can I start manually and switch later?
Yes. Carefully marked-up pages are the inventory the entity model gets built from, so early manual work is not wasted, provided the facts in it are accurate.
Where does SchemaGraph fit?
SchemaGraph examines the graph your pages describe, whichever way the markup was produced, so drift and contradiction are visible before you choose an approach.