The Evolution of Data Layers: Transitioning from Traditional to Event-Driven Models

An in-depth examination of the fundamental shift in data layer design and its implications for future-proof data collection

Opening Summary

As digital businesses evolve, so does the need for sophisticated data collection methodologies. Today, a 'data layer' concept is integral to digital analytics, web personalization, and many marketing technology applications. Data layers provide a standardized method to consolidate and streamline the information flowing from various website interactions, forming the foundation for a data-driven approach to decision-making. In this article, we'll critically evaluate two key types of data layers: traditional upfront-loaded models and the increasingly adopted event-driven models.

Our exploration begins with traditional data layer models, exemplified by systems like defined JS objects remotely loaded to the client. The traditional approach involves predefining a set of variables that capture specific data points on a webpage. These variables are populated at page load, creating a data snapshot that various tracking tags can utilize. This upfront-loaded model has served the digital analytics world for many years. Adobe and Google used this approach in previous versions of their solutions. However, with the growth and complexity of digital interactions, this approach often lacks flexibility and scalability.

Notably, Traditional Data layer models have sought to address these limitations by introducing new features. However, these new feature capabilities may allow for a more dynamic data collection, using configurable event listeners to capture and track user actions in real-time. While this feature provides some real-time benefits and characteristics of event-driven data layers, it essentially functions as a traditional upfront-loaded data layer.

As we transition into the future, the digital landscape demands an even more adaptable, scalable, and real-time approach to data collection. Enter the event-driven data layer, a model that Google Tag Manager (GTM) and Adobe's Experience Platform championed. Instead of relying on a predefined set of data points, the event-driven model captures data based on user interactions or 'events.' This model's responsiveness to user actions allows it to capture a much richer, more granular data set in real-time. Its dynamic nature makes it better suited to handle the ever-evolving requirements of modern web technologies and complex marketing tech stacks, positioning it as a truly future-proof data layer solution.

This article digs deeper into the mechanics, pros, and cons of these two data layer models. We explore their working principles, strengths and weaknesses, implementation and management considerations, and suitability to different businesses and technologies. The objective is to provide you with a comprehensive understanding that will aid in selecting the most fitting data layer model for your specific needs, allowing you to leverage the best of what both these methodologies offer.

Understanding Traditional Data Layers

Traditional data layers, also known as page load data layers, operate on a simple principle - they load data as soon as the page loads. This approach is great for static websites or situations where data doesn't need to be updated dynamically based on user interaction.

How Traditional Data Layers Work

Imagine a web page as a static billboard. When a visitor lands on the page, all the relevant information is presented upfront. Here is a simplified example of how a traditional data layer might be structured:

var dataLayer = {
    "pageCategory": "Electronics",
    "userId": "user123",
    "session": "session456",
    "product": "TV"
}

This static object holds key-value pairs representing various information about the user, session, page, or other interesting attributes. I have to pre-define upfront and then hunt and pick within the code to determine if a value maps to the pre-defined value.

Drawbacks of Traditional Data Layers

While simple to implement and understand, traditional data layers have several limitations:

  • Limited Scope: They're less effective for capturing real-time user interactions or changes on the page after the initial load. While there are ways around this, it is not straightforward. It's important to note that a traditional legacy Data Layer can capture and respond to events in real-time, but this often requires manual configuration and coding, which can be labor-intensive and may not scale effectively in large, complex implementations. Newer Event listener features might overcome this deficiency.
  • Limited Flexibility: Traditional data layers might not be as adaptable to modern, dynamic web applications or capable of capturing interactions in real-time.
  • Outdated Approach: Data must be captured dynamically with more interactive websites and single-page applications (SPAs). Traditional data layers struggle in these environments. While SPAs are supported, they are typically an add-on code. The previous versions of the data layer object were not radically updated for the newer approaches in the technology landscape.
  • Privacy Concerns: Traditional data layers collect all data upfront, which can lead to challenges in managing user consent. While you can deploy and administer consent management, it is often done as an add-on and developed later in the life-cycle of data layers. You must be sure your Consent management system can work well with an event-driven model as your dev teams transition.

Embracing Event-Driven Data Layers

