PlatformIntegrationsResourcesDocsPricing
ContactLog inSign up
Intro to Composable Architecture
The Modern Enterprise Stack
The Rise of Composable Architecture
Key Parts of a Composable System
Microservices & Serverless Functions
How Microservices Work
Benefits of Microservices
Challenges of Microservices
Serverless Function Providers
The Backend: Databases & Headless CMS
Working with Composable Content
Types of Backend Services
Benefits of Decoupled Content
Common Challenges with Decoupled Content
Choosing the Right Backend Service
The Frontend: Web Frameworks
The New "Frontend"
Site Framework Considerations
Modern Frameworks for Enterprises
Content Editing in Composable Systems
Editing Experience in Monolithic Systems
Headless Editing Experiences
Visual Editing Services
Composable Content
Multi-channel Developer Challenges
Homegrown Content Meshing Solutions
Vendor-based Composable Systems
CI/CD: Building, Deploying, & Hosting
CI/CD for Monolithic Applications
The Build Pipeline
Build & Deployment Services
Common Website Features & Tooling
Authentication
Analytics
Personalization & A/B Testing
Form Submissions
Search
Common Enterprise Challenges
Technology Cost
Security
Traffic & Scalability
Page Speed Performance
Code Complexity
Continuous Integration & Delivery
Getting Started: Migration Strategies
Gradual Migration
Evaluating Tools & Services
Wrapping Up: Is Composable Worth It?

Headless Editing Experiences

Editing Experience in Monolithic SystemsVisual Editing Services
Trust CenterPrivacySecurityGDPR/CCPAAbuse
©2023 Netlify
On This Page
Previewing in prerendered content
Dynamic previews in prerendered contexts
Additional challenges with headless editing

The move to headless content sources presented new challenges to enabling content editors to be effective and productive.

Previewing in prerendered content

Previewing content before publishing became an enormously difficult task in the early days of headless CMS. This is because the frontend projects were typically static site generators that required a build step.

Since the early days of Netlify, we've offered deploy previews — a unique URL provided as the result of a build, which could be triggered from a number of different events. Deploy previews could b used to see content before it was published.

Developers loved this feature! But for editors of large sites, builds could take a long time. With fully static sites at scale, it wasn’t unusual for an editor to save a change in the CMS and wait several minutes just to be able to preview that change.

Dynamic previews in prerendered contexts

This was an obvious problem, as editing efficiency plummeted.

One method some teams used to solve this was to render preview content dynamically. That had its own problems and rarely worked, simply because rendered preview content was then done in a separate context from production content. It was extremely difficult to keep the two in sync, thus degrading the developer experience we’d worked so hard to improve.

Additional challenges with headless editing

While previewing was the biggest challenge with the headless CMS editing experience, there were others:

  • Detached schema: Because visibility and previewing was limited, editors needed an intimate understanding of the content schema to make changes to a page.

  • Deeply-nested content: To provide a flexible editing experience, developers often designed content models in parity with frontend components. This could mean being deeply nested in a structured setting, making it difficult to understand where exactly you were making changes.

  • Omnichannel challenges: One of the advantages of headless CMS was the ability to publish the same content to multiple frontend websites (i.e. omnichannel). For editors, it was powerful and efficient, but risky. They needed to have a deep understanding of the channels to know how a change to a piece of content might affect multiple websites.

Deploy Preview Flow
Deploy Preview Flow