Achieving Fast, Marketer-Driven Personalization
Site visitors expect a fast-loading, individually tailored digital experience, while business users need personalization tools that are familiar and intuitive and that avoid creating data silos.
Unfortunately, these goals are often at odds. Ironically, the most effective way to bring them together is by breaking them apart. Learn how Uniform’s decoupled personalization provides the best of both worlds.
Speed is absolutely essential for user engagement. Visitors have grown to expect sites to load quickly and will often click away from sites that don’t load as fast as they’re accustomed to. In fact, one in four visitors said they would abandon a site that took more than four seconds to load.
This emphasis on speed is so important that Google factors site speed into their search result rankings. In other words, visitors may not even get the chance to experience your sluggish site first hand if it doesn’t wind up near the top of Google’s rankings.
Although speed is clearly the most important factor that affects user engagement, another key factor is personalization. But there’s a problem. The same personalized experience that most visitors have grown to expect will often undercut the very speed that got them engaged in the first place. Like a tree falling in an empty forest, a carefully customized user experience may land on deaf ears if the snail’s pace of page loading has led visitors to abandon the site before they have an opportunity to appreciate it.
The problem lies with logic. Logic controls the personalization process, and it is this same mechanism that is the factor that can slow your site down. Regardless of their approach, all personalization paradigms involve logic running somewhere.
Unfortunately, whether that logic lives at the point of origin or on the client, it tends to throw sand in the gears of your user’s experience. Logic running at the point of origin – what you’re most likely to encounter with a traditional monolith content management system (CMS) or digital experience platform (DXP) – is not just slow, but it can also be expensive and difficult to scale.
In addition, client-side solutions are easier to block and tend to update pages in a conspicuous way that’s disruptive to the user experience. If you’ve ever watched sections of a page jump around as it’s loading, you’ve gotten a visual demonstration of one of the principal drawbacks of client-side personalization.
The performance problems that many personalization approaches can create for your visitors aren’t the only things to be concerned with. How your company’s practitioners – marketers, merchandisers, etc. – configure that personalization can be crucial.
From the perspective of your company, the value of personalization hinges on your ability to configure it at the right place and time. Because traditional monolithic CMSes and DXPs typically incorporate personalization into the authoring process, business users have come to expect this. Indeed, they expect this even in headless systems where by definition the content and presentation are separate.
Unfortunately, most third-party personalization tools designed to bridge the headless gap require duplicating the content that has already been defined within the CMS. That can lead to data silos and all sorts of updating nightmares. Each time you make even the simplest change to your content you have to make it in multiple places. As a result, retaining even a basic understanding of what content is used and where becomes almost impossible.
Although personalization may seem like a monolithic undertaking, it actually consists of two distinct parts:
- Configuration refers to the user interface that a practitioner employs to create and manage personalization instructions.
- Execution is the technical process responsible for applying available information about the user in order to create a personalized experience.
Uniform’s decoupled personalization approach allows you to select the best tool for each part instead of being saddled with a single personalization tool that provides optimum execution but unfriendly configuration, or vice versa.
For example, some personalization solutions speed up execution by shifting the responsibility of configuring personalization away from business users and onto developers. Although developer-based personalization is certainly an option, it’s not a practical solution for most organizations. It provides very little flexibility, it can be time consuming to build, changes cannot be made quickly, and developers have to be heavily involved in planning and execution that is better handled by practitioners. When it comes to configuring personalization, the old adage applies: if it ain’t broke, don’t fix it.
If your CMS already comes with native tools for configuring personalization, there’s no point in reinventing the wheel. In fact, it can be expensive and alienating for business users who are already comfortable with tools that they are familiar with and that meet their needs.
So, for example, with Sitecore, which already has robust personalization tools that users are accustomed to, Uniform allows them to continue to work in that familiar environment with standard Sitecore personalization with no changes to their workflow. This points to one of the key strengths to decoupling personalization: In our Sitecore scenario, the configuration remains the same; only the execution is different.
On the other hand, if your company’s CMS doesn’t currently have personalization tools, Uniform offers a no-code solution for business users that improves on the personalization approach offered by most personalization vendors. Instead of relying on a complex, rules-based personalization approach that is difficult to implement and even harder to maintain, Uniform uses automated intent-based personalization. By focusing on the customer's in-the-moment needs, intent-based personalization is more effective in connecting customers with the information they are looking for.
In addition, automated personalization frees practitioners from having to define and manage the large sets of nested if-else statements you find with rules-based personalization. Rules-based personalization requires practitioners to think like developers. Uniform's automated intent-based personalization lets them think like practitioners.
Although personalizing content using unfamiliar tools can be annoying or disorienting, it isn’t responsible – at least not directly – for the performance problems that plague so many personalized sites. The bottleneck occurs, not with how personalization is configured, but with how those personalization rules are executed.
The problem arises because standard personalization typically involves contacting the application server, waiting for it to apply the personalization rules that have been configured, building the page according to those rules, and then pushing out the individually tailored page to the visitor. The entire process, often referred to as origin-side personalization, takes just a few seconds, but in Web time those seconds can seem like an eternity.
This process is further affected by the load on the application server. The more visitors who are using the site, the longer it takes for this personalization process to complete. Even in the age of high-speed Internet, the fundamental laws of physics still apply. The farther a signal has to travel, the longer it’s going to take to get there.
Most companies rely on a limited number of application servers, often just one. If that server is located in New York, it’s good news for people in the eastern United States because the data doesn't have to travel far. Unfortunately, site visitors based elsewhere, such as in the Middle East, won't be so lucky. They’ll have to contend not only with the time it takes to run the personalization process, but also the time it takes for data to travel to the application server and back.
These days, most companies are bridging the distances and speeding up their Web sites by deploying pages to servers on a Content Delivery Network (CDN) with points of presence that are geographically closer to where their visitors reside.
Unfortunately, CDNs alone can’t solve the problem of personalization. If you’re relying on origin-side personalization, your CDN can’t serve up a customized page without referring back to the application server, thus undermining the primary value of CDNs in the first place.
Nor can they do much to improve the performance of pages that are personalized client-side. Any savings that come from serving up those pages from a speedy CDN are likely to be lost by the time it takes to build them on the browser.
When it comes to personalization, the team at Uniform has found a clever way to reap the performance benefits of a CDN while carefully steering clear of the drawbacks. By moving the execution of personalization to the CDN, Uniform avoids the performance hits that come with executing from the origin:
The first time a page is requested, the CDN retrieves the page from the application server. The application server returns a page with all of the personalization instructions embedded. The CDN runs the personalization instructions and returns a personalized experience to the visitor.
The CDN also caches the page - with the embedded personalization instructions - on the CDN. When a subsequent visitor requests the page from the CDN, the personalization instructions are executed, using the visitor’s unique context. No call to the original application server is needed.
In addition, because visitor requests are made to the CDN instead of the application server, scaling up to address demand becomes much easier. Your site maintains fast performance regardless of visitor load.
Likewise, the problems associated with client-side execution are eliminated. Since the page is composed on the CDN before it is delivered to the client, there’s no need for additional requests or client-side processing. As a result, pages can’t be blocked or tampered with on the client. Each page is fully rendered on the CDN. All the browser has to do is display the content.
And because Uniform decouples the execution of personalization from its configuration, the authoring experience remains unchanged, which is a big win for practitioners.
Most of the issues that have made personalization difficult or disappointing have stemmed from a fundamental flaw in the way that personalization architecture is designed. Solutions that give business users the control they demand and the tools they are accustomed to often come at a high cost in performance that frustrates and alienates visitors.
On the other hand, solutions that deliver pages at speeds that visitors have come to expect often do so by wresting control of personalization tools from business users who depend on them and in some cases by eliminating personalization altogether.
By decoupling the configuration of personalization from its execution, Uniform offers the best of both worlds. It provides a familiar user experience for practitioners while delivering superior performance that in the past was only available with costly custom development. What was once expensive and limited to just a handful of brands is now widely available.
Uniform’s approach is fully compatible with popular architectures, such as Jamstack and MACH, which emphasize performance and support a wide variety of products. And, as you might expect, because Uniform is an inherently decoupled solution, it is also fundamentally equipped to handle decoupled architectures.
When it comes to solving the paradox of personalization, Uniform has taken a powerful divide-and-conquer approach. It has split the problem into two parts – configuration and execution – and then arrived at a superior solution for both.