Event-driven data layers present a dynamic and flexible approach to data collection. Instead of capturing data only at page load, they can react to real-time user interactions and changes on the page. Adobe's adobeDataLayer and Google's dataLayer in GTM utilize this approach.

How Event-Driven Data Layers Work

Event-driven data layers are more interactive. They track user interactions and update the data layer object in real-time. This allows a more accurate representation of the user's journey through the site. Here's an example using Adobe's adobeDataLayer:

var adobeDataLayer = [];
adobeDataLayer.push({
    "event": "pageLoad",
    "page": {
        "pageInfo": {
            "pageName": "home",
            "pageType": "main"
        },
        "user": {
            "userStatus": "logged_in"
        }
    }
});
adobeDataLayer.push({
    "event": "addToCart",
    "product": {
        "productName": "XYZ",
        "productCategory": "electronics"
    }
});

In this case, the data layer is updated at page load and when a user adds a product to the cart. It provides a more comprehensive view of user behavior, capturing nuances and real-time interactions.

Benefits of Event-Driven Data Layers

Here are a few reasons why event-driven data layers are seen as a future-proof approach:

  • Real-Time Data Collection: They capture user interactions in real-time, offering a richer data set for analysis and insight generation. The event-driven model continually updates the data layer in real-time as users interact with the site. This approach provides a more granular and dynamic representation of user behavior, allowing marketers to understand and respond to user actions as they occur. This is where the automatic event capture and processing offered by event-driven data layers can be more efficient and scalable.
  • Flexibility & Scalability: These data layers accommodate complex and dynamic web applications, making them more adaptable to new technologies and use cases.
  • Better Privacy Management: Tying data collection to specific user actions allows better consent management and regulation compliance.

Event-Driven Data Layers & Future Technologies

Event-driven data layers are well-positioned to integrate with various emerging technologies. Let's explore some of them:

  • Generative AI: Generative AI models, like GPT-3, create content based on the data they are trained on. Event-driven data layers could provide these AI models with real-time, contextual user data to generate personalized content.
  • CMS & WCM Solutions: Content Management Systems (CMS) and Web Content Management (WCM) solutions, like WordPress and Drupal, have started adopting decoupled architectures, where front-end and back-end systems are separated. This allows for more dynamic content updates, making event-driven data layers a more compatible solution.
  • MarTech Stacks: Modern marketing technology (MarTech) stacks are becoming increasingly complex, requiring real-time, granular data. Event-driven data layers cater perfectly to this need, providing detailed, real-time user interaction data.
  • Data Platforms: Modern data platforms, such as data lakes and data warehouses, store vast amounts of structured and unstructured data. Real-time data collected through event-driven data layers can feed these platforms with rich, up-to-date data.

Case Study: An E-commerce Platform

Consider an e-commerce platform that recently transitioned from a traditional data layer approach to an event-driven data layer. While the traditional approach is not inherently bad, it limited the capability and extended the time needed to implement the changes more quickly. The event-driven approach was especially helpful with the constant changes occurring with their content personalization program.

Under the traditional model, the platform could only capture static data when a user loaded a page. While it provided some insights, it lacked the ability to track dynamic user interactions. The traditional data layer lived client-side and was not flexible to adapt. Whereas the event-driven model allowed them to change and update the backend and accept the values being passed in based on simple .push call without constantly changing the data layer javascript object or defining new specific name-value pairs within the object. They could also transition to server-side and back to Client-side effortlessly.

By adopting an event-driven data layer, the platform could track in real-time when users added or removed items from their cart, viewed product details, changed filters, and more. Again, the traditional approach can do this, but if the pages and components are always being tested and changing - which occurs in larger data-driven and experiment-driven organizations; the traditional approach is too inflexible.

The Event-driven approach leads to more nuanced insights about user behavior, enabling personalized recommendations and improving conversion rates. Moreover, as they adopted a single-page application framework for a smoother user experience, the event-driven data layer seamlessly captured all interactions.

Building a Future-Proof MarTech Stack with Event-Driven Data Layers

The shift to event-driven data layers isn't just a response to the evolving technology landscape. It's also a strategic move towards building a future-proof marketing technology (MarTech) stack. Integrating these systems becomes critical as organizations embrace new marketing tools and platforms.

