Uniform blog/Personalization/Delivering personalized and fast experiences at scale
adam conn
Adam Conn
Posted on Nov 11, 2021

8 min read

Delivering personalized and fast experiences at scale

To meet consumer demands for fast-loading, individually tailored digital experiences, business teams need intuitive personalization tools that do not lead to data silos. Those requirements are often at odds, however, and, ironically, the most effective way to bring them together is by separating them. This article shows you how Uniform delivers an ideal resolution through decoupled personalization.
Understanding and Mastering Personalization of Websites

The need for speed

Consumers expect fast page loads, clicking away from lethargic sites as a rule. In fact, a survey showed that one in four visitors would abandon a site that took more than four seconds to load.
Speed is so important that Google factors it into their search-result rankings. If your site is in a low ranking, visitors might not even get to see its sluggishness first hand.

The personalization paradox

Also crucial for user engagement is personalization. Problem is, the personalized experience that most visitors have come to expect often undercuts the speed that attracted them in the first place. Like a tree falling in an empty forest, a carefully customized user experience might land on deaf ears if the snail-paced loads have caused visitors to abandon the site before its display.

A fundamental flaw in logic

Regardless of their approach, personalization paradigms involve logic, which is where the problem lies. Because it controls the personalization process, logic can slow down page loads. No matter where that logic lives—at the point of origin or on the client—it tends to mess up your user experience.
Furthermore, logic running at the point of origin, which is mostly the case with monolith content management systems (CMSes) or digital experience platforms (DXPs), is not just slow, but also expensive and tough to scale.
On the other hand, tools that run on the client, such as Optimizely, Adobe Target, and Google Optimize, are no magic either. Moving personalization logic closer to visitors still sacrifices speed because the browser must download and run another block of JavaScript.
In addition, client-side solutions are easier to block and tend to conspicuously update pages, simultaneously disrupting the user experience. You’ve likely seen sections of a page jump around while it’s loading—a demonstration of a principal drawback of client-side personalization.

Proliferation of personalization problems

Besides performance issues caused by personalization approaches, also important is the way in which practitioners—marketers, merchandisers—configure personalization. From the business perspective, the value of personalization hinges on your ability to configure it at the right place and time. Because monolithic CMSes and DXPs typically incorporate personalization into the authoring process, practitioners assume that the feature is a matter of course—even in headless systems where, by definition, the content and presentation are separate.
Reality is, most third-party personalization tools that bridge the headless gap require duplicating the content already defined within the CMS, sparking data silos and updating nightmares. Each time you change your content, you must do so in multiple places. As a result, you lose your knowledge of even the basics of the content type and content location.

A two-part personalization

Seemingly a monolithic undertaking, personalization actually consists of two distinct parts:
  • Configuration, which is the user interface through which practitioners create and manage personalization.
  • Execution, which is the technical process of applying the unique information about the visitor for a personalized experience.
With Uniform’s decoupled personalization approach, you can pick the best tool for each of those two parts instead of being saddled with one tool that, for example, offers optimum execution but complex configuration, or vice versa.
A case in point: Some personalization tools accelerate execution by tasking developers, not practitioners, with configuring personalization. That model is impractical for most organizations, however, since it’s inflexible and time consuming to establish, let alone that updates are laborious. Plus, the task requires heavy involvement from developers in planning and execution, which are better handled by practitioners.
Thus, when it comes to configuring personalization, the old adage applies: If it ain’t broke, don’t fix it.

Configurations that meet your needs

If your CMS includes native tools for configuring personalization, do not reinvent the wheel. In fact, doing so can be costly and alienating for practitioners who are familiar with the tools that meet their needs.
For example, with Uniform, Sitecore users who are accustomed to Sitecore’s robust personalization tools can continue to operate in that familiar environment with no workflow changes. That’s a key strength of decoupling personalization: In the Sitecore scenario, the configuration remains the same even though the execution is different.
If your company’s CMS comprises no personalization tools, Uniform offers a no-code, more effective solution than that from most vendors. Instead of a complex, rules-based mechanism that’s difficult to implement and even harder to maintain, the Uniform technique is automated and intent based, focusing on the visitor’s in-the-moment needs and deftly connecting consumers with the information they are after.
In addition, automated personalization frees practitioners from having to think and operate like developers, such as defining and managing the large sets of nested if-elseClick to copy statements in rules-based personalization. Instead, practitioners are free to tackle tasks in which they excel.

Bottlenecks to execution

No matter that personalizing content with unfamiliar tools can be frustrating, the performance problems that plague many personalized sites are not due to the tools’ setup. Rather, the bottleneck occurs in execution.
Standard personalization typically involves contacting the application server, waiting for it to apply the personalization rules, building the individually tailored pages accordingly, and then pushing out the pages. The entire process, called origin-side personalization, takes just a few seconds, which in internet time can seem like an eternity.
Further impacting that process is the load on the application server. The more site visitors, the longer it takes to complete the process—a fundamental law of physics that still applies in today’s age of high-speed Internet. Besides, the farther a signal must travel, the longer it takes to reach the destination.
Also compounding the problem is the reality that most companies rely on a limited number of application servers, often just one. If that server is in New York, data needs to travel only a short distance to reach the consumers on the East Coast, whose page loads would be fast. Not so for those in, say, the Middle East, who must wait for not only the personalization process to run, but also for data to journey to the application server and back.

The pros and cons of CDNs

These days, most companies are bridging distances and speeding up sites by deploying pages to servers on a content delivery network (CDN) whose points of presence are closer to visitors’ locations.
Nonetheless, CDNs alone cannot solve the problem of personalization. If you’re relying on origin-side personalization, your CDN must refer back to the application before serving customized pages, thus undermining the primary value of CDNs in the first place.
Nor can CDNs raise the performance of pages that are personalized client-side. Any savings in time that result from serving those pages from a speedy CDN would likely be canceled out by the time it takes to build them on the browser.

Execution: a Uniform solution

Uniform offers a clever way to reap the performance benefits of CDNs vis-à-vis personalization while steering clear of the drawbacks. How? By moving the execution of personalization to the CDN. Here’s the process:
  1. The first time a visitor requests a page, the CDN retrieves it from the application server, which then returns a page with embedded personalization instructions.
  2. The CDN runs the instructions and returns a personalized experience to the visitor.
  3. The CDN also caches the page—along with the embedded instructions—on the CDN itself. When another visitor requests the page, the CDN executes the instructions according to the visitor’s unique context with no need to call the application server.
In addition, because visitor requests go to the CDN instead of the application server, scaling up to address demand becomes much easier. Your site’s fast performance persists regardless of visitor load.
Likewise, client-side execution is efficient and smooth. Since pages are composed on the CDN before delivery, no longer necessary are additional requests or client-side processing, hence no page blocking or tampering on the client. All pages are fully rendered on the CDN; the browser simply displays the content.
Not least, because Uniform separates the execution of personalization from its configuration, the authoring experience remains unchanged, which is a big boon for practitioners.

The effectiveness of divide-and-conquer

Most of the issues that render personalization difficult or disappointing have stemmed from a design flaw in the personalization architecture. That is, solutions that give practitioners the control they desire and the tools they are used to usually come at a high cost in performance that alienates visitors.
On the other hand, mechanisms that deliver pages fast often do so by wresting control of personalization tools from practitioners and, in some cases, by eliminating personalization altogether. That’s not an acceptable alternative by far.
Uniform’s approach of decoupling the configuration of personalization from its execution offers the best of both worlds: a familiar user experience for practitioners and a superior performance that was only available before with pricey custom development. All told, what was once expensive and limited to just a handful of brands is now widely available.
What’s more, the Uniform option is fully compatible with popular architectures, such as Jamstack and MACH, which emphasize performance and support numerous products. Additionally, because Uniform is inherently decoupled, it can also handle decoupled architectures.
In summary, with respect to solving the paradox of personalization, Uniform’s divide-and-conquer tactic is impressive and powerful. By splitting the problem into two parts—configuration and execution—Uniform has engineered a superior fix and a win-win for the digital universe.
To see Uniform in action, schedule a free demo today!