Content creation: Strapi vs headless WordPress

When comparing Strapi vs WordPress as a CMS for content creation, the experience varies greatly as they take two completely distinct approaches to content creation, each designed to cater to the needs of their primary audiences—developers in the case of Strapi and non-technical users for WordPress. Let’s take a look at each.

Strapi: A flexible but developer-centric approach to content

Strapi emphasizes flexibility and customization, making it a go-to option for technical teams. However, this also means that its editor experience isn’t as feature-rich as those from traditional CMS platforms.

Here are key content creation features in Strapi.

Creating content in Strapi

In Strapi, content modeling refers to defining and structuring the types of content that your site will manage. This process involves creating “content types,” which are essentially templates for how data will be stored and organized. These content types can be customized to include various fields (such as text, media, dates, and relations) based on the needs of your application or website.

Let’s consider an example where you want to model a blog post in Strapi. Here’s how you would go about it.

Create a content type:
- In the Strapi admin panel, navigate to the “Content-Type Builder.”
- Click “Create New Collection Type” and name it “Blog Post.”
Define fields:
- Add the necessary fields for a blog post. Common fields might include:
  - Title (Text): The title of the blog post.
  - Content (Rich Text): The body content of the post, where you can write your blog text.
  - Author (Relation): A relationship to an Author content type if you want to link blog posts to authors.
  - Published date (Date): The date when the post is published.
  - Image (Media): A featured image for the blog post.
Set up relationships:
- You can create relations between content types, like linking a blog post to an author (for example, a 1-to-many relationship with the “Author” content type), so each blog post has a specific author. (Strapi supports one-to-one, one-to-many, and many-to-many relationships, ideal for building complex data models like product catalogs or hierarchical menus.)
Content creation:
- Once the content type is defined, you can begin creating individual blog posts. In Strapi’s admin panel, you can add new blog posts by filling out the fields based on your model.
  - Example entry for a blog post:
    - Title: “How to use Strapi for headless CMS”
    - Content: “In this blog post, we’ll explore how Strapi can be used as a headless CMS…”
    - Author: “Jane Doe”
    - Published date: “2024-12-30”
    - Image: [Uploaded featured image]
Content delivery:
- After creating a blog post, Strapi provides API endpoints (REST or GraphQL) that allow you to query the content. For example, you can fetch the data for the blog post through a simple GET request to display the blog post on a website.

Strapi allows developers to define content types tailored to their needs, such as single types (e.g., “About Us” pages) and collection types (e.g., blog posts or products).

Strapi’s limitations when it comes to content creation

Customizable but basic
Strapi’s editor includes Markdown support and a basic WYSIWYG editor, but it lacks advanced formatting tools, drag-and-drop interfaces, and intuitive workflows. (The more recent versions have introduced some drag-and-drop functionality.)

Role-based access
Admins can assign granular permissions through Role-Based Access Control (RBAC), ensuring editors only access relevant content.

Workflow features

Strapi lacks built-in tools for content approvals, scheduling, or collaboration, requiring custom implementation or third-party integrations. (The enterprise edition brings some though.)

Media management

The media library supports basic upload and management but lacks advanced features like bulk editing, image optimization, or streamlined handling of large media libraries.

Editor usability
Strapi’s minimalist design prioritizes developers over editors. Non-technical users often struggle with navigation, formatting rich content, and accessing basic content creation features.

Also, frequent updates in Strapi can introduce breaking changes that disrupt editor workflows and require developer intervention, such as API adjustments or schema migrations.

A limited feature set

Strapi focuses on foundational content management, but SEO tools, analytics, and advanced scheduling require additional customizations or third-party tools.

WordPress: Editor-friendly and versatile

WordPress is built with content creators in mind, delivering an intuitive, feature-packed experience right out of the box. Its extensive ecosystem ensures it’s just as accessible for non-technical users as it is for developers, even in headless setups. Here are key content creation features in WordPress (headless implementations).

Creating content in WordPress

In a headless WordPress setup, the content modeling process is quite similar to traditional WordPress but with the added flexibility of delivering content via APIs (REST API or GraphQL) rather than relying on WordPress’s frontend rendering. You still create content types (like blog posts, pages, or custom post types), but instead of displaying them directly in a theme, you expose the content through API endpoints to be consumed by various front-end technologies

Let’s now look at how you would structure a blog post in a headless WordPress setup:

Create a post type:
- Just like in traditional WordPress, you can use the default “Post” post type, or you can create custom post types using plugins (e.g., “Custom Post Type UI”) or custom code. For a blog post, the default post type is typically sufficient.
Define fields:
- You would define custom fields using WordPress’s custom fields feature or a plugin like “ACF (Advanced Custom Fields)” to add additional data to the blog post. In a headless setup, these fields will be exposed via the API.
  1. Title (Text): The title of the blog post.
  2. Content (Text): The main body content of the post.
  3. Author (User): WordPress links posts to authors by default.
  4. Published date (Date): WordPress automatically stores the published date for posts.
  5. Featured Image (Media): This would be stored as a URL or ID in the post metadata for use on the front end.
Set up relationships:
- You can use Advanced Custom Fields (ACF) or custom code to create relationships between content types. For example, you could relate a blog post to categories, tags, or authors. These relationships are accessible via the API to integrate with the front-end application.
Content creation:
- In headless WordPress, you create content in the admin panel just like traditional WordPress. However, the key difference is that the content is now accessed programmatically via APIs instead of being rendered on the WordPress theme directly.
  1. Example entry for a blog post:
    1. Title: “How to use WordPress as a headless CMS”
    2. Content: “In this blog post, we explore how WordPress can function as a headless CMS and how to set it up.”
    3. Author: “Jane Doe”
    4. Published date: “2024-12-30”
    5. Featured Image: [URL of the uploaded image]
Content delivery:
- In a headless setup, WordPress acts purely as the content repository and API provider. Content is retrieved via the WordPress REST API or GraphQL (via a plugin like WPGraphQL). The API allows for flexible querying of posts and fields.
  1. For example, a REST API request like wp-json/wp/v2/posts will return a JSON response with all blog posts, including titles, content, author information, and metadata.
  2. In a front-end framework (like React, Vue, or Angular), you fetch this data to dynamically display blog posts on the website.

WordPress’s strengths when it comes to content creation

Content editor

Gutenberg (WordPress’s default block-based editor) editor allows editors to create visually appealing layouts with drag-and-drop ease.

Rich media support
WordPress handles images, videos, and embeds seamlessly, offering features like bulk uploads, optimization, and third-party integrations.

Workflow features

WordPress provides native support for scheduling posts, version control, and content approvals. Plugins can further enhance these features, enabling collaborative workflows.

Editor usability

WordPress’s intuitive interface ensures that non-technical users can easily manage content, media, and settings. Minimal reliance on developers makes it ideal for small teams or non-technical editors. Even in headless implementations, it’s never as technically intensive as it is with Strapi.

A rich feature set

Even out of the box, WordPress includes tools for SEO, analytics, scheduling, and collaboration, which can be extended via plugins. For Strapi, you’d have to build a lot of these on your own—an analytics plugin, for instance, to bring native analytics to your instance.

Strapi vs WordPress as a CMS: A high-level overview of content creation

Feature	Strapi	WordPress
Primary audience	Developers and technical teams.	Developers, editors, marketers, and non-technical users.
Content modeling	Highly customizable with components and relationships.	Custom Post Types, taxonomies, and ACF for flexible content structures.
Content editor	Basic WYSIWYG and markdown, less intuitive for editors.	Rich block-based Gutenberg editor with drag-and-drop capabilities.
Media management	Basic functionality lacks advanced optimization or bulk editing.	Advanced media tools, bulk uploads, and optimization features.
Workflow features	Limited, requires custom implementation.	Built-in scheduling, approvals, and version control with plugin support.
Ease of use	Developer-heavy setup, editors may struggle with minimal tools.	User-friendly for editors, with minimal reliance on developers for basic tasks.
Rich Features	Requires custom development for SEO, analytics, and collaboration tools.	Built-in tools or plugins for SEO, analytics, and workflow automation.
Updates	Breaking changes can disrupt content workflows.	Updates are stable, ensuring continuity for editors.

When it comes to content creation, WordPress is hands down the winner. Its intuitive interface, vast ecosystem, and flexibility make it the go-to choice for both technical and non-technical users, even in headless setups.