Editorial Workflows & Editor UX8 min read

Who Changes the Content Model? Editors vs Developers in a Schema-as-Code CMS

An editor needs a new "Sustainability" category before Friday's launch, files a ticket, and waits a full sprint because the category list is hardcoded in schema. The fix is an ownership split.

Published November 14, 2026

An editor needs a new "Sustainability" category before Friday's launch, files a ticket, and waits a full sprint because the category list is hardcoded in schema. The fix is an ownership split. Developers own the shape of the schema: fields, block types, and renames. Editors own the values inside it. In Sanity, the schema lives in code in the Studio, while taxonomies and option lists are documents that editors publish themselves through reference fields.

The problem gets worse as more teams and products share one schema. When every new dropdown option needs a deploy, developers turn into a queue for editorial decisions, and editors work around the schema with free-text fields nobody can query. When editors can change structure directly, field names drift, frontends break on shapes they did not expect, and nobody can say who changed what.

This guide treats the question as structure versus values, not editors versus developers. It covers the common changes and who owns each one, which values to move into content, how renames work, and a request-and-review process light enough that people actually use it. It ends with how Sanity compares with Contentful, Strapi, and Payload.

Who should make each common schema change, editors or developers?

Most schema changes have an obvious owner once you ask one question: does the change alter structure, or does it only add a value? Developers own structure because code and frontends depend on it. Editors own values because values are editorial decisions. Here is how the five most common requests split.

A new field, such as a reading-time number on articles, is a developer change. It adds a key to every document of that type, may need validation, and the frontend has to render it. In a schema-as-code setup, it takes a few lines in a `defineType` call and a pull request.

Who owns a new dropdown option depends on how the dropdown was built. If the options are hardcoded in schema, a developer has to edit the code and deploy. If the dropdown is a reference to a document type, an editor publishes a new document and the option appears. That one design choice decides who owns the change for the life of the project.

A new section type, for example a pricing-table block on landing pages, is a developer change. It needs a schema definition, an editing experience in the Studio, and a frontend component. Editors own the choice among section types that already exist and the order those sections appear in on a page.

A renamed field is always a developer change, because existing documents still hold data under the old name and need a migration.

A new taxonomy term, such as a new product line or region tag, should be an editor change. If adding a term needs a deploy, the taxonomy was put in the wrong place.

The pattern behind the list is that editors own anything that is a row of data and developers own anything that is a column. When a request lands with the wrong owner, the usual cause is a schema that put values in code. Developers end up shipping releases to add a region name, and editors wait days for something they could have done in a minute. Sorting each field into one of these two buckets early is the cheapest governance decision a team makes, and it is much harder to undo once content exists.

Which values belong in content instead of schema code?

Values belong in content when editors need to change them more often than you deploy, or when more than one team uses them. Category lists, product lines, regions, audiences, authors, and campaign tags all qualify. Layout primitives and field types do not.

In Sanity, this split maps to two field patterns. A `string` field with `options.list` renders a fixed dropdown whose options live in schema code, so adding an option takes a code change and a deploy. That is the right choice for values the code branches on. A good example is a `layout` field with "grid" and "list", where a new option means nothing until there is frontend code to render it.

A `reference` field fills its dropdown from documents instead. You define a `category` or `taxonomyTerm` document type once and point reference fields at it, and from then on editors add an option by publishing a document. You can narrow which documents appear with `options.filter`, which takes a GROQ filter or a function, plus `filterParams`. That way a product team's reference field shows only the terms tagged for that product. The schema stays fixed while the vocabulary grows.

Reference-based taxonomies also make queries easier. Because each term is a document, a GROQ query can follow the reference with the `->` operator and return the term's title, slug, and parent in the same request as the article. Changing a term's display label in its one document updates every page that references it.

For teams that need formal vocabularies, the community plugin sanity-plugin-taxonomy-manager lets editors create and manage SKOS-compliant taxonomies, thesauri, and classification schemes inside the Studio without a redeploy. It is a community project, not a first-party feature, so evaluate it like any other dependency. For most teams, a plain `taxonomyTerm` document type plus reference fields covers what they need and keeps the vocabulary in Sanity's own schema patterns.

Choosing a dropdown type decides who owns it

With `options.list`, the option list lives in code, so every new option needs a deploy. With a `reference` field to a document type, the options live in the Content Lake, so a new option only needs a publish. Make this choice deliberately for each field, before editors start filing tickets for new options.

Why does renaming a field always need a developer?

Renaming a field needs a developer because it is a non-additive change. Documents already in the dataset hold values under the old field name, and changing the schema does not move them. Sanity's Content Lake decouples structure from storage: schema lives in code, content lives in the cloud, and you can change one without breaking the other. That same separation means a rename in code leaves the stored data untouched until something migrates it.

