Content editors are the unsung heroes of the digital experience. They keep the messaging up-to-date, respond to real-time changes, and ensure that your website remains relevant. But here's the truth: most websites are still too hard to edit.
And that’s a problem we—designers, developers, and strategists—need to solve.
The Problem: Clunky CMS Interfaces and Lost Opportunities
Let me paint a familiar picture.
Imagine managing a website for a small business, higher ed institution, or nonprofit. Say your small business is a gym and it’s a holiday—your hours of operation change. You know the update should go right on the homepage, but instead, someone posts it to Instagram.
Why?
Because it's easier. The CMS is too clunky. Updating the actual site feels like a chore.
Now scale that to a university with hundreds of editors and thousands of pages. If even a local gym can’t easily update their own website, how can we expect large teams to navigate overly complex CMSs?
We Need to Design For Editors, Not Just End-Users
Content editors are users too yet they’re often left out of the design and build process.
We obsess over the front-end UX while the admin interface—the actual editing experience—gets overlooked. It’s time for a shift in mindset: editing interfaces should be usable, flexible, and empowering.
Modern page builders like WordPress’s block editor (Gutenberg) and Drupal’s upcoming Experience Builder are rapidly evolving.They offer visual, drag-and-drop interfaces that bring content editing closer to what we see on the front end.
But there’s a catch…
Modern Tools Are Only as Good as Their Implementation
While page builders unlock powerful features, they can also introduce too much flexibility.
Dozens of block types, unlimited colour choices, and fine-grained layout controls might appeal to designers—but they often overwhelm editors.
Faced with 40 block types, an editor may not choose the best one for the job.
The solution isn’t to remove features, but to implement intentional defaults and smart guardrails that simplify choices and support consistency.
To Support Editors, Do the Following:
1. Use Clear Field Labels and Help Text
- Why: Content editors may not be technical. Clear labels reduce confusion.
- Best Practice: Replace vague labels like Body with Main Content or Article Body, and add descriptions like “This is the main section of your page.”
2. Organize Fields Logically
- Why: A well-organized content-entry form improves usability and reduces cognitive load.
- Best Practice: Group fields in logical sections (e.g., SEO, Header, Content, Sidebar) using fieldsets or tabs. Keep this structure consistent across content types.
3. Provide Flexible Yet Structured Components
- Why: Editors need creative freedom without sacrificing consistency using tools like Drupal Paragraphs, Layout Builder, or WordPress custom blocks—rather than relying solely on WYSIWYGs. This approach gives editors options to assemble pages in creative ways while maintaining visual consistency.
- Best Practice: Instead of relying solely on WYSIWYG fields for full-page content, provide a library of reusable, pre-designed components using tools like Drupal Paragraphs or Layout Builder, or WordPress custom blocks. This approach gives editors options to assemble pages in creative ways while maintaining visual consistency.
4. Set Reasonable Default Values
- Why: Editors juggling multiple tasks benefit from smart defaults. When the CMS provides helpful starting points, editors can focus on crafting meaningful content rather than wrestling with layout or metadata choices.
- Best Practice: Auto-fill fields like meta descriptions or Open Graph tags based on content. Default layouts and image sizes help editors focus on content, not formatting.
5. Create Granular User Roles and Permissions
- Why: Editors will be confused if they have access to advanced configuration settings that they don’t have the training to update. Editors should only see what they need—no more, no less.
- Best Practice: Limit access to advanced features with role-based permissions aligned to staff responsibilities.
6. Make Media Management Easy
Why: Efficient access to quality, on-brand assets speeds up publishing.
Best Practice: Use a media library with previews, drag-and-drop, and asset categories for easy re-use.
7. Build with Accessibility in Mind
Why: Accessibility isn’t just a legal requirement—it’s a key aspect of good user experience. Yet for many content editors, it can be difficult to know whether what they’re creating is truly accessible. That’s where the CMS can provide much-needed guidance.
Best Practice: Use accessible components by default and build guardrails into the editorial interface to help prevent common accessibility issues.
For example, instead of allowing editors to choose arbitrary colours—which can result in poor contrast—offer a curated colour palette that aligns with brand guidelines and meets contrast requirements. Incorporate a tool like Editoria11y in Drupal or Editoria11y Accessibility Checker in WordPress that allows content editors to do a quick check of accessibility before publishing content.
8. Train Your Content Teams and Provide Content-Entry Guides
Why: Even the most intuitive CMS can be overwhelming for new or occasional users. Without training, content teams may struggle to understand editorial workflows, component use, or accessibility best practices which can lead to inconsistent content, errors, or underused features.
Best Practice: Provide clear onboarding and content-entry guide. If internal training feels too difficult to manage, talk to us about training your content team to get tailored support and resources.
Too Much Freedom? Giving editors access to unrestricted colour palettes can lead to inconsistent branding and inaccessible content.
Avoid These These Mistakes
1. Don’t Use Technical Jargon
Why: Editors may not understand terms like Node, Taxonomy, or View Mode.
Best Practice: Use plain language labels and admin interfaces (e.g., “News Article” instead of “Node Type: Article”).
2. Don’t Overload the Edit Screen
Why: Too many options causes decision fatigue.
Best Practice: Use conditional fields, collapsible sections, and permissions to simplify the experience.
3. Don’t Hardcode Layouts or Lock Editors Out
Why: Editors often need to update layouts over time.
Best Practice: Provide structured layout tools (like Layout Builder with guardrails), instead of rigid templates, so that content can evolve.
4. Don’t Ignore Performance for Admin Users
Why: Speed is often the single most important factor in delivering a good user experience—especially for content editors working in the backend every day. When editing screens are slow to load or unresponsive, it leads to frustration, interruptions in workflow, and more room for error.
Best Practice: Apply performance best practices to the administrative interface, which could mean changing form settings to reduce the complexity, and selecting page-building tools that load quickly.
Emerging tools like Drupal’s Experience Builder offer a glimpse into what a high-performance admin experience can look like. Its React-based architecture will enable near-instant updates for editors.
5. Don’t Skip Content Previews
Why: Editors want to know what their content will look like before publishing.
Best Practice: Enable preview modes, ideally with live preview built in, that render content as it will appear on the site. Bonus points for adding a mobile preview.
6. Don’t Neglect Help Text and Documentation
Why: Content editors don’t want to hunt around for links to documentation. They want to be able to get help for the specific task they’re working on.
Best Practice: Add inline help text, links to documentation, or tooltips where possible, to reduce the friction for getting help.
Curating the Editor Experience: Reducing clutter in the block editing interface helps content creators focus on what matters—content, not configuration.
Who Owns the Editor Experience?
That’s a tricky question.
- Developers think in terms of schemas and data models.
- Designers empathize with end users, but are often disconnected from CMS workflows.
- Project managers advocate for client needs, but may not possess full technical insight.
What’s often missing is shared ownership of the content editor experience. Creating a usable backend shouldn’t fall solely to developers or be an afterthought. Instead, we need intentional conversations across roles—designers, developers, strategists, and editors—to prioritize editorial usability from the earliest stages of discovery through to implementation.
In most projects, the CMS backend isn’t explicitly designed. It emerges by default—from how Drupal, WordPress, or similar platforms render interfaces based on content types, fields, and configurations. The result is often a functional but fragmented editing experience. But the backend deserves the same thoughtful design as the front-end—and that means approaching it with intent, not just accepting what the CMS gives us out of the box.
Practical Steps for Each Role
Here’s how each team member can contribute:
Developers
- Embrace modern editing frameworks. Platforms like WordPress’s block editor or Drupal’s Experience Builder (soon to be released) are built with React to support visual editing. Embracing these tools—rather than older, field-heavy methods—can make editing feel more intuitive and less technical.
- Simplify the interface. Default page building tools often offer too many blocks, options, and settings. Reduce clutter by removing unused blocks, hiding advanced controls, and setting defaults for fonts, colours, and layouts. This lets editors focus on content instead of configuration.
- Avoid overcomplicated field systems. When editors need layout flexibility, field-based solutions can be limiting and confusing—kind of like using spreadsheets to design a webpage. Instead, offer structured components that support visual editing but still preserve consistency and accessibility. For WordPress, tools like the Block Binding API, or the Meta Field Block plugin, can help render our beloved structured data in a much more editor-friendly way.
Designers
- Perform user testing with content editors on the editor interface. Testing with content editors is essential to truly understand how to improve their experience
- Design with this flexible backend in mind.This requires designers to get familiar with the back-end. Typically, “components” can be placed anywhere on a page, next to any other component. Designers can play a role in giving guidance around how to combine components in a way that creates a good visual balance and a good UX flow.
- Prioritize consistency in styling defaults. Establish rules for spacing, font sizes, and colour palettes that carry through to the editor experience. This reduces cognitive load for editors and prevents design drift.
- Create an editorial style guide or content templates. These can help non-designers replicate good layout and visual hierarchy by using predefined combinations of components.
Content Editors
- Provide feedback during demos—especially on the admin UI. No one knows the job better, so that insight is incredibly valuable. Doing a test run of daily tasks can help surface any gaps and ensure the right tools are in place.
- Advocate for brand and accessibility compliance. Ask for sensible options for colours or text sizing so to be able to create branded, accessible content more easily.
- Request training resources and backend walkthroughs. Think about which formats would be most helpful—whether that’s guides, videos, or live training sessions—to support everyday workflows.
Why It Matters
Websites are strategic investments—often meant to last 5–7 years. A poor editing experience erodes that value.. Editors avoid using a CMS that’s hard to use, content gets outdated, and the site gradually deteriorates.
On the flip side, when content editors are empowered, they:
- Keep the site fresh and relevant
- Create accessible content
- Communicate more effectively with audiences
Improving editor UX saves time, reduces support requests, and supports compliance. Better editing tools don’t just help editors—they help the entire organization.
Looking Ahead
Embracing Experience Builder and Beyond
As tools like Drupal’s Experience Builder and WordPress’s block editor (Gutenberg) continue to mature, they’re reshaping how we think about backend design. These systems have the potential to make publishing more accessible. Built on modern React-based frameworks, these systems move away from rigid, form-based interfaces toward dynamic, visual editing environments that more closely mirror the frontend experience.
Visual, drag-and-drop tools reduce barriers for non-technical users and unlock creative autonomy. But flexibility without strategy can quickly lead to clutter and inconsistency.
To truly improve the editor experience, we need to curate the interface, set smart defaults, and collaborate across roles—bringing developers, designers, and editors into alignment from the start. These systems offer real opportunities to democratize publishing but only if we treat backend usability as a core part of the design process.
Join the Conversation
Want to explore this topic further? Join me for a free webinar on May 9 at 12 PM EST, where he'll dive deeper into building better content editing experiences.
Sign up for the webinar!
+ more awesome articles by Evolving Web