Synchronization Workflows

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

Average rating: 0 No reviews

Outline

At a glance

Architectural Split: Choose between proactive Scheduled Pulls for predictability or reactive Event-Driven Pushes for real-time accuracy.
Batch Efficiency: Use ScheduledJobBase to process deltas, reducing network overhead and API costs for large datasets.
Real-time Response: Implement webhooks with asynchronous background queues to handle immediate updates without blocking the source system.
Operational Safety: Ensure resilience through idempotency and circuit breaking to protect the CMS from external system bursts.

Content federation via a custom IContentProvider or direct database replication requires a robust synchronization strategy. In Optimizely CMS 13, architects must choose between two primary synchronization mindsets: the Scheduled Pull (batch-oriented) and the Event-Driven Push (real-time). Selecting the correct pattern ensures that federated data remains consistent with external sources without over-provisioning system resources or degrading performance.

1. Architectural Analysis: Pull vs. Push

The choice between scheduled and event-driven synchronization is driven by the capabilities of the source system and the requirements for data freshness.

Scheduled Pull (The Batch Mindset)

In this pattern, the CMS acts as the active participant, periodically requesting data from the external source. This is the traditional approach for integrating with systems that do not offer native webhooks or real-time eventing.

Mechanism: Utilizes the ScheduledJobBase in Optimizely to execute logic at a predefined interval (e.g., every 60 minutes).
The Benefit: It provides high predictability for resource consumption. Batching thousands of updates into a single background job reduces the overhead of constant network handshakes and allows for bulk operations in the IContentRepository.
Ideal Use Case: Large product catalogs where prices update once a day, or legacy systems where API calls are expensive and must be minimized.

Event-Driven Push (The Real-Time Mindset)

An event-driven strategy transitions the CMS into a passive participant that waits for notifications (webhooks or service bus messages) from the source system.

Mechanism: An ASP.NET Core Minimal API endpoint or a specialized controller receives a "Push" notification from the external system containing the ID of the updated item.
The Benefit: Synchronization latency is virtually eliminated. This approach is highly efficient for targeted updates, as the CMS only processes records that have actually changed, avoiding the "Full Scan" overhead of scheduled jobs.
Ideal Use Case: Live inventory management, breaking news feeds, or customer-generated content where immediate visibility is a business requirement.

2. Technical Implementation: Scheduled Pull

A scheduled pull implementation typically centers on processing "Deltas." Instead of downloading the full dataset, the job requests records changed since the last successful execution.

[ScheduledPlugIn(DisplayName = "External Content Sync Job", GUID = "8a0e3b0b-2a0d-4b88-f6dc-af8d6acccb7a")]
public class ExternalContentSyncJob : ScheduledJobBase
{
    private readonly IContentRepository _contentRepository;
    private readonly IExternalApiService _apiService;

    public ExternalContentSyncJob(IContentRepository contentRepository, IExternalApiService apiService)
    { 
        _contentRepository = contentRepository;
        _apiService = apiService;
    }

    public override string Execute()
    {
        // Fetch items changed since last execution (e.g., last hour)
        var items = _apiService.GetUpdatedItemsSince(DateTime.UtcNow.AddHours(-1));
        int successCount = 0;

        foreach (var item in items)
        {
            try 
            { 
                SyncItem(item);
                successCount++;
            }
            catch (Exception ex)
            {
                // Detailed logging for individual record failures
            }
        }

        return $"Successfully synchronized {successCount} items.";
    }

    private void SyncItem(ExternalData item)
    {
        // Persistence logic using IContentRepository
    }
}

3. Technical Implementation: Event-Driven Push

Implementing an event-driven workflow requires an endpoint resilient to bursts. Utilizing an asynchronous background queue ensures the source system receives an immediate acknowledgment while the CMS processes the heavy mapping logic.

[ApiController]
[Route("api/webhooks/push")]
public class SyncWebhookController : ControllerBase
{
    private readonly ISyncService _syncService;

    public SyncWebhookController(ISyncService syncService)
    {
        _syncService = syncService;
    }

    [HttpPost]
    public async Task<IActionResult> HandleUpdate([FromBody] WebhookPayload payload)
    {
        if (payload == null || string.IsNullOrEmpty(payload.ExternalId))
        {
            return BadRequest();
        }

        // Fire-and-forget: Return 202 Accepted immediately
        _syncService.QueueUpdate(payload.ExternalId);

        return Accepted();
    }
}

4. Decision Framework: Synchronization Selection

Feature	Scheduled Pull	Event-Driven Push
Data Freshness	Lagging (Interval-based)	Near Real-Time
Complexity	Low (Internal to CMS)	High (Requires Webhooks/API)
System Load	Burst (Occasional spikes)	Smooth (Steady stream)
Error Handling	Easier (Batch logging)	Challenging (Requires Retries)
Source Dependency	Pull-friendly API	Outbound Event Support

5. Operational Resilience and Monitoring

Synchronization workflows must account for data transactional integrity and system stability:

Conflict Resolution: Logic must decide precedence when both local editorial state and external API state change simultaneously.
Idempotency: Processing the same update notification multiple times must result in the same final state to prevent record duplication.
Circuit Breaking: For event-driven setups, rate-limiters protect the database from overwhelming write operations during high-frequency bursts from external systems.

Conclusion

Architecture in Optimizely CMS 13 is a balance between maintaining data integrity and system performance. Scheduled Pull workflows are the standard for predictable, high-volume batch processing. Conversely, Event-Driven workflows are essential for modern digital experiences requiring real-time accuracy. Implementing defensive synchronization logic—focusing on deltas, idempotency, and background processing—enables architects to build resilient federated content hubs that scale with enterprise growth.