How it works

Build it once, and Sitecore puts it on every page

JSON-LD Schema Manager is a SitecoreAI Marketplace app that lets your marketing team manage schema markup without code. You build graphs once, and Sitecore renders the JSON-LD into every page built on the matching template.

Get the app Documentation

The big picture

From one block to every page

A block sits inside a graph. The graph becomes a partial design in Sitecore, the partial design sits in a page design, and every page built on that page template publishes the JSON-LD.

A diagram of how a graph reaches your pages. A page design holds partial designs. One partial design holds a graph, and the graph holds an Article block that uses the Organization Mini shared record. The shared record sits above the site and is shared by blocks on every site in scope. The page design is attached to a page template, and every page built on that template, from Page A to Page F, publishes the JSON-LD.

Diagram: a graph sits inside a partial design and a page design, and reaches every page built on the page template.

The building blocks

Three items you work with

We have designed three core items to build your schema. The block is the shape of your entity. The shared record holds the facts you state once. The graph groups blocks, links them to a content type, and sets the values. The guides and in-app support will help you use these to build your schema.

Block

The shape of your entity

Each block contains one schema.org entity type and the properties you want to use. Around 30 come pre-built and ready to be built.

JSON-LD Schema Manager Article block, showing the schema.org Article type with its properties @id, headline, datePublished, image, author and publisher, none of them filled in yet.

The Article block: its properties, with no values.

Shared record

The facts you state once

Fixed text, typed once. Every graph that points at it publishes exactly the same thing.

Expand

The Organization Mini shared record: @id, name, url and logo, typed once.

Graph

Group blocks, link them to a content type and set the values

The graph contains the Article block. Its publisher property references the Organization Mini shared record. The graph becomes a partial design in Sitecore.

JSON-LD Schema Manager Article Graph, linked to the Article page template, with a source for each property: automatic values, the Title, Main image and Author page fields, and the Organization Mini shared record.

The Article Graph, linked to the Article page template, with a source for every property.

Inside a graph

Every value knows where it comes from

A graph maps the properties of each entity type to the template fields once. Every page built on the template then supplies its own values.

JSON-LD Schema Manager Article Graph for the Article block, with a source for each property: @id and datePublished set automatically, headline from the page Title field, image from the Main image field, publisher from the Organization Mini shared record, and inLanguage set automatically.

Page fields are available on every page that uses the mapped template. The values of those fields supply the values for the properties, such as the title or the main image.
Shared records are built once with fixed text, then reused across your blocks. For example, your Organization is the publisher of the website, the provider of a product and the employer of a person.
Automatic values, such as the site’s language or the page’s publish date, come from the page itself.
Fixed text is typed in once, for example the legalName property of the Organization type.

Connecting your entities

A stable identifier for every entity

Each entity your pages describe, such as your organization, a person or an article, gets an @id. It is a stable identifier that stays the same on every page that mentions the entity. Blocks point at each other by @id, so search engines and answer engines join them into one picture of who you are and what you publish.

Auto-generated. JLSM builds the @id from the page’s own address and the type. Use it for things that belong to one page, such as an article.
Custom pattern. Set a fixed base address for things that are the same everywhere, such as your organisation. Add the page’s slug to the pattern for things like people, so each one keeps its own identifier.
Generated, never typed. JLSM writes every @id in the same form, so identifiers do not drift from page to page.
Details share their parent’s identity. An address or opening hours sit inside the entity they describe, so they need no @id of their own.

One article, two connected entitiesCopy

{
  "@type": "Article",
  "@id": "https://www.example.com/articles/plan-a-home-renovation/#article",
  "author": {
    "@id": "https://www.example.com/people/alex-smith/#person" },
  "publisher": {
    "@id": "https://www.example.com/#organization" }
}

The article’s identifier is auto-generated from its page. The author and publisher use custom patterns, so every page that mentions them points at the same entity.

What is rendered on the page

In the page, where every crawler reads it

The JSON-LD is part of the HTML every visitor receives, in the head of the page, above the main content. Nothing is injected by a script.

Rendered HTML · where Sitecore puts itCopy

<head>
  <title>How to plan a home renovation</title>
  <!-- Partial design: Article Graph -->
  <script type="application/ld+json">
    {
      "@context": "https://schema.org",
      "@graph": [
        {
          "@type": "Organization",
          "@id": "https://www.example.com/#organization",
          "name": "Example Group",
          "url": "https://www.example.com"
        },
        {
          "@type": "Article",
          "@id": "https://www.example.com/articles/plan-a-home-renovation/#article",
          "headline": "How to plan a home renovation",
          "author": {
            "@type": "Person",
            "@id": "https://www.example.com/people/alex-smith/#person",
            "name": "Alex Smith"
          },
          "publisher": { "@id": "https://www.example.com/#organization" }
        }
      ]
    }
  </script>
</head>
<!-- the page body follows -->

Building it in the app

Drag and drop to build, then check before it goes live

Step 1

Pick the blocks the page needs

Around 30 arrive pre-configured for the types enterprise sites use, and the whole schema.org catalogue sits behind them.

Expand

The block library, grouped the way a marketing team thinks.

Step 2

Point each property at your content

A field on the page template, a fixed value typed once, or a shared record. Changing a mapping is a content change and a publish, not a ticket and a backlog.

JSON-LD Schema Manager graph editor showing the Article Graph, with headline, image and author mapped to page fields, publisher pointed at the Organization Mini shared record, and @id, datePublished and inLanguage set automatically.

The graph editor. Each property points at a field, a fixed value or a shared record

Step 3

Preview, validate and publish

See the exact output for a real page before it goes live, then copy it to the Schema.org validator or Google Rich Results Test. In-app guides tell you when you've missed required values.

The Preview tab for the Article Graph in JSON-LD Schema Manager, showing the JSON-LD it will publish, starting with the Organization entity. Handy links to the Rich Results Test and the Schema Markup Validator sit above it.

The preview shows exactly what the sample page publishes.

Ownership

Your data, with your IP, on your infrastructure

This is the question most developers ask first, so here is the plain answer. The app is a user interface that makes a set of complicated Sitecore content items easy to configure, provides strategic help to deliver the best results, and keeps them current as the schema.org vocabulary changes.

You own the items and they stay that way

The schema configuration is content items in your own Sitecore content tree. It is your content and your IP, under your governance. It stays there if you stop using the app.

Your infrastructure does the work

At page building and publishing time, it is your hosting and your environments, running Sitecore’s own rendering. Nothing of ours takes part in delivering a page.

Your data sovereignty is respected

Nothing about your schemas, field values or usage is held anywhere outside your own Sitecore infrastructure. There is no new place for your data to sit.

What ART Software holds

Billing details only, in Stripe. Nothing from your Sitecore tenant.

Who builds and supports it

PING Works, a Sitecore Gold Partner, and an ISO 9001 and ISO/IEC 27001 accredited provider and Microsoft CSP.

Frequently asked questions

Does JLSM change my page content?

No. It adds JSON-LD to the page through a partial design. Your page content stays as it is.

Is the JSON-LD added by JavaScript?

No. It is part of the page HTML, so every crawler reads it, including AI crawlers that do not run JavaScript.

Can I check it before it goes live?

Yes. The preview shows the exact JSON-LD for a sample page, and you can send it to the Google Rich Results Test from the same screen.

What happens if a required value is missing?

The graph shows VALUE NEEDED. JLSM leaves that property out rather than publish an empty value, so the entity is not valid until you add one.

Can I change an @id after it is published?

You can, but it gives that entity a new identity, and search engines treat it as a new thing. Set your patterns before you publish.

Do I need a developer?

For a few hours at the start, to add the rendering component. After that, your marketing team does the work.

Ready to get going, and want to know if your site is too?

Request a free schema gap analysis. We check your site, show you what it publishes today and what is missing, and talk you through what JSON-LD Schema Manager would add.

Request your free gap analysis Get the app Documentation > What you need