Hybrid Personalization on Edge Delivery Services

Hybrid personalization is emerging as a preferred approach for delivering fast, relevant, and engaging user experiences. It combines the speed of server-side decisions with the flexibility of client-side rendering, making it well suited for modern architectures such as Edge Delivery Services (EDS).

This post explains how to implement a hybrid personalization pattern on EDS using edge compute (for example, Cloudflare Workers) together with Adobe Experience Platform capabilities.

What is Hybrid Personalization?

Hybrid personalization is a two-phase model:

1. Server-side decisioning at the edge
   A personalization decision (such as an offer, experience, or content variant) is retrieved on the server side using the Adobe Experience Platform Edge Network Server API.

   • The call is made at the edge, close to the user.
   • Latency is minimized because the decision happens early in the request lifecycle.

2. Client-side rendering in the browser
   The personalization result is embedded into the response document and applied client-side using a library such as the Adobe Experience Platform Web SDK.

   • The browser can then update content, styles, or layout dynamically.
   • Additional interactions (tracking, events, follow-up calls) are handled after initial load.

This pattern works with solutions such as Adobe Target, Adobe Journey Optimizer, or Offer Decisioning. The main difference between these solutions is the structure and content of the payload returned by the Server API.

Why Use Hybrid Personalization on Edge Delivery Services?

Edge Delivery Services are optimized for speed, cache efficiency, and simplicity. Hybrid personalization aligns well with these goals:

• Server-side decisions at the edge reduce round trips and keep personalization logic close to users.
• Client-side rendering allows for rich dynamic behavior without sacrificing the initial render time.
• The personalization data can be cached alongside the document, reducing flicker and redundant calls.

Using Cloudflare Workers for Hybrid Personalization

In our proof of concept, a Cloudflare Worker acts as an intermediary layer between the user and Edge Delivery Services. Its responsibilities are:

1. Intercept the request

   • The Worker receives the incoming request that would normally go directly to EDS.

2. Call the Edge Network Server API

   • The Worker calls Adobe’s Edge Network using the Server API.
   • It passes the necessary context (for example, identity, page, and environment data) to obtain a personalization decision.

3. Embed the response in the document

   • The personalization payload returned by the Edge Network is injected into the HTML document before it is cached.

   • This might be done via:

     • An inline JSON block (for the Web SDK to read), or
     • Server-side substitution of placeholders in the document.

4. Serve and cache the personalized document

   • The modified document (containing the personalization data) is then passed to Edge Delivery Services and ultimately to the user.
   • Because the document in cache already includes the personalization payload, the Web SDK can apply it immediately in the browser, minimizing flicker or delayed content swaps.

A work-in-progress proof-of-concept implementation of this pattern is available as code in a dedicated repository.

Putting It All Together

By combining:

• Server-side decisions at the edge (via the Edge Network Server API),
• A lightweight edge compute layer (such as Cloudflare Workers), and
• Client-side rendering with the Web SDK,

you can deliver fast, highly personalized experiences on Edge Delivery Services without sacrificing performance. The hybrid approach ensures that critical decisions are made early, while the browser retains the flexibility to render and track user interactions in real time.

If you’d like, I can follow up with a concise, step-by-step “implementation checklist” or a sample Worker + Web SDK integration pattern you can adapt to your own project.

Work in progress code can be found here.