In launching same-session personalization, Hightouch has solved one of the most challenging problems in modern marketing technology: combining sub-second event processing with complete customer context from the data warehouse. Here’s the fundamental issue: data warehouses contain rich customer data but operate on batch timelines, while streaming systems process events in milliseconds but lack historical context.
This post dives into the technical architecture and design decisions that make this possible. We’ll explore how we built a system that can scale from thousands to millions of events while maintaining sub-second latency, and how it combines real-time signals with historical context to power same-session personalization.
The technical challenge: speed vs. completeness
At Hightouch, we believe the data warehouse should be the center of your martech stack. It’s where your richest customer data lives. However, same-session personalization has been a historical challenge for warehouse-first technology.
The architectural challenge results from conflicting processing models. Warehouses optimize for analytical queries across large datasets with batch processing that can take minutes. Event streaming systems optimize for low-latency event processing, often measured in milliseconds, but they lack access to historical data and non-event entities.
Traditional Customer Data Platforms (CDPs) have tried to solve same-session personalization, but run into several constraints:
- Rigid schemas that prevent the use of full customer data in the warehouse
- Deployment complexity that can require months of data migration and schema mapping
- Complex data governance due to data duplication and maintaining systems of record in multiple locations
As a result, marketers and data teams have been forced to choose between personalizing quickly with limited customer context or rich customer experiences delivered in minutes instead of seconds. Hightouch bridges this gap with a novel parallel architecture that maintains sub-second performance while accessing the full breadth of warehouse data.
Core architectural components: Parallel processing for real-time context
Hightouch’s same-session personalization engine operates on three core architectural components designed to solve the trade-off between speed and completeness.
Building this required solving several distributed systems challenges through these components: an incremental compute engine that maintains consistent audience membership, intelligent data caching that handles high event throughput, and a hybrid computation model that ensures data freshness while minimizing warehouse query load.
1. Incremental compute engine
To begin using same-session personalization, users create an audience in Hightouch and toggle on “real-time.” Users can use real-time events and historical data to determine audience qualification. Instead of evaluating audience membership from scratch with each event, our platform incrementally updates the affected audience calculations for each user as events arrive.
When a user performs an action, the system:
- Captures the event in real-time
- Updates only the affected audience calculations
- Evaluates membership changes against defined thresholds
- Triggers downstream actions within milliseconds
This incremental approach means that complex audience definitions with rolling lookback windows like "users who performed 10+ high-value actions in the last 30 minutes" compute just as quickly as simple ones.
Build real-time audiences that combine real-time signals with historical customer data.
2. Intelligent data caching with automatic purging
While Hightouch's philosophy centers on zero data storage outside your warehouse, sub-second processing requires strategic caching. We've solved this through intelligent, time-bound caching:
- Event window management: For an audience defined as "performed 3+ events in the last hour," the system automatically maintains a rolling cache of the last hour of event metadata pertaining to that audience definition.
- Profile attribute caching: Static or slowly changing attributes from your warehouse are cached with configurable refresh intervals.
- Automatic purging: Data expires and purges automatically based on your audience definitions, ensuring a minimal storage footprint.
This approach means you get the speed of in-memory processing without the data governance concerns of traditional CDPs.
3. Hybrid computation model
Hightouch blends streaming and batch data through a hybrid computation model. For example, an audience of "Premium customers who browsed luxury items in the last 10 minutes" combines:
- Real-time events: Browse events from a rolling window of the last 10 minutes
- Warehouse data: Customer tier status (Premium customers) from your data platform
The system fetches and caches warehouse attributes on demand, ensuring fresh data without sacrificing speed.
Architecture that runs parallel to the data warehouse powers same-session personalization use cases.
Scaling for the enterprise
From day one, we designed our same-session personalization technology to handle enterprise scale.
Horizontal scalability
Whether you're processing thousands or billions of events daily, the architecture maintains consistent sub-second latency through:
- Distributed event processing across multiple nodes
- Automatic load balancing of audience computations
- Stateful processing with intelligent persistence to balance the benefit of in-memory state with dynamically scaling compute
Efficient resource utilization
Unlike traditional streaming systems that process all events, Hightouch intelligently filters and processes only events relevant to your defined audiences. This selective processing dramatically reduces computational overhead while maintaining real-time performance.
Flexible integration into your tech stack
There are two primary patterns for accessing computed audience memberships (push or pull):
1. Event-driven push
Receive audience entry/exit events in real-time:
- Immediate notifications when users cross audience thresholds
- Push to any destination in Hightouch's 250+ connector catalog
- Support for email tools, webhooks, message queues, etc.
This approach enables use cases like instant campaign triggers or real-time offer eligibility.
2. Real-time API pull
Query audience memberships on-demand through a high-performance API:
- RESTful interface for easy integration
- Average of 1-second latency from event ingest to membership update
This pattern works perfectly for same-session personalization, where your application needs instant access to user segments.
Push vs pull methods for computing real-time audiences
Real-world technical impact
A great example of where the value of this design is so impactful is within the publisher space. Imagine you are a travel agency (or any site that publishes ads). You must do two things to generate revenue:
- Show ads relevant to each user, combining context & behavioral actions
- Drive these users down your purchase funnel
Before, in order to show relevant ads in real time, you had to rely on uploading these events into an SSP such as Google Ad Manager or pass these audiences from the warehouse into your SSP, sacrificing the context and speed required to charge premium CPMs for advertisers.
Now, Hightouch can dynamically calculate audience membership based on same-session activity and immediately share as key:value pairs into Google Ads Manager. In the image below, for example, hotel ads on the right side are immediately personalized based on the same-session intent of the browsing user.
Dynamic hotel ads are displayed based on user interactions within the session.
Getting started quickly
Unlike traditional real-time implementations that require months of infrastructure work, Hightouch deploys in days:
- Connect your event stream: Point your event pipeline to Hightouch's ingestion endpoint.
- Define audiences: Use our visual audience builder to create real-time segments.
- Choose your integration: Decide whether to pull via API or receive push notifications.
- Go live: Start delivering sub-second personalization.
The future of real-time marketing
Combining real-time signals with unlimited customer data represents a fundamental shift in how enterprises can approach real-time personalization. By solving the technical challenges of combining streaming speed with warehouse completeness, we have removed the traditional compromise between being fast and being smart.
Whether you're personalizing ad inventory in milliseconds, triggering instant cart abandonment campaigns, or delivering dynamic pricing based on real-time behavior, the architecture behind our same-session personalization technology ensures you can scale without limits, while maintaining the sub-second performance your customers expect.
The data warehouse should be the center of your marketing technology stack. It’s where your richest customer data lives. Now, it can also power your fastest and most responsive customer experiences.
Ready to bring real-time intelligence to your customer experiences? Contact our solutions team to learn how Hightouch can transform your personalization strategy.