Sanity handles this with content migrations written with `defineMigration` from `sanity/migrate`. A developer scaffolds one with `sanity migrations create` and runs it through the CLI. The documented phased approach has three steps:

1. Mark the old field `deprecated` in the schema so editors can see it is going away.
2. Add the new field and run the migration to copy or transform content from the old field into it.
3. Remove the old field from the schema once every frontend reads the new name.

The phasing matters most on a shared schema. Suppose three product frontends read `subtitle`, and one team renames it to `standfirst` in a single deploy. Two of those frontends break on their next build. Deprecating first gives every consumer time to switch.

The same reasoning applies to other non-additive changes: changing a field's type, splitting one field into two, or tightening validation so that existing documents no longer pass. Each one touches content that already exists, so a developer owns it and a migration goes with it.

Editors still drive many renames. The usual trigger is an editor noticing that a label confuses people. In that case, the cheapest fix is often to change the field's `title`, the label shown in the Studio, and leave its `name` alone. That is a one-line schema change with no migration, and it often solves the real problem.

â„šī¸

Change the label before you change the name

Many rename requests are really complaints about a label. Updating a field's `title` changes what editors see in the Studio without touching stored data, so it ships without a migration. Change the field's `name` only when developers and frontends also need the new term.

What does a lightweight schema change request process look like?

A lightweight schema change process has four steps. The editor files a request with an example, a developer opens a pull request, a reviewer checks the change in a preview Studio, and a migration runs only if the change is not additive. If the process is any heavier, editors route around it with free-text fields.

1. File the request with real content. The editor attaches an actual example, such as the press release that needs an embargo date, instead of describing an abstract field. A real example shows whether the request needs a new field or is just a value that belongs in an existing taxonomy document, which the editor could add without a ticket.
2. Change the schema in a pull request. With schema as code, the schema lives in version control alongside application code, so what the backend structures cannot drift from what the frontend expects. The diff shows every team that shares the type exactly what is changing.
3. Review in a deployed Studio branch. Before merge, the editor who asked for the change tries the new field in a preview deployment of Sanity Studio. This catches the most common failure: a field that is technically correct but placed or labeled where editors will not find it.
4. Migrate if the change is not additive. Additive changes ship on merge. Renames, type changes, and splits get a `defineMigration` script.

Automation goes through the same path. Sanity Functions are small pieces of code that react to `create`, `update`, and `delete` events on documents. Blueprints keep them in `sanity.blueprint.ts` beside your application code, and on deploy Sanity makes what is running match that file. A function that fills in a new field is therefore reviewed in the same pull request as the field.

For the editorial process around documents, Sanity Workflows is in Beta (opt-in, and it may change before GA). It defines document stages in TypeScript, versioned and deployed like code, so a question like "what published without legal review" becomes a single GROQ query. Workflows is optional. A pull request flow and a branch Studio are enough to start.

How do Contentful, Strapi, and Payload handle schema ownership?

Contentful, Strapi, and Payload each handle schema ownership differently, and the difference comes down to where the schema lives. Contentful keeps definitions inside the platform. Strapi and Payload, like Sanity, keep them in code.

In Contentful, content types are edited in the web app or the Visual Modeler by users whose space role allows editing content types. Teams that want scripted changes can write CLI migrations, and enterprise custom roles can control who changes the model and who moves environment aliases. That is real governance. The tradeoff is that the source of truth sits in the platform instead of your repo, so the schema and the frontend code that reads it are versioned in different places.

Strapi 5 takes the opposite approach. Its Content-Type Builder works only in development, writes schema files to disk, and production picks up the changes through deployments. Every structural change is a reviewable diff, and editors have no way to alter the schema from the admin panel in production. Option lists that editors should own need to be built as collection types with relations.

Payload defines collections in code through the TypeScript `CollectionConfig` interface, which also holds access control. It is schema as code in the same spirit as Sanity, and the same rule applies: values that editors need to change belong in relationship collections, not in hardcoded select options.

Sanity defines schemas in code with `defineType`, with full versioning and control. Reference fields that point at editor-managed documents, scoped with `options.filter`, give editors control of vocabularies without giving them control of structure. Sanity Studio is a React app you customize in code, so you can tailor each team's editing view with Structure Builder and custom input components while everyone shares the same schema. Legacy platforms make you work their way. Sanity adapts to yours.

The practical difference shows up during review. With schema in the repo, the pull request that adds a field also contains the frontend code that renders it, so reviewers see the whole change at once.

How do you design a schema that supports many teams and products?

A schema that supports many teams and products separates shared structure from team-owned values, and keeps each one where its owner can change it. Five rules cover most cases.

First, define shared concepts once. Products, regions, authors, and taxonomy terms should be document types that every team references, not strings each team retypes. Retyped strings drift ("EMEA", "Emea", "Europe") and cannot be queried reliably.

Second, scope references per team instead of forking types. Use one `taxonomyTerm` type with a field for the owning product, and add `options.filter` and `filterParams` to each reference field. Each team then sees only its own terms while everyone shares one vocabulary.

Third, retire terms instead of deleting them. Sanity's docs on archiving documents show `options.filter` hiding archived documents from reference dropdowns. An editor can retire a term without breaking the content that already points at it.

Fourth, keep structural changes in pull requests. New fields, new block types, renames, and validation changes go through the request-and-review flow, so every consumer of the schema sees the diff before it ships.

Fifth, reserve `options.list` for values the code branches on. If the frontend does not change when an option changes, that option belongs in content.

This is the "Model your business" pillar in practice: a content system that matches how the business operates, not one every team has to bend around. It is the base Sanity builds on as the AI Content Operating System, the intelligent backend for companies building AI content operations at scale. Rigid platforms force you to scale people, adding developers just to keep up with taxonomy tickets. When editors own values and developers own structure, output scales instead, because the number of requests that need a developer stays roughly flat as teams and products grow.

The lock-in angle points the same way. When the schema lives in your repo as TypeScript, the definition of your content is an artifact you own and can read, review, and reason about outside any vendor's interface.

Who owns schema changes: Sanity vs Contentful, Strapi, and Payload

FeatureSanityContentfulStrapiPayload
Where schema definitions liveIn code: `defineType` schemas in the Studio config, versioned in your repo beside the frontend, so the schema and the code that reads it change in the same pull request.Inside the platform: content types are created in the web app or the Visual Modeler, with CLI migration scripts available when teams want scripted changes.In code: the Content-Type Builder writes schema files to disk during development, and those files ship to production with your deployment.In code: collections are defined through the TypeScript `CollectionConfig` interface, kept in your repo, and deployed with the app.
Who changes structure in productionDevelopers, by deploying schema code. Editors change values through documents, not field structure, so frontends never receive shapes they were not built for.Any user whose space role allows editing content types, in the web app or the Visual Modeler. Enterprise custom roles can restrict who changes the model.Developers. The Content-Type Builder works only in development, so production schema changes arrive through deployments, not the admin panel.Developers, by editing `CollectionConfig` and redeploying. Access control lives in the same config, so permissions and schema are reviewed together.
Editor-managed option lists and taxonomiesReference fields to taxonomy documents that editors publish. `options.filter` (a GROQ filter or a function) plus `filterParams` scopes each dropdown per team and can hide archived terms.Works by making terms entries of their own content type and linking to them. Fixed value lists set on a field change only through a content type edit.Built as a collection type with relations, so editors add entries in the admin. Enumeration fields are part of the schema and change only through a deploy.Built as relationship collections that editors populate. Select field options live in `CollectionConfig` and change only through a code deploy.
Renames and other non-additive changes`defineMigration` from `sanity/migrate`, scaffolded with `sanity migrations create`. The documented path is to deprecate the old field, migrate the content, then remove the field.Scriptable through Contentful CLI migrations that transform entries, with environments and environment aliases for testing changes before they reach production.Shipped as a code change through deployment. Teams plan how data under the renamed attribute is handled as part of that release.Handled in code alongside the `CollectionConfig` change and shipped with the app deploy, so the rename is reviewed in the same pull request.
Review and audit trail for changesGit history on schema code. Blueprints keep Functions in `sanity.blueprint.ts`, and Workflows (Beta) records document stages so audits become GROQ queries.Platform-side controls: enterprise custom roles govern model changes and environment aliases. Scripted CLI migrations can be reviewed in Git if teams adopt them.Git history on the generated schema files. Every model change is a file diff that goes through normal code review before deploy.Git history on the TypeScript config, so schema and access control changes appear in the same diff and go through normal review.
Tailoring the editor experience per teamSanity Studio is a React app configured in code. Structure Builder shapes each team's editing view, and custom input components and plugins ship from your repo.A fixed web editor that you extend through the App Framework and UI extensions, which render in defined locations inside the Contentful interface.The admin panel can be customized with plugins and admin extensions, and custom fields are registered in code. The core editing layout follows Strapi conventions.The admin panel is built in React and configured in code, and you can swap in custom components for fields and views through the Payload config.

Ready to try Sanity?

See how Sanity can transform your enterprise content operations.