WordPress stores content as HTML blobs in a MySQL table. EmDash stores content as structured JSON called portable text. That single difference changes everything about how you query, reshape, and distribute your content.
EmDash’s GraphQL API lets you request exactly the fields you need — nothing more, nothing less — from any content type, any relationship, any depth. No over-fetching, no under-fetching, no parsing HTML to extract data that should have been separate in the first place. For agencies building headless front ends, for developers piping content into mobile apps, and increasingly for AI agents that need machine-readable content, this architecture is not just better. It is the only approach that scales.
That is not a minor ergonomic improvement. It is a fundamental shift in how content flows through a system.
The Query Problem WordPress Never Solved
WordPress’s REST API returns fixed responses. Hit /wp-json/wp/v2/posts/42codecodecodecode and you get a 40-field JSON blob. Title, date, author, featured media, content rendered as HTML, excerpt rendered as HTML, meta fields dumped into a flat array. You wanted the post title and a custom field called pricecodecodecodecode. You still download the entire object. Then you parse the HTML in content.renderedcodecodecodecode to find anything embedded inside a block.
That is not a query. That is a firehose.
EmDash flips this. Its GraphQL API treats every field as a first-class citizen. The portable text format means rich content — headings, images, embeds, block quotes — lives as structured JSON nodes, not as HTML strings. A GraphQL query like this becomes possible:
“`
query {
post(id: “42”) {
title
featuredImage { url alt }
content {
… on HeadingBlock { text level }
… on ImageBlock { caption }
}
customFields { price }
}
}
“`
No over-fetching. No HTML parsing. The API returns exactly the shape you asked for. That is not a minor ergonomic improvement. It is a fundamental shift in how content flows through a system.
What Makes EmDash’s GraphQL Implementation Different
EmDash did not bolt GraphQL onto an existing relational schema. The CMS was built from scratch in TypeScript on Astro, with content types that are flexible by design — not the fixed postscodecodecodecode and pagescodecodecodecode of WordPress. Every content type you create — projects, staff, offices, products — automatically generates its own GraphQL schema. No plugins, no custom endpoint configuration, no code generation step.
The built-in MCP server extends this further. An AI agent connected via the Model Context Protocol can query your entire content graph through the same GraphQL layer. The agent does not need to know your database structure. It does not need to write SQL. It asks for content by type and field, and the API returns structured JSON. This is why Yoast de Valk called EmDash the most interesting thing to happen to content management in years — not because of the admin UI, but because the content layer is finally machine-readable by default.
The Permission Model Matters Here
Every API token in EmDash carries granular scopes. content:readcodecodecodecode, content:writecodecodecodecode, media:readcodecodecodecode. A plugin that only needs to read published posts cannot access drafts. An AI agent that generates reports from your content cannot delete it. The GraphQL API enforces these boundaries at the query level. WordPress offers no equivalent. Its REST API either authenticates you fully or not at all.
The Defensible Position
Here is the claim worth defending: EmDash’s GraphQL API is not just a feature — it is the architectural foundation that makes every other claim about the CMS credible. The sandboxed plugins matter for security. The serverless scaling matters for cost. But the GraphQL layer is what makes the CMS future-proof. Because content that lives as structured JSON, queryable through a typed API, can feed any front end — web, mobile, email, AI agent — without translation layers, without scraping, without workarounds.
WordPress content is trapped in HTML. Every headless WordPress project confirms this: you install WPGraphQL, you map custom fields manually, you write resolver functions for data that should already be separate. EmDash starts with separation built in. The portable text format, the auto-generated schemas, the MCP server — these are not afterthoughts. They are the product.
The One Counterargument That Matters
The strongest objection is practical: GraphQL adds complexity for simple use cases. A blogger who wants to display their latest three posts on a homepage does not need a typed schema. They need get_posts('numberposts=3')codecodecodecode. WordPress gives them that in one line of PHP. EmDash requires understanding queries, fragments, and the concept of resolving nested types. For a solo site owner who just wants content on a page, that is real friction.
This objection is valid for a specific user. But it misunderstands who EmDash targets.
The CMS is version 0.1.0. It ships with starter templates — blog, marketing site, portfolio — that handle the common query patterns already. The default theme calls the GraphQL API internally. The solo site owner never writes a query. They edit content in the admin UI, and the theme renders it. The complexity lives in the infrastructure layer, not the user layer.
For the developer or agency building custom front ends, GraphQL’s learning curve pays for itself on the second project. The first project teaches you the schema. The second project reuses it. The third project discovers that every content type you ever create generates its own typed API automatically. Compare that to WordPress, where every custom post type and every ACF field group requires manual REST API exposure, manual endpoint registration, and often a plugin just to make the data accessible.
The friction argument assumes the user writes GraphQL by hand. In practice, EmDash’s built-in MCP server means AI agents write those queries. The developer describes what they need — “show me all projects from 2024 with their client names and featured images” — and the agent generates the query. The human never touches the syntax.
What This Enables That WordPress Cannot Match
Multi-source rendering. A single post in EmDash can render as a web page, an email newsletter, a mobile app card, and an AI training document — all from the same GraphQL query, all from the same structured content source. WordPress would require separate templates, separate plugins, and separate API endpoints for each output.
Real-time preview without duplication. The GraphQL API serves draft content when the requesting user has permission. A developer building a live preview in Astro can query the draft state of any post, render it with the same components that serve the published page, and see changes instantly. No separate preview endpoint, no iframe hacks.
Agent-driven content operations. Because the GraphQL API is typed and self-documenting, an AI agent can discover the schema, understand the relationships between content types, and perform bulk operations — “find all posts where the SEO title is missing and generate one using the post title as a base” — without a human writing a single line of code. WordPress plugins that attempt this must parse HTML, guess field locations, and handle dozens of edge cases.
The Named Tool You Should Know
The @astrojs/mdashcodecodecodecode integration package, available through the Astro CLI, connects any Astro front end to an EmDash instance in under sixty seconds. It auto-generates TypeScript types from your GraphQL schema, so your editor autocompletes field names and catches mismatches at build time. No other CMS in the same weight class offers that level of developer ergonomics out of the box.
The Cost of Staying with REST
WordPress will not abandon its REST API. Too many plugins and themes depend on it. But the REST model creates a ceiling. Every site that needs more than basic post/page retrieval hits the same wall: over-fetching, manual field mapping, and custom endpoints that rot when the schema changes. Agencies spend billable hours maintaining these workarounds. EmDash eliminates them at the architectural level.
The migration tool that imports WordPress content into EmDash does not just move posts and pages. It converts HTML content into portable text. That conversion is the hard part. Once the content lives as structured JSON, the GraphQL API unlocks every downstream benefit automatically. The migration is painful because it is transformative. But the transformation is the point.
When GraphQL Is Overkill
There is one scenario where EmDash’s GraphQL API adds weight without value: a static marketing site with five pages, no blog, no dynamic content, and no plans to grow. For that use case, plain Markdown files in a Git repository generate a faster, simpler, cheaper site. EmDash, like any CMS, introduces infrastructure that a five-page site does not need.
But that scenario is not where WordPress dominates. WordPress powers 43% of the web. Most of those sites have blogs, have custom post types, have forms, have SEO requirements, have users who need an admin panel. For those sites, the GraphQL API is not overhead. It is the shortest path to a modern, decoupled architecture that can outgrow WordPress without replacing everything.
- What makes EmDash's GraphQL API different from WordPress's REST API?EmDash's GraphQL API returns only the requested fields from structured JSON content, while WordPress's REST API returns fixed, over-fetched HTML blobs.
- How does EmDash handle content types for GraphQL?Every content type you create in EmDash automatically generates its own GraphQL schema, with no plugins or custom endpoint configuration needed.
