The New “Content Types System” in WordPress

When the WordPress Core team announced the Content Types System (CTS) experiment in early 2026, it immediately sparked conversations across the developer community. At first glance, it might sound like an incremental improvement: a new way to register and manage custom post types (CPTs). But dig deeper, and it becomes clear that this experimental framework could fundamentally change how WordPress defines, stores, and interacts with content in the next era of the platform.

If WordPress 7.0 was about stability, then CTS is about evolution—a long-anticipated bridge between WordPress’s traditional database-driven model and the emerging need for flexible, schema-aware, and API-native content architectures.

This in-depth analysis explores what the Content Types System is, how it works, why it matters, and how it could reshape editorial workflows, content modeling, and development practices inside WordPress for years to come.

1. Why WordPress Needs a Content Types Revolution

WordPress began in 2003 as a blogging tool. Over two decades, it evolved into a comprehensive content management system, powerfully extended by custom post types (CPTs) and custom fields (meta) introduced in the 3.x era.

These tools made WordPress flexible—but not without limits. The traditional approach to defining content types comes with three big challenges:

1. Fragmented Definitions
   Every CPT lives in PHP code, often scattered across themes and plugins. Developers must register post types manually with register_post_type(), add custom taxonomies with register_taxonomy(), and define metadata, capabilities, and edit UI behavior separately.

2. Limited Interoperability
   Custom data models defined in code are not natively portable or API-introspectable. REST-API schemas must often be maintained manually, leading to inconsistency between frontend and backend representations.

3. Complex Editorial Workflows
   Editors interact with these data structures indirectly through meta boxes, which can feel awkward and disconnected from the block-based editing experience.

As WordPress transitions into its third Gutenberg phase—Collaboration and Workflows—the platform requires a new content foundation: one that is descriptive, declarative, and API-first. That’s where the Content Types System comes in.

2. Introducing the Content Types System (CTS)

The Content Types System—launched as an experimental feature in WordPress 7.0—is a new internal architecture for defining and managing content entities using JSON schemas rather than PHP code.

In essence, it moves WordPress toward a schema-driven model, similar to what developers see in modern headless CMSs (like Sanity, Strapi, or Contentful), but fully integrated into WordPress’s existing ecosystem of posts, taxonomies, and blocks.

At its core, CTS introduces a way to:

• Declare content structures (post types, fields, and relationships) in human-readable configuration files.
• Expose these definitions to the REST API for consistent headless integrations.
• Enable non-developers to register and edit content types visually within the Site Editor in future versions.

Initially, the system ships as an experimental framework, meaning it’s not part of WordPress Core’s default behavior but available to developers who opt in by activating experimental flags or Gutenberg plugin builds.

3. The Philosophy: From Code to Configuration

To understand the philosophical leap CTS represents, consider how content types are registered today. A typical functions.php example might look like this:

function create_book_post_type() {
    register_post_type('book', [
        'label' => 'Books',
        'public' => true,
        'show_in_rest' => true,
        'supports' => ['title', 'editor', 'thumbnail'],
    ]);
}
add_action('init', 'create_book_post_type');

That’s simple, but it’s procedural, imperative, and locked in code.

The new Content Types System takes a declarative approach, allowing content types to be defined using JSON. For example:

{
  "name": "book",
  "label": "Books",
  "description": "A custom content type for books.",
  "supports": ["title", "editor", "thumbnail"],
  "taxonomies": ["genre"],
  "fields": [
    { "name": "author", "type": "string", "label": "Author" },
    { "name": "published_date", "type": "date", "label": "Published Date" },
    { "name": "isbn", "type": "string", "label": "ISBN" }
  ],
  "rest": { "expose": true }
}

This file can live inside a theme, plugin, or even the site’s configuration directory (like /wp-content/types/book.json). When WordPress loads, it parses this schema and automatically registers the corresponding post type, meta fields, and REST routes.

The approach echoes theme.json and block.json files from the Site Editor era, aligning with WordPress’s broader shift toward structured configuration over procedural registration.

4. What the Experiment Includes in WordPress 7.0

The experimental Content Types System in WordPress 7.0 is designed primarily for developer exploration. It’s still under active development, but already includes some key capabilities:

a. JSON-Based Content Type Definition

