--- title: Matrix vs. CKEditor in Craft CMS — When to Use Which date: 2025-10-06T15:07:00+02:00 author: admin canonical_url: "https://craft-kit.dev/blog/matrix-vs.-ckeditor-in-craft-cms-when-to-use-which" section: Blog --- One of the most common questions when starting a new Craft CMS project: should I build this with Matrix blocks or CKEditor components? Both are powerful. Both are editor-friendly. But they serve fundamentally different purposes — and choosing the wrong one creates friction for editors and developers alike. Here's how I make the decision on every project. ## The Short Answer **Matrix** — for landing pages, flexible layouts, and structured page building. **CKEditor** — for long-form articles, editorial content, and document-style pages. ## When I Use Matrix Matrix is my go-to whenever the page itself *is* the product. Landing pages, campaign pages, homepages, service pages — content that needs to be composed visually, block by block, with precise control over layout and presentation. The reason is simple: Matrix gives you a structured, predictable content model. Each block is a defined entry type with its own fields, its own template, and its own layout rules. You can build a proper grid system around it — full-width sections, content columns, popout elements, feature rows — and the editor always knows exactly what they're building. On my projects I use a layout grid with defined width zones: *full*, *content*, *feature*, and *popout*. Every Matrix block slots into this grid cleanly. The result is a page builder that's flexible enough for designers, controlled enough for developers, and simple enough for editors. You can see this in action in the [Craft Kit Matrix Builder demo](https://craft-kit.dev/matrix-builder). **Use Matrix when:** - The page is composed of distinct visual sections - Layout control matters — different blocks need different widths or spacing - Content is highly structured and unlikely to flow as prose - You need clean, maintainable templates per block type - Multiple stakeholders touch the same page ## When I Use CKEditor CKEditor is my go-to for content that *reads*. Long articles, blog posts, documentation, case studies, news — anything where the editor is writing, not designing. CKEditor keeps editors in a focused writing environment. The content flows as prose, and you can enrich it with structured components — cards, quotes, galleries, buttons, callouts — inserted inline without breaking the writing flow. These components are defined once as CKEditor entries and reused across the entire site. The key advantage: editors don't have to think about layout. They write, they insert a component where it makes sense, and the template handles the rest. It's a much faster and more natural workflow for editorial teams. You can see this in action in the [Craft Kit CKEditor Builder demo](https://craft-kit.dev/cke-builder). **Use CKEditor when:** - The content is primarily long-form text - Editors need a focused, distraction-free writing experience - Components need to be embedded inline within flowing content - The page structure is consistent and doesn't vary section by section - Content is authored frequently by non-technical editors ## Can You Use Both? Yes — and on many projects I do. A typical setup: the page uses Matrix for the main structural sections (hero, feature blocks, CTA), and one of those Matrix blocks contains a CKEditor field for the long-form body content. You get the layout control of Matrix with the editorial freedom of CKEditor, exactly where each one makes sense. ## One Block, Two Contexts What makes this approach especially powerful in practice: a well-structured block component can work in both Matrix *and* CKEditor — without duplicating template code. The idea is straightforward. Each block template checks the context it's being rendered in — Matrix builder or CKEditor field — and adjusts its wrapper, layout classes, and structure accordingly. The block content itself stays identical. When rendered as a Matrix block, the component gets a *<section>* wrapper with layout grid classes. When rendered inside CKEditor, it gets a lightweight *<div>* wrapper that opts out of prose typography styles. Two completely different layout contexts — same component logic underneath. This pattern keeps your codebase DRY, makes components reusable across page types, and means you only ever maintain one version of each block. Build it once, use it everywhere — in a landing page builder and inside a long-form article at the same time. If you want to see exactly how this is implemented, the base templates for both contexts are available in the Craft Kit repository: 👉 [partials on GitHub](https://github.com/handplant/craftcms-lazy-starter-kit/tree/main/templates/_partials) ## The Rule of Thumb > **If the editor is designing a page — use Matrix. If the editor is writing a document — use CKEditor.** It's not about which tool is more powerful. It's about which one fits the mental model of the person using it. Get that right, and both editors and developers will thank you. **Want to see both in action?** The Craft Kit demos show real implementations of both approaches — built with Craft CMS 5, fully server-rendered, and ready to explore or fork. - [Matrix Builder Demo](https://craft-kit.dev/matrix-builder) - [CKEditor Builder Demo](https://craft-kit.dev/cke-builder) - [GitHub](https://github.com/handplant/craftcms-lazy-starter-kit) --- **This article is based on how I structure real Craft CMS projects for agencies.** I'm Andi Grether, a freelance Craft CMS developer specializing in clean, maintainable architectures — with a focus on hypermedia-first approaches using Datastar and Twig. If you're building a Craft CMS project and want a reliable technical partner, feel free to reach out — [webworker.me](https://webworker.me)