Whoever owns the template that emits it, with one named reviewer who tracks the rules. Structured data is code that makes claims about content, which puts it between two teams, and markup that belongs to both teams in theory belongs to nobody in practice.
Why does split ownership break markup specifically?
Because the two halves fail silently in opposite directions. A developer can ship valid markup that says something untrue about the page, and a marketer can specify correct claims that the template never actually emits.
Neither failure announces itself. The page looks right, the validator is content, and the enhancement report in Search Console takes weeks to register a change in eligibility. Compare that with a broken checkout, which tells you inside an hour. A field quietly starts emitting an empty value after a CMS migration and the markup stays technically valid while the claim it makes becomes meaningless. Nobody is assigned to notice, because noticing was never anyone's deliverable.
Which parts are a developer's job and which are not?
The split is clean once you write it down: developers own the emission, the content side owns the claims, and one person owns knowing what the rules currently require.
| Artifact | Owner | Review triggered by |
|---|---|---|
| Template that renders the markup | Engineering | Any template or component change |
| Which fields map to which properties | Content or SEO lead | New content type, renamed field |
| Truth of the claims against the page | Content or SEO lead | Page redesign, copy rewrite |
| Current eligibility requirements | One named reviewer | Documentation change, report warning |
| Monitoring and alerting | Engineering, specified by SEO | Error or drop in valid items |
The pattern that works is a single accountable name per row rather than a team name. Teams do not read reports; people do.
Markup is the only part of a page that can be wrong while looking perfectly right to everyone who reviews the page. That is why it needs an owner rather than a process.
What happens when a plugin or the CMS generates it?
Ownership gets harder, not easier, and the risk moves to the seam. A plugin emits schema markup on its own schedule, from fields someone else edits, with defaults nobody chose.
Two specific failures come from this. The first is duplication: the theme emits one block, the plugin emits another, and the page makes two competing claims about the same thing. The second is the update that changes output without changing any content, which is the hardest kind of regression to attribute because version control shows nothing. Whoever owns the markup has to own the plugin version too, including the decision not to update it, or the ownership is nominal.
This matters most where the markup drives something visible. Product schema carries price and availability that change without anyone touching a template, and review schema depends on aggregate values that shift as reviews arrive. Those are live claims, not launch-day configuration.
Who notices when the rules change?
One person, named, who reads the documentation and the Search Console enhancement reports on a schedule. Google adjusts which types are eligible, which properties are required and how results are presented, and none of those adjustments arrive as a ticket.
This is the role teams skip, and skipping it has a predictable shape. A property that was recommended becomes required, the existing markup keeps validating, and eligibility quietly ends. Nothing in your repository changed, nothing in your reports breaks loudly, and the loss in organic search presentation shows up as a gentle decline that gets attributed to something else entirely, usually an algorithm update nobody can verify.
Treating the launch validation as the work. Markup passing on the day it ships says nothing about the version running six months later, after a migration, a plugin update and two copy rewrites.
What does ownership look like in the release process?
Three hooks, each small enough to survive a busy quarter. A check when templates change, a check when content types change, and an alert when valid items fall.
The template hook belongs in code review: any change to a component that renders markup gets the markup checked against a live URL before merge, not after. The content hook is a question in the brief for a new content type, asking which properties it needs and who confirms them. The alert is the cheapest of the three and the one that catches what the other two miss, because it watches the running site rather than the intent. Set it on the count of valid items per type, so a drop surfaces as an alert rather than as a quarterly discovery.
How do you tell whether anyone really owns it?
Ask two questions in your next planning meeting. Who gets paged when valid items drop, and who decided what the markup currently claims? If either answer is a team name, a former employee or a consultant from a previous project, your markup is unowned regardless of how good it was when it shipped. Pick the name for each row of that table this week, and the first thing the new owner should do is compare what the templates emit today against what someone signed off on.