Developers can create JSON files that describe new content types, and WordPress will automatically translate those into working post types on load.

b. REST API Schema Generation

Each defined content type automatically produces a REST schema, making it visible to headless frontends. This ensures parity between backend definitions and public data structures.

c. Taxonomy and Field Linking

CTS supports linking built-in or custom taxonomies directly within the JSON file, promoting consistency and reducing the need for extra PHP hooks.

d. Experimental UI Hooks

In the Gutenberg plugin, there’s a prototype UI for browsing and inspecting registered content types. The long-term plan is to integrate this into the Site Editor, letting administrators create and manage new content types without code.

e. Synced Configuration

A major vision for CTS is to allow configuration sync—meaning the content type definitions could be version-controlled, exported, or imported between environments, much like block patterns and templates.

5. Technical Underpinnings

The system is built on a few foundational ideas that will be familiar to developers following Gutenberg’s evolution:

• WP Object Registry Abstraction: A more consistent layer for managing instances of post types, taxonomies, and other registered entities.
• Schema Inference: Automatic generation of REST schema and editor configuration from a single JSON descriptor.
• Theme and Plugin Integration: Just as blocks and patterns are discoverable through block.json files, CTS allows similar discoverability for content definitions.
• Declarative Metadata: Meta fields (custom fields) are formally described with data types, validation rules, and labels for UI generation.

This means that in the near future, themes could ship with both design patterns and content definitions, giving users turn-key custom content setups right out of the box—no custom coding required.

6. How CTS Could Reshape Custom Post Types

The impact of CTS on custom post types (CPTs) is potentially revolutionary.

Here’s how it evolves traditional behavior:

Traditional CPT (WordPress ≤6.x)	CTS Approach (WordPress ≥7.x)
Defined in PHP code using register_post_type()	Declared in JSON using a schema file.
Requires manual taxonomy, meta, and capability registration.	All relationships defined together in one file.
REST API support optional and uneven.	Full REST schema generated automatically.
Modifications require code changes and redeploys.	Changes can be synchronized through configuration.
Difficult for non-developers to modify.	Future UI will allow safe visual management.

This shift democratizes content model creation. Non-developers, once reliant on plugins like Custom Post Type UI or Advanced Custom Fields, may soon be able to manage CPTs natively—through an official, natively supported interface.

7. Rethinking Content Modeling in WordPress

Content modeling is the practice of defining how information is structured, related, and reused. Until now, WordPress has relied on a somewhat ad-hoc model—posts, pages, taxonomies, and meta fields loosely coupled by developer convention.

CTS lays the groundwork for a first-class content model layer, which could include:

a. Structured Field Definitions

Each field in a content type can declare its data type, validation rule, and UI rendering hint. For example:

{
  "name": "event",
  "fields": [
    { "name": "date", "type": "date", "label": "Event Date" },
    { "name": "location", "type": "object", "label": "Location", "properties": {
        "city": "string",
        "country": "string"
      }
    }
  ]
}

This schema-aware approach opens doors to auto-generated editing interfaces, consistent validation, and API contracts without boilerplate.

b. Rich Relationships Between Types

Future iterations of CTS plan to introduce relationship fields, letting authors link content types (e.g., “Books” linked to “Authors”) more intuitively. These will likely build upon existing mechanisms like post relationships and taxonomies, but with formal schema guarantees.

c. Shared and Reusable Type Libraries

Organizations could bundle reusable type definitions—like “Event,” “Product,” or “Testimonial”—into packages versioned independently. Imagine installing a reusable library of structured content models via Composer or the WordPress plugin directory.

This modularity could inspire a new ecosystem around content model libraries, similar to today’s block pattern ecosystem.

8. Editorial Workflows: Toward Structured Collaboration

While CTS may seem developer-centric, its long-term implications for content creators and editors are just as profound.

a. Uniform Editing Experiences

Because each field is explicitly declared in a schema, WordPress can automatically render consistent input interfaces—eliminating the random assortment of meta boxes and custom UI widgets prevalent today. Editors will experience cleaner, structured forms that match the underlying data model exactly.

b. Smarter Validation and Error Handling

Schema-defined validation rules (e.g., “ISBN must be 13 characters”) mean editors can catch data issues instantly, rather than after publication. These constraints bring WordPress closer to enterprise-grade CMS sophistication.

c. Built-In Documentation

CTS fields carry human-friendly labels and descriptions, which can double as in-editor help text. This helps teams share a common vocabulary across content workflows.

d. Streamlined Collaboration

When combined with the forthcoming Real-Time Collaboration (RTC) features expected in WordPress 7.2–7.3, CTS could enable multiple editors to collaborate on richly structured content, each seeing changes reflected live within defined fields.

The ultimate vision: content modeling, authoring, and collaboration become unified under one intuitive system.

9. How CTS Paves the Way for Headless and Multichannel WordPress

WordPress’s journey toward being a full-fledged headless CMS has long depended on the REST API. But the REST schema for custom content was often inconsistent, since CPTs could define arbitrary metadata.

With CTS, every field and relationship is defined with type information, enabling predictable, introspectable APIs—critical for Gatsby, Next.js, or Astro frontends consuming WordPress data.

Because REST endpoints can now be generated automatically from schema definitions, headless developers no longer have to handcraft API endpoints. This makes deployments faster, safer, and more portable.

In addition, CTS’s declarative structure could eventually inform GraphQL schemas, content migration tools, and federated content networks, significantly broadening WordPress’s role in decoupled and multichannel ecosystems.

10. Comparing WordPress CTS to Other Systems

Platform	Content Definition Model	Key Strength
WordPress (Legacy)	Imperative PHP + Database Meta	Familiar, but rigid
WordPress CTS (Experimental)	JSON schema, declarative	Unified, API-driven
Contentful / Sanity.io	Schema-based models (JSON/YAML)	Introspectable, robust
Drupal	Entity/Field system	Highly structured, complex
Strapi	JSON-based content models with REST/GraphQL	Modern, flexible
Ghost	Limited structured types	Simplicity over diversity

What makes the WordPress CT System unique is continuity: it doesn’t discard existing data or force a new paradigm. Instead, it layers modernization on top of 20 years of backward compatibility. Developers can gradually adopt the declarative approach while legacy code keeps working.

11. Implementation Examples and Use Cases

Let’s explore how CTS would manifest in practical scenarios:

Example 1: A “Podcast” Site

Under current setups, developers must write code to register CPTs, metadata, and custom views.

With CTS, one schema can define everything:

{
  "name": "podcast_episode",
  "label": "Podcast Episodes",
  "description": "Individual episodes in our podcast feed.",
  "supports": ["title", "editor", "excerpt", "thumbnail"],
  "fields": [
    {"name": "duration", "type": "number", "label": "Length (minutes)"},
    {"name": "audio_url", "type": "url", "label": "Audio File"},
    {"name": "guest", "type": "string", "label": "Guest Name"}
  ],
  "rest": {"expose": true}
}

Within the editing screen, editors would see fields formatted correctly (number, URL, text) and benefit from validation and API-ready output.

Example 2: A Custom Product Catalog

For an agency maintaining e-commerce landing pages outside WooCommerce, CTS allows lightweight product definitions:

{
  "name": "catalog_item",
  "fields": [
    {"name": "price", "type": "number"},
    {"name": "available", "type": "boolean"},
    {"name": "category", "type": "taxonomy", "taxonomy": "product_category"}
  ]
}

Editors gain a product input form that pairs cleanly with block templates, while frontend developers can rely on structured JSON to render product details dynamically.

12. The Road Ahead: From Experiment to Core

WordPress contributors have outlined a tentative multi-stage evolution plan for CTS:

1. Experimentation (7.0–7.1)
   JSON-based content type registration for developers, hidden behind the Gutenberg plugin’s experimental flag.

2. Schema API Expansion (7.1–7.2)
   Adding validation, relationships, and richer field definitions.

3. Visual Interface (7.3–7.4)
   Integrating a UI within the Site Editor for administrators to create and modify content types.

4. Configuration Sync (8.0+)
   Allowing content type definitions to synchronize across environments—opening the door for version-controlled WordPress sites.

This evolution mirrors how block-based design tools like Global Styles matured from experiments into Core mainstays.

13. Benefits for Developers and Agencies

The CTS framework offers major practical benefits:

• Version Control-Friendly: Because definitions are in JSON files, they can be reviewed, diffed, and collaboratively developed via Git.
• Fewer Plugin Dependencies: Many popular CPT/field plugins may eventually use CTS under the hood, simplifying site stacks.
• Clearer Migration Paths: Schema definitions can serve as blueprints for migrating or replicating content between staging and production environments.
• Improved Testing: Automated testing tools can read the schema directly to mock or validate content structures.

Agencies building multisite networks or reusable templates gain particular leverage, as content modeling can become part of the deployment pipeline rather than post-deployment manual setup.

14. Challenges and Open Questions

Despite the excitement, the Content Types System still faces hurdles before mainstream adoption:

• Backward Compatibility: WordPress must ensure legacy register_post_type() sites remain functional.
• Meta Key Conflicts: Merging older meta fields into schema-driven definitions requires migration tooling.
• Performance Considerations: Parsing JSON files at runtime introduces overhead; likely caching strategies (like precompiled manifests) will emerge.
• User Permissions: Who gets to create or modify content schemas? This introduces potential complexity around roles and capabilities.
• Plugin Ecosystem Integration: Large frameworks such as Advanced Custom Fields (ACF) and Pods must decide how to integrate or coexist with CTS.

Open discussion continues among contributors on make.wordpress.org/core as developers weigh design trade-offs between flexibility, performance, and simplicity.

15. Long-Term Vision: WordPress as a Schema-Driven CMS

The introduction of CTS signals WordPress’s commitment to a schema-first future. Imagine this scenario a few releases from now:

• A content strategist opens the Site Editor and defines a new “Event” type visually.
• WordPress saves the underlying JSON schema automatically.
• A frontend developer queries it via REST or GraphQL, confident in its data shape.
• The AI Assistant (now baked into WordPress.com) suggests a matching template block pattern for event displays.
• Team members collaborate in real-time to populate data.

This integration of structured modeling, intelligent tooling, and collaborative editing is where WordPress is headed. CTS is the quiet architecture enabling that shift.

16. Community Reaction and Early Feedback

Contributors testing CTS in the Gutenberg nightly builds have praised its clarity and potential.

“This is what we’ve needed for a decade—declarative CPTs that belong to the site, not the theme.” — Developer feedback, March 2026.

Others see it as a natural extension of WordPress’s recent progress:

“We went from hardcoded PHP templates to block templates, from inline CSS to theme.json, and now from register_post_type() to JSON-based CTS. Everything is aligning.”

Of course, there’s also healthy skepticism. Some developers worry that abstracting too much might confuse users who prefer code control. Others raise performance or complexity concerns. But the sentiment is overwhelmingly constructive. WordPress has matured to where this kind of structural evolution is not just possible—it’s eagerly awaited.

17. The Broader Implications: Content Infrastructure for the Open Web

Beyond WordPress itself, CTS hints at a future where open content interoperability becomes reality.

Imagine being able to export a type definition from one CMS and import it into another, standardized by schema conventions. If WordPress helps popularize a portable JSON-based model, it could lay the foundation for a broader open web standard for content modeling.

This potential extends WordPress’s long-standing mission: to empower publishing through open, extensible technology—now updated for the era of structured data and API-driven ecosystems.

18. Conclusion: The Foundation for WordPress’s Next Decade

The Content Types System isn’t just another experiment—it’s a pivot point. It represents WordPress’s shift from procedural legacy to declarative flexibility; from ad hoc meta fields to structured content intelligence; and from developer-only configurations to shared, collaborative modeling tools.

By externalizing content type logic into portable, human-readable schemas, WordPress is setting the stage for:

• Consistent, API-driven content across channels.
• Simplified editing interfaces grounded in formal structure.
• Seamless collaboration and version control for content architecture.
• Long-term sustainability that respects backward compatibility.

In the same way that Gutenberg redefined the editing experience, CTS aims to redefine the modeling experience—where WordPress becomes not only a place to write and design content, but also to shape and structure it at the core.

If successful, the system could become one of the most transformative updates since the introduction of custom post types themselves. And much like Gutenberg in 2018, it may take a few versions before its power is fully apparent—but when it does, it will mark the true arrival of WordPress as a schema-driven, collaborative content platform for the open web.