The dynamic nature of event-driven data layers allows businesses to integrate multiple systems within their MarTech stack more effectively. Because data is updated in real-time, every tool in the stack can access up-to-date, user-centric data, enabling more targeted and personalized marketing.

Use Case: Personalization in Real-Time

Consider a real-world example: an online retailer uses Adobe's adobeDataLayer to capture user interactions. The customer navigates to the electronics category and views several high-end smartphones. This interaction triggers an "event," updating the data layer.

The retailer's personalization tool, connected to the data layer, can immediately react to this data. It displays personalized smartphone recommendations, increasing the likelihood of purchase. Without an event-driven data layer, such real-time personalization would be challenging, if not impossible, to achieve.

Governance and Compliance in the Age of Privacy

In an era of increasing scrutiny on data privacy, with regulations like the GDPR and CCPA, managing user consent and compliance becomes critical. Traditional data layers, with their upfront data collection approach, can struggle to meet these stringent requirements. Working through the Dev stages and processes might take weeks or months.

Event-driven data layers shine in this regard. Businesses can control when and what data to send based on user consent or other conditions by tying data collection to user actions. This approach allows organizations to meet regulatory requirements while still capturing valuable data. This approach would only take hours to a few days to implement.

Event-Driven Data Layers and Modern Web Technologies

The web is evolving, and so are the technologies that power it. Single-page applications (SPAs), built with frameworks like React.js and Vue.js, deliver smoother, app-like experiences on the web. However, they also break the traditional page-based data collection model.

Event-driven data layers align well with these modern technologies. Instead of relying on page loads to capture data, event-driven data layers track user interactions, perfect for SPAs where user interactions drive changes on the page.

Let's consider a case where a company has a SPA built with React.js:

import {useEffect} from 'react';
const ProductPage = () => {
  useEffect(() => {
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
      'event': 'productPageView',
      'product': 'XYZ',
      'productCategory': 'Electronics',
      'productPrice': '$500'
    });
  }, []);
  return (
    <div>
      {/* Product Details */}
    </div>
  );
}

In the above example, a "productPageView" event is pushed to the data layer whenever a product page component is mounted in the React.js application. This provides a flexible and efficient way to capture data in a SPA environment, something traditional data layers would struggle to achieve.

The Evolution of Data Layers: Looking Ahead

With their adaptability, flexibility, and focus on real-time, user-centric data collection, event-driven data layers are poised to be the future of data collection. However, new methods and techniques will continue to emerge as technology advances.

For instance, server-side tagging is becoming increasingly popular. By shifting the data processing workload from the client-side (user's browser) to the server-side, server-side tagging offers improved page performance, greater data privacy control, and more reliable data collection.

Similarly, technologies like WebAssembly (which allows high-performance applications on web pages) could open new avenues for data collection. Due to their flexibility, event-driven data layers might be better suited to adapt to these technologies.

Moreover, as artificial intelligence (AI) and machine learning (ML) technologies advance, we may see more automated and intelligent data collection mechanisms. These systems could potentially identify and track significant user interactions automatically, reducing manual work in setting up and managing event-driven data layers.

Conclusion

The digital landscape is evolving, and so is how we collect, analyze, and use data. While helpful in the past, traditional data layers can help with dynamic, real-time, and user-centric data collection methods; the future is with Event-driven data layers. Solutions like Adobe and Google Tag Manager are pushing the envelope with EDDLs. They align better with the emerging trends in web technology, marketing technology stacks, and modern data platforms. Their adaptability and flexibility make them a future-proof approach to data collection.

The future of data layers will be influenced by new technologies, including server-side hybrid tagging, WebAssembly, and AI/ML. The key to staying ahead will be continuously adapting and evolving, ensuring your data collection methods align with technology trends, user expectations, and regulatory requirements. In this ongoing journey, event-driven data layers promise to be a valuable companion, offering the versatility and user focus that future technologies will demand.

Subscribe to CDP Everything - Martech and your Customer

Don’t miss out on the latest issues. Sign up now to get access to the library of members-only issues.
jamie@example.com
Subscribe