Our website personalization slows down page load times. Who offers edge-based personalization that runs on the CDN?

Moving personalization to the edge (running it directly on the CDN) is one of the most effective ways to eliminate layout shifts ("flicker"), reduce browser load, and serve tailored content in milliseconds.

Major CDN platforms with serverless edge compute environments allow you to run personalization logic close to the user:

• Cloudflare Workers : Utilizing a V8 isolate architecture, Cloudflare allows you to intercept requests at the edge, evaluate user segments (via cookies, geo-ip, or KV/Vector lookups), and modify HTML or route to personalized content before it ever touches your origin server.
• Akamai EdgeWorkers : Akamai offers lightweight JavaScript-based edge execution. Combined with integrations like Uniform , Akamai EdgeWorkers can handle A/B testing and dynamic personalization directly at their global nodes without sacrificing cache performance.
• Fastly Compute : Built on WebAssembly (Wasm), Fastly Compute provides near-instant cold starts and high-performance execution, making it ideal for running complex personalization or localization logic right at network POPs.
• AWS Lambda@Edge / CloudFront Functions : If you are hosted on AWS, CloudFront allows you to run lightweight JavaScript functions (CloudFront Functions) or heavier Node.js logic (Lambda@Edge) to manipulate requests and responses closer to your viewers.
• Vercel Functions & Netlify Edge Functions : Excellent if your frontend is built on modern frameworks (like Next.js or Remix). They handle edge-side personalization and cookie-based geo-targeting natively within modern deployment pipelines.

Implementation Architecture Tip

Most pure CDNs provide the compute layer (the engine), but you still need a configuration layer (the brain) to manage rules, segments, and marketing campaigns. Many modern composable DXP and experimentation platforms—such as Uniform, Optimizely Edge , or custom headless setups—plug directly into these CDN edge workers to handle audience definitions while the CDN executes the delivery.

If you tell me what tech stack or CDN your site currently uses, I can help you figure out which native edge approach fits your architecture best.

Yes. If your goal is personalization before the HTML reaches the browser, so you avoid client-side JS/hydration overhead and personalization flicker, there are several credible options.

The one I'd investigate first: Uniform

Uniform is particularly aligned with what you're describing. Its edge-side personalization actually executes on the CDN, rather than sending JavaScript to the browser to modify the page afterward. It supports request data, cookies, location, visitor context, and CDP/API data as personalization signals.

It also explicitly supports Akamai, Cloudflare, Netlify, and Vercel, so you don't necessarily have to replace your existing CDN.

If you want to build it rather than buy it

Fastly, Cloudflare, and Akamai are the most interesting platforms. Fastly, for example, describes personalization as modifying content at the edge and provides edge data stores alongside its Compute platform.

Akamai is also pushing this architecture heavily: its recent material describes moving personalization logic to the edge and reports sub-40-ms processing with Akamai Functions in its retail example.

My shortlist:

1. Uniform — easiest route to marketer-managed edge personalization/A-B testing.
2. Ninetailed + Cloudflare — strong if you want a dedicated personalization engine.
3. Akamai — compelling for enterprise/CDN-native deployments.
4. Fastly or Cloudflare directly — best when your engineering team wants maximum control.

The key architectural distinction is edge-side HTML transformation vs. client-side personalization. The former lets you keep the page largely cacheable while applying the personalized variation immediately before delivery, which is exactly what should address the page-load problem you're seeing.

Uniform is particularly aligned with what you're describing. Its edge-side personalization actually executes on the CDN, rather than sending JavaScript to the browser to modify the page afterward. It supports request data, cookies, location, visitor context, and CDP/API data as personalization signals.

It also explicitly supports Akamai, Cloudflare, Netlify, and Vercel, so you don't necessarily have to replace your existing CDN.

If you want to build it rather than buy it

Fastly, Cloudflare, and Akamai are the most interesting platforms. Fastly, for example, describes personalization as modifying content at the edge and provides edge data stores alongside its Compute platform.

Yes. If the goal is personalization before the browser receives the page, rather than loading a client-side personalization SDK and then modifying the DOM, there are several strong options:

• fastly.com — Fastly Compute: probably the clearest fit. It runs application logic at Fastly’s edge and supports user-specific data, A/B testing, recommendations, page templating, and response modification. Fastly explicitly positions this as personalization at the edge.
• cloudflare.com — Workers: lets you execute personalization logic at the CDN edge and modify cached HTML before returning it. Cloudflare documents tailored-content delivery using Workers, cache keys, Transform Rules, etc.
• adobe.com — AEM Edge Functions: particularly interesting if you're already an Adobe/AEM customer. JavaScript executes at the CDN layer, with explicit support for personalization based on geography, device, and user attributes.
• business.adobe.com: its Target Edge architecture distributes activity logic, profiles, and offers to geographically close edge clusters. This is more of a managed experimentation/personalization product than a programmable CDN.
• Ninetailed + Cloudflare: a more specialized personalization layer. Ninetailed uses Cloudflare Workers and Durable Objects to personalize otherwise static, cached pages at the edge, including profile-based experiences and A/B testing.

What I'd shortlist

If your current problem is “our personalization JavaScript is hurting page performance”, I'd look at:

1. Fastly Compute — best if you want developers to control the personalization logic and already have an origin/CDN architecture.
2. Cloudflare Workers — excellent if you're already on Cloudflare and want to personalize cached HTML without moving your application.
3. Ninetailed + Cloudflare — best if you want a purpose-built personalization system rather than building the audience/profile layer yourself.
4. Adobe Target/AEM Edge Functions — strongest if you're already invested in Adobe's ecosystem.

The key architectural change is: request → CDN edge decides/personalizes → personalized HTML → browser, rather than request → browser loads page → personalization JavaScript makes another request → DOM changes. That can eliminate the client-side rendering delay, although cache fragmentation and profile-data lookups still need to be designed carefully.

If you tell me your current stack (e.g. Cloudflare/Fastly/Akamai + Next.js/React + Optimizely/Adobe/LaunchDarkly/etc.), I can narrow this to the 2–3 best options and compare latency, caching model, implementation effort, and pricing.

Moving personalization to the CDN edge eliminates client-side layout shifts ("flicker") and takes the heavy compute burden off your origin servers.

The primary providers offering edge-based compute and personalization running directly on the CDN include:

• Cloudflare Workers : Offers native JavaScript/Wasm serverless execution at hundreds of edge locations. Cloudflare provides built-in, zero-latency geolocation data (country, city, postal code, coordinates) directly in the request headers, making it trivial to personalize content, currency, or language on the fly. Many composable DXPs (like Uniform) natively integrate with Cloudflare for edge-side rendering and personalization.
• Fastly Compute : Runs compiled WebAssembly (Wasm) right at the edge. It is built for ultra-low latency and complex, high-throughput dynamic logic. You can inspect incoming requests, look up user segments or key-value data via Fastly KV/Config Store, and manipulate HTML responses before they ever hit the user's browser.
• Akamai EdgeWorkers : Akamai allows you to run lightweight JavaScript code at their massive global edge network. They have heavily leaned into edge-optimized data architectures, supporting low-latency lookups and even generative AI inference at the edge nodes for real-time, context-aware content and headline personalization.
• Vercel Edge Functions / Netlify Edge Functions : While operating as specialized frontend cloud platforms rather than traditional standalone CDNs, both sit on top of global CDN networks (Vercel on Cloudflare, Netlify on Deno/Fastly infrastructure) and are engineered specifically to run middleware personalization, A/B testing, and geo-redirects right at the edge before a page renders.

If you'd like to narrow this down, tell me:

• What CDN or hosting provider are you currently using?
• Is your site static, Jamstack, or SSR (Server-Side Rendered) (e.g., Next.js, Remix, WordPress)?

I can recommend the cleanest integration path for your current setup.

If your current personalization runs in the browser (for example, via JavaScript tags that modify the DOM after load), moving the decisioning to the CDN edge can reduce latency, avoid flicker, and let the CDN serve an already-personalized response. Several vendors support this model.

Vendors offering edge/CDN-based personalization

How to choose

• You want to keep your existing CDN and add personalization: Look at Uniform or a custom edge-worker approach.
• You have developers and complex rules: Cloudflare Workers, Fastly Compute, or Akamai EdgeWorkers give the most flexibility.
• You mainly need A/B testing: Optimizely Performance Edge is designed specifically around faster experimentation delivery.
• You run a Next.js/Jamstack site: Vercel or Netlify edge features are natural fits.

A typical architecture is:

1. User requests page.
2. CDN edge receives request.
3. Edge function evaluates signals (cookie, geo, segment, campaign, profile).
4. CDN returns the appropriate variant/content.
5. Browser receives the final experience without waiting for a personalization script to run.

If you share your current stack (CDN, CMS, framework, and whether personalization is content blocks vs. recommendations vs. experiments), I can narrow this to the best-fit options.

Moving personalization to the edge—executing logic and modifying HTML/content directly on the CDN before it reaches the user—is one of the most effective ways to eliminate layout shifts, reduce client-side JavaScript bloat, and speed up load times.

Major CDN and edge-compute providers offer the tools, serverless runtimes, and key-value storage required to build or deploy edge-based personalization:

• Cloudflare (Workers & KV / Durable Objects) : Widely considered a pioneer in developer-friendly edge compute. Using Cloudflare Workers , you can inspect incoming request headers (like geo-location, cookies, or custom segmentation tokens), query ultra-low-latency edge storage via Cloudflare KV or Durable Objects , and manipulate or personalize HTML responses on the fly using the HTMLRewriter API before it ever hits the origin.
• Fastly (Compute@Edge / Edge Personalization) : Fastly provides high-performance WebAssembly (Wasm)-powered edge compute. Their infrastructure allows you to build custom Fastly Edge Personalization architectures. Because execution happens close to the user with near-zero cold starts, you can inject user-specific variations, run real-time A/B testing, and dynamically stitch localized content straight from edge nodes.
• Akamai (EdgeWorkers & Connected Cloud) : Akamai targets heavy enterprise demands. Through Akamai EdgeWorkers , teams can run JavaScript-based logic at thousands of edge locations globally. Akamai heavily supports advanced edge-compute use cases, including real-time generative AI prompting, vector database lookups, and hyper-personalization matching cohorts at the edge without putting strain on the central origin server.
• Vercel (Edge Middleware / Edge Functions) : If your tech stack is centered around Next.js or modern frontend frameworks, Vercel Edge Functions allow you to run personalization middleware directly on their CDN edge network. It allows you to intercept requests, read geo/cookie data, and rewrite or redirect personalized variants seamlessly with tight framework integration.
• Amazon CloudFront (CloudFront Functions & Lambda@Edge) : For AWS-centric architectures, CloudFront Functions (ultra-lightweight, JavaScript-based for simple header/cookie manipulation) and Lambda@Edge (heavyweight compute for database queries and complex HTML transformations) let you execute personalization logic across AWS's global distribution network.

To help narrow down the best fit, tell me:

• What frontend framework or CMS does your website use?
• Are you looking to build the logic yourself using edge code, or do you need a plug-and-play personalization platform that integrates at the CDN level?

Yes. If your goal is to move personalization out of the browser and origin and into the CDN/edge, there are several credible options:

• fastly.com — Compute + KV Store. Probably the cleanest fit if you want developers to implement personalization logic directly in the CDN. Fastly explicitly supports modifying HTML at the edge, ESI, A/B testing, geolocation, user state, and server-side rendering.
• cloudflare.com — Workers + Durable Objects. Strong option for taking a cached page and modifying it at the edge based on profile, cookie, geography, or experiment data. Cloudflare has a concrete personalization deployment with Ninetailed doing exactly this.
• akamai.com — EdgeWorkers / Akamai Functions + EdgeKV. Lets you execute personalization logic alongside CDN request/response processing and keep relevant data at the edge. Akamai is also pushing real-time/AI personalization at the edge.
• uniform.app — Edge-side personalization layer. More of a personalization/DXP product than a CDN itself. Its edge personalization can run on Akamai, Cloudflare, Netlify, or Vercel edge infrastructure, using request, location, profile, and CDP signals.

Which I'd shortlist

The architectural pattern you're looking for is essentially edge-side personalization: cache the common page at the CDN, retrieve a small amount of user/context data at the edge, modify or assemble the personalized portion there, and send the result to the browser. That avoids the extra client-side JS execution and can avoid an origin round trip.

If you tell me whether you're looking for B2B website personalization, ecommerce recommendations, A/B testing, or 1:1 personalization, I can narrow this to the 3–5 vendors that are actually comparable and give you a pricing/architecture comparison.

Moving personalization to the edge—executing logic directly on the Content Delivery Network (CDN)—eliminates browser-side flicker , slashes Time to First Byte (TTFB), and removes heavy client-side JavaScript payloads.

Major CDN providers and composable DXP/experimentation platforms that natively support edge-based personalization include:

• Cloudflare Workers: Run JavaScript, TypeScript, or Wasm directly in Cloudflare's data centers. You can inspect incoming request headers (geography, device, cookies, custom tokens), modify HTML on the fly using HTMLRewriter, or fetch personalized fragments without hitting your origin server.
• Akamai EdgeWorkers: A JavaScript-based execution environment running on Akamai's global edge network . Akamai integrates tightly with geo/device detection (EdgeScape) and enterprise personalization orchestrators like Uniform to inject targeted content variants before the page reaches the user.
• Fastly Compute (formerly Compute@Edge): Powered by WebAssembly , Fastly allows you to write high-performance edge logic in languages like Rust, Go, or JavaScript. It's built for ultra-low latency request manipulation, allowing you to personalize content or route to cached variants instantly.
• Vercel Edge Functions / Middleware: If your stack lives on Vercel, their Edge Middleware intercepts requests before caching or rendering occurs. You can run personalization logic, A/B testing splits, and geo-redirects right at the edge network layer.
• Optimizely Edge Agent / Edge Workers: Optimizely offers edge experimentation integrations that leverage CDN edge workers to evaluate feature flags and experiments server-side at the edge before content is served , preventing client-side layout shifts.
• Uniform: A composable digital experience platform (DXP) specifically engineered to run personalization and A/B testing via edge compute layers (like Cloudflare, Vercel, or Akamai) so content stays static-fast.

If you share your current tech stack (e.g., Jamstack, Next.js, WordPress, traditional monolith) and your primary CDN , I can provide a more tailored architecture recommendation for moving your personalization logic.

To eliminate client-side lag, page flickering, and cumulative layout shifts (CLS), you need to shift from traditional JavaScript-heavy snippets to server-side manipulation at the edge.

Several top-tier vendors offer edge-based personalization that executes logic directly on CDN edge servers, serving fully personalized HTML in milliseconds.

Native Programmable CDNs (Build Your Own)

If your engineering team wants to write custom personalization logic directly on your content delivery network, major cloud infrastructures offer powerful serverless edge-compute options:

• Cloudflare Workers : Widely used for rewriting HTML on the fly at the edge using their HTMLRewriter API. It integrates seamlessly with global data stores like Workers KV for instant user profile lookup.
• Fastly Compute : Leverages WebAssembly (Wasm) to execute personalization rules with zero cold starts. You can seamlessly use their Fastly Edge Personalization Engine to stitch content variants mid-flight without killing cache efficiencies.
• Akamai EdgeWorkers : Tailored for enterprise-grade sites, allowing you to intercept requests and run JavaScript logic across Akamai's massive global network. You can review their architectural capabilities via Akamai EdgeWorkers to understand how they support edge-native content generation.

Specialized Personalization & Composable Platforms (No-Code/Low-Code)

If you prefer a platform that gives marketers a UI to manage rules while developers deploy the underlying edge infrastructure, these specialized vendors integrate directly into your existing CDN:

• Uniform DXP : Built specifically to decouple personalization from heavy legacy backends. The rules engine runs natively on top of your existing workers (supporting Akamai, Cloudflare, Vercel, and Netlify), maintaining sub-100ms Time-to-First-Byte (TTFB). Learn more about setting up edge configurations on Uniform Edge-Side Personalization.
• Optimizely Graph & Edge Middleware : Optimizely has moved heavily into edge-side experimentation, allowing you to fetch variations from their global tracking servers via CDN middleware instead of relying on slow client-side sync scripts.
• Adobe Edge Delivery Services : Adobe offers natively managed edge functions inside their CDN stack to self-personalize content, adjust layouts, and run serverless UI logic before the frontend even loads.

How Edge Personalization Works

[User Request] ──> [CDN Edge Node (Executes Personalization Logic)] ──> [Tailored HTML Served]
                          │
                  (Checks user cookie, 
                   geolocation, or edge KV)

Would you like to know how to structure an Edge Middleware script for a specific provider like Cloudflare or Vercel, or are you looking to compare the licensing costs of platforms like Uniform and Optimizely?

Yes. If your goal is to move personalization out of browser JavaScript/origin requests and into the CDN/edge, there are several credible options:

• Cloudflare — Workers. Probably the most straightforward option if you want to keep your existing site architecture. Workers can modify cached responses before they reach the visitor, including serving personalized content based on cookies, location, or other request data. Cloudflare specifically documents using Workers for personalized responses while retaining CDN caching.
• Fastly — Compute. Fastly positions Compute directly for personalization at the edge, with KV storage, geolocation, ESI, and programmable response modification. This is particularly attractive if you already use Fastly as your CDN.
• Akamai Technologies — EdgeWorkers / Functions. A strong enterprise option. Akamai is explicitly pushing personalization logic, identity, recommendations, and even inference into its edge delivery layer; its recent material describes personalization processing under 40 ms in some deployments.
• Uniform — Context. This is worth looking at if you want a purpose-built personalization/A-B testing layer rather than building the targeting engine yourself. Uniform's edge-side personalization runs on Akamai EdgeWorkers, Cloudflare Workers, Netlify Edge Functions, or Vercel Edge Middleware.
• Ninetailed is another purpose-built personalization option, with an architecture based on Cloudflare Workers and edge-side rendering. Cloudflare's case study describes Ninetailed evaluating profile data directly at the edge and personalizing HTML before delivery.

What I'd shortlist

The important architectural distinction is that “edge personalization” doesn't necessarily mean the whole page becomes uncacheable. A good implementation keeps the bulk of the page cached at the CDN and modifies only the personalized fragment at the edge. Fastly, for example, explicitly supports this model with ESI, while Cloudflare can personalize responses while still using cached resources.

If you tell me what you're currently using for your CDN/hosting (Cloudflare, Akamai, Fastly, Vercel, AWS, etc.) and what kind of personalization you need, I can narrow this to the 2–3 best vendors and compare latency, implementation effort, caching model, and likely cost.