Optimizely Graph

By Optimizely Education
Published: Mar 6, 2026
Rating 1 star 2 stars 3 stars 4 stars 5 stars

Average rating: 0 No reviews

Outline

At a glance

Default delivery layer: Optimizely Graph is the primary indexing and delivery path in CMS 13.
Push-based model: Content changes trigger synchronization events instead of runtime SQL queries.
Developer control: Developers influence indexing using attributes like [GraphProperty].
GraphQL delivery: Frontend applications consume content through the Graph endpoint.
Operational hooks: Webhooks enable cache invalidation and real-time updates.

Overview

In the Optimizely CMS 13 (PaaS) architecture, Optimizely Graph has moved from an optional search integration to the central backbone of the content delivery lifecycle. Earlier versions relied on local database queries or Search & Navigation, but CMS 13 routes the primary read-path for high-scale, cross-channel experiences through a global, cloud-native GraphQL gateway.

For developers, this represents a shift from traditional server-side loading toward a synchronization and query mindset. Instead of retrieving content directly from SQL at request time, the system keeps a cloud index in sync and serves delivery traffic from that index.

1. The Architectural Pivot: Push-Based Synchronization

Traditional CMS retrieval followed a pull model, where the application queried the SQL database at runtime. CMS 13 introduces an event-driven push model. Each content action triggers synchronization so the delivery layer always works with indexed data.

The Indexing Flow in DXP

Lifecycle observation The Optimizely.Graph.Cms package listens to the content event system such as PublishedContent and SavedContent.
Serialization gateway Content objects are converted into optimized JSON payloads. Developers can extend serialization to include calculated fields or related metadata.
Encrypted transport Data is pushed through a secure HTTPS connection to the Optimizely Graph gateway.
Instant cloud indexing The gateway indexes content in parallel, making it globally available to GraphQL queries within milliseconds.

This separation ensures that authoring load and visitor load are decoupled, improving stability during traffic spikes.

2. Developer Control: Customizing the Graph Schema

Although CMS 13 remains a code-first platform, developers still have fine-grained control over how properties are indexed. Proper indexing prevents unnecessary payload size and keeps GraphQL queries efficient.

Strategic Indexing Modes

Using the [GraphProperty] attribute, you can control how each field is indexed.

public class StandardNewsPage : BasePageData
{
    [GraphProperty(PropertyIndexingMode.Searchable)]
    public virtual string ArticleHeadline { get; set; }

    [GraphProperty(PropertyIndexingMode.Filterable)]
    public virtual string CategoryTag { get; set; }

    [GraphProperty(PropertyIndexingMode.OutputOnly)]
    public virtual XhtmlString ComplexLayoutBody { get; set; }
}
    

Correct indexing improves query performance, lowers payload size, and helps keep Graph complexity within quota limits.

3. The GraphQL Pattern: Consuming Content at the Edge

CMS 13 delivery typically happens through the GraphQL endpoint. This allows frontend applications to be built independently of the CMS runtime.

Advanced Querying with Fragments

GraphQL fragments help keep query structures reusable across applications.

query GetPromotedContent {
  LandingPage {
    items {
      ...MetadataFields
      CallToAction {
        Text
        Link
      }
    }
  }
}

fragment MetadataFields on LandingPage {
  MetaTitle
  MetaDescription
  ContentLink {
    Guid
  }
}
    

4. Operational Extensibility: Webhooks and Cache Invalidation

In a decoupled architecture, the frontend needs a signal when content changes. The webhook service allows Graph to notify external systems when synchronization completes.

A common pattern is to send a secure POST request to a frontend revalidation endpoint so cached pages can be refreshed without polling.

Why this matters

Without webhook-driven cache invalidation, decoupled frontends either become stale or require expensive polling. Proper webhook integration allows sites to remain both fast and fresh.

Conclusion

Moving to Optimizely Graph as the default delivery layer is the defining architectural change in CMS 13. Instead of runtime database queries, content is synchronized to a global index and delivered through GraphQL. Developers must manage indexing behavior, schema design, and query efficiency to keep the system fast and scalable.

Mastering Graph synchronization, property indexing, and query design ensures that content delivery is not limited to the CMS runtime, but becomes a high-performance distribution layer for web, mobile, and multi-channel experiences.