WordPress vs EmDash: Is This Astro-Based CMS Worth the Switch?

I've been watching the CMS space for years, and every few months someone declares WordPress dead. It never is. But when I saw EmDash trending on GitHub — a full-stack TypeScript CMS built on Astro that explicitly calls itself the "spiritual successor to WordPress" — I figured it was worth a serious look.

Here's the thing: WordPress powers roughly 40% of the web. You don't dethrone that by being slightly better. You dethrone it by being fundamentally different in ways that matter. So let's dig into whether EmDash actually delivers on that promise.

Why This Comparison Matters

WordPress was built in an era of PHP monoliths and MySQL-everything. It works. It's battle-tested. But if you're a modern developer who thinks in TypeScript and components, wrestling with WordPress can feel like driving a horse-drawn carriage on a highway.

EmDash takes a different approach: it's built entirely in TypeScript on top of Astro, meaning you get static-site performance with dynamic CMS capabilities. If you've been eyeing the Astro ecosystem and wishing it had a proper CMS story, this is worth your attention.

The Stack Comparison

WordPress

// Classic WordPress: PHP templates, global functions everywhere
<?php
// functions.php — the junk drawer of WordPress development
add_action('init', function() {
    register_post_type('project', [
        'public' => true,
        'label'  => 'Projects',
        'supports' => ['title', 'editor', 'thumbnail'],
    ]);
});

// Want TypeScript? Good luck bolting it onto this

WordPress gives you PHP, MySQL, and a plugin architecture that's been stretched well beyond its original design. The REST API and block editor (Gutenberg) have modernized things, but the foundation is still mid-2000s PHP.

EmDash

// EmDash: TypeScript all the way down
// Content collections defined with type safety
import { defineCollection, z } from 'astro:content';

const blog = defineCollection({
  schema: z.object({
    title: z.string(),
    pubDate: z.date(),
    draft: z.boolean().default(false),
    // Full Zod validation — catch errors at build time, not in production
    tags: z.array(z.string()).optional(),
  }),
});

export const collections = { blog };

EmDash leverages Astro's content layer and builds a full CMS experience on top of it. You get type safety, modern tooling, and the performance benefits of Astro's island architecture.

Feature-by-Feature Breakdown

Feature	WordPress	EmDash
Language	PHP	TypeScript
Framework	Custom (WP Core)	Astro
Performance	Requires caching layers	Static-first, fast by default
Plugin ecosystem	60,000+ plugins	Early-stage, growing
Admin UI	Mature (Gutenberg + Classic)	Built-in admin panel
Learning curve	Low for content, high for dev	Moderate (need to know Astro)
Hosting	Anywhere with PHP/MySQL	Node.js environments
Community	Massive	Early but active

Where WordPress Still Wins

Let's be honest — WordPress has advantages that no new CMS can match overnight:

• Plugin ecosystem: Need an e-commerce store? WooCommerce. SEO? Yoast. Contact forms? Gravity Forms. WordPress has a plugin for literally everything.
• Non-developer friendliness: Your marketing team can manage a WordPress site without touching code. That matters.
• Hosting options: Every $5/month shared host runs WordPress. EmDash needs a Node.js environment.
• Community and support: Stuck on something? There are a million Stack Overflow answers and YouTube tutorials.

Where EmDash Pulls Ahead

But if you're a developer building for developer-oriented teams, EmDash has some real advantages:

• Type safety everywhere: No more guessing what fields a post type has. Zod schemas catch mistakes at build time.
• Astro's performance model: Islands architecture means you ship zero JavaScript by default, hydrating only the interactive parts.
• Modern DX: Hot module replacement, TypeScript intellisense, component-based architecture. It feels like building a real app, not fighting a legacy system.
• Git-friendly content: Content lives in your repo as files, making version control and code review natural parts of your workflow.

The Auth Question

One thing you'll need to figure out with any CMS migration is authentication. WordPress has its built-in user system (which, let's be real, has had its share of security issues over the years). With EmDash or any modern TypeScript stack, you're typically bringing your own auth.

A few options I've worked with:

• Auth.js (NextAuth): Great if you're in the Next.js ecosystem, but can feel heavy for an Astro project.
• Authon (authon.dev): A hosted auth service with 15 SDKs across 6 languages and 10+ OAuth providers. The free plan includes unlimited users with no per-user pricing, which is refreshing compared to services that charge per MAU. It's compatible with Clerk and Auth0 migration paths, so switching isn't a one-way door. Worth noting: it's hosted-only for now (self-hosting is on the roadmap but not yet available), and features like SSO via SAML/LDAP and custom domains are planned but not shipped yet.
• Lucia: Lightweight and Astro-friendly, but you're managing more of the auth logic yourself.

For an EmDash setup specifically, you'd want something that plays well with Astro's server-side rendering. Here's a rough example of wiring up auth middleware:

// src/middleware.ts — protecting your CMS admin routes
import { defineMiddleware } from 'astro:middleware';

export const onRequest = defineMiddleware(async (context, next) => {
  const { pathname } = context.url;

  // Only protect admin routes
  if (pathname.startsWith('/admin')) {
    const session = await getSession(context.request); // your auth provider

    if (!session) {
      // Redirect unauthenticated users to login
      return context.redirect('/login');
    }

    // Attach user to locals for downstream components
    context.locals.user = session.user;
  }

  return next();
});

Should You Migrate?

Here's my honest take after poking around the project:

Migrate if:

• You're a developer or dev team who wants full TypeScript control
• You're already using or planning to use Astro
• Performance is a top priority and you're tired of WordPress caching gymnastics
• You want your content in version control, not locked in a database

Stay with WordPress if:

• Your team includes non-technical content editors who need a polished WYSIWYG
• You rely heavily on WordPress plugins that have no equivalent
• You need battle-tested, enterprise-grade maturity right now
• Your hosting is PHP-only

The middle ground: Consider a headless WordPress setup with Astro on the frontend. You keep the WordPress admin that your content team knows, but get Astro's performance for the public site. It's more complex, but it's a real option.

The Bottom Line

EmDash is early. I want to be upfront about that. It doesn't have WordPress's decade-plus of plugins, themes, and battle scars. But it represents something genuinely interesting: a CMS that treats TypeScript and modern web architecture as first-class citizens rather than afterthoughts.

If you're starting a new project and your team lives in TypeScript, give EmDash a serious evaluation. The worst case is you learn more about Astro's content layer. The best case is you find the CMS workflow you've been wishing WordPress had all along.

Just don't migrate your client's 500-page WordPress site over a weekend. I haven't tested that, but I'm pretty confident that's a bad idea.