Redpoint + Snowflake + Databricks + OfferFit + Braze

Overview

This solution positions Redpoint Global’s Customer Data Platform (CDP), powered by Snowflake as its primary data warehouse, as the central hub for unifying and enriching customer data, in tight integration with Databricks for advanced analytics, OfferFit (Braze’s AI Decisioning) for 1:1 offer optimization, and Braze for cross-channel campaign execution.

• Redpoint’s cloud platform provides identity resolution (including Realtime Profiles) to create accurate unified profiles, a real-time decision engine to determine next-best actions, and robust segmentation and audience creation tools.

• Databricks augments Redpoint with an Apache Spark-based lakehouse for big data processing and machine learning as well as being the source of 1^st party data for the client.

• OfferFit’s reinforcement learning agents continuously experiment and learn the optimal message, channel, and timing for each customer, feeding those decisions into Braze.

• Braze serves as the execution layer, delivering personalized messages (email, SMS, push, etc.) and capturing engagement feedback.

All components are deployed in their respective SaaS clouds and communicate via secure APIs and connectors, supporting both batch data pipelines (for large-scale data sync and model training) and real-time event flows (for instant personalization triggers). This reference architecture enables a 360° customer view with timely, AI-optimized customer interactions across channels.

Key components and roles

This section provides details on key components and roles.

Unified customer profile

Redpoint CDP creates a single source of truth by cleansing, standardizing, and merging customer data into a Golden Record for each individual. Deterministic and probabilistic identity resolution with persistent IDs delivers a trusted 360° view of the customer to power real-time decisioning and personalization.

Realtime decision engine

Redpoint’s Realtime engine evaluates live events and profile data in milliseconds to select the best content or action for each moment. Every new signal updates the profile instantly, so decisions are based on the most current state. It can trigger personalized responses on websites, apps, or via Braze in real time.

Cross-channel execution

Braze delivers the decided experiences across email, SMS, push, in-app, and more, orchestrating journeys and then streaming engagement events (sends, opens, clicks, purchases) back to Redpoint in real time via Braze Currents. This ensures a closed-feedback loop where responses continuously enrich the CDP.

AI optimization (OfferFit)

OfferFit by Braze adds self-learning experimentation with AI agents that test hundreds of variables and learn the optimal message, channel, and timing for each customer. It maximizes campaign performance by making true 1:1 decisions, supplementing Redpoint’s rule-based logic with reinforcement learning.

Databricks: Lakehouse (source data)

Databricks serves as the lakehouse hosting governed customer source data, including transactions, behavioral events, and reference datasets. Redpoint consumes curated datasets from the lakehouse to unify identities, enrich profiles, and create Golden Records used for downstream decisioning and activation.

Databricks modeling and analytics

Databricks enables advanced analytics and machine learning on customer data using scalable Apache Spark and collaborative notebooks. Data teams produce scores, segments, and predictive attributes that are published back to governed tables and consumed by Redpoint to drive personalization.

Redpoint CDP (SaaS): Unified profile & decision hub

Redpoint’s cloud-native platform ingests customer data from all sources (web, mobile, CRM, transactions, etc.) and unifies it into a single customer profile. It performs advanced identity resolution (combining industry-leading deterministic and probabilistic matching and assigning a persistent key) to merge records belonging to the same person with high accuracy. This yields a unified profile for each customer, encompassing their demographics, behaviors, and engagement history.

Redpoint provides a rich audience builder and activation interface to these profiles for other systems. The CDP’s built-in real-time decisioning engine continuously listens for inbound events (like website actions or API calls) and can apply business rules, predictive models, and lookups to determine the appropriate Realtime Decision with sub-second response times.

In this architecture, Redpoint acts as the intelligent core – it holds the master customer data, makes decisions on that data (in batch for scheduled campaigns and in real-time for immediate interactions), and hands off execution to Braze to orchestrate the overall experience.

Redpoint’s deployment is in its SaaS cloud, but it can directly connect to data warehouses like Snowflake or data lakes/lakehouses for access, if needed. User preferences are one source that can be ingested to support the customers’ expected use of their data and respect their desired interaction with the business by enforcing their privacy; e.g., if a user opts out, Redpoint’s profile updates, and it will stop including them in segments sent to Braze.

Databricks (SaaS): Lakehouse analytics & machine learning workspace

Databricks is an Apache Spark–based lakehouse platform used for large-scale data processing, advanced analytics, and machine learning. In this architecture, Databricks functions as the analytics and machine learning extension of the customer data platform, while Snowflake remains the system of record for identity resolution, unified customer profiles, and enterprise aggregates.

Operational and domain-level data such as transactions, product interactions, and event streams may originate in Databricks and are landed in Snowflake through a governed cloud data sharing and ingestion pattern. Within the Redpoint CDP environment, Redpoint curates this data, performs identity resolution, and generates enterprise-level aggregates and summaries.

Selected identity mappings and enterprise aggregates (for example, individual and business-unit cross-reference tables) are made available to Databricks through governed federated access patterns. Where persistence is required, Snowflake-generated changelog tables are ingested via the Snowflake Connector for Spark and applied to Databricks Delta tables using Delta Lake MERGE operations.

Databricks consumes these curated datasets to support advanced analytics and machine learning use cases. Data scientists use Databricks notebooks to perform exploratory analysis, build and train models, and compute derived features using Delta Lake. Model outputs and analytical summaries, such as churn scores or behavioral segments, are written to Delta tables in Databricks and synchronized to Snowflake as governed aggregates, where they are merged into the unified customer data model for segmentation and activation.

This integration follows a controlled, contract-driven federated bidirectional pattern rather than unrestricted two-way updates. Synchronization semantics are explicitly defined through published data contracts and deterministic application of changes, while selected analytical datasets are accessed through governed federated query patterns rather than implicit replication.

The primary data exchange patterns are summarized below:

• Databricks → Snowflake for curated domain facts, feature outputs, and analytical results, exposed via shared open-table datasets in cloud object storage (e.g., Iceberg) for federated access where persistence is not required, and published via standard Snowflake ingestion patterns (such as the Snowflake Connector for Spark and/or staged file-based loads) when shaping data into Redpoint Feed Layouts using views or dynamic tables for CDP ingestion.

• Snowflake → Databricks for identity mappings and enterprise aggregates, accessed through governed federated query patterns (such as pushdown via the Snowflake Connector for Spark or equivalent federation mechanisms) to support ML workflows without requiring bulk extraction, with Snowflake-generated changelog tables selectively applied using Delta Lake MERGE where historical persistence or training dataset replayability is required.

• A shared analytical exchange layer (e.g., Iceberg) enables controlled collaboration on feature tables, model scores, and large domain datasets, reducing duplication while maintaining schema contracts and governance boundaries.

• Synchronization occurs on a scheduled cadence for identity and activation-critical datasets (based upon business requirements), ensuring determinism, replayability, and strong data governance, while federated access is leveraged for analytical collaboration and ML agility. This design leverages Databricks’ scalable compute and AI capabilities while maintaining Snowflake as the authoritative foundation for customer identity and activation.

High-level data processing illustration

Braze: Omnichannel orchestration & delivery

Braze functions as the message execution and orchestration system, responsible for campaign delivery, journey logic (Canvases), and channel-level engagement tracking. Redpoint provides Braze with audiences and personalization attributes, enabling Braze to dynamically tailor content at send time. Campaigns may be triggered on a scheduled basis or initiated in near real time using API-triggered workflows, depending on the use case.

Braze emits detailed message disposition and engagement events such as sends, deliveries, failures, opens, clicks, bounces, unsubscribes, and conversions through its streaming and export mechanisms. These datasets are made available in Snowflake through Snowflake Secure Data Sharing, providing live, governed access to the data. Within Snowflake, the data is aligned to enterprise identity and shaped into Redpoint-compatible Feed Layouts using views, dynamic tables, or materialized tables.

Redpoint ingests these feeds to validate, standardize, and load engagement outcomes into its extensible customer data model. This ensures that orchestration outcomes directly inform identity resolution, segmentation updates, and subsequent campaign decisions. Braze remains focused on execution and channel excellence, while Redpoint and Snowflake provide governance, identity alignment, and cross-channel intelligence.

OfferFit (Braze AI decisioning): Self-learning personalization

OfferFit operates as a decision intelligence layer that applies reinforcement learning and contextual bandit techniques to outbound marketing. For OfferFit-enabled use cases, marketers define objectives, constraints, and eligible treatments, while OfferFit autonomously selects the best action for each individual at each decision point.

OfferFit integrates closely with Braze for execution, using Braze campaign and content metadata to determine available actions and issuing send instructions that Braze executes. Customer responses—captured as engagement and conversion events by Braze—are returned to OfferFit as outcome signals, allowing the models to continuously refine future decisions.

From an enterprise data perspective, OfferFit generates decision and experimentation metadata (chosen action, model version, cohort/control designation, exploration vs. exploitation indicators). These decision outputs, along with downstream outcomes sourced from Braze and transactional systems, are landed in Snowflake. There, they are aligned to unified customer identity and published as Redpoint Feed Layouts.

Redpoint ingests this data to maintain a complete decision → execution → outcome history within the CDP. This enables governed reporting, attribution, and learning at scale, while ensuring OfferFit’s adaptive intelligence operates within enterprise data, identity, and compliance standards. Together, Redpoint and OfferFit combine rule-based governance with AI-driven optimization to deliver both control and continuous improvement.

Integration approach and data flows

The systems are connected through a series of data integration points that enable both bulk data sharing and real-time event-driven interactions. This section outlines how data moves between Redpoint, Databricks, Braze, and OfferFit in both batch and real-time modes.

Step 1: Data ingestion & profile unification (continuous)

Customer and engagement data enters the ecosystem through Snowflake, which acts as the governed data foundation. Source systems—including web and app events, transactional systems, Braze engagement data, and OfferFit decision outputs—are delivered into Snowflake using cloud-native mechanisms such as Data Sharing, streaming ingestion, or batch file landing.

Within Snowflake, raw datasets are aligned to Redpoint Feed Layouts using views, dynamic tables, or materialized tables. These feed-shaped datasets standardize formats, normalize attributes, and add operational metadata (timestamps, source identifiers, batch markers). Redpoint ingests these feeds to validate, standardize, and apply identity resolution, linking all events and records to the appropriate customer profiles within its extensible data model. As a result, Redpoint maintains a continuously refreshed, unified customer profile that reflects activity across all channels.

Step 2: Batch analytics & feature exchange (scheduled)

On a scheduled cadence, Snowflake publishes curated customer, engagement, and outcome datasets to Databricks for advanced analytics and model development. These datasets are sourced from Snowflake’s curated and identity-aligned tables and transferred using cloud data lake patterns or bulk connectors optimized for scale.

Databricks uses these datasets to perform feature engineering, exploratory analysis, and machine learning (e.g., churn prediction, propensity scoring, behavioral clustering). Resulting outputs—such as scores, segments, or derived aggregates—are written back to Snowflake as governed analytical results. These outputs are then reshaped into Redpoint Feed Layouts and ingested back into the CDP, where they are merged into customer profiles and made available for segmentation and decisioning.

This batch exchange ensures Redpoint benefits from advanced analytics without fragmenting identity or duplicating systems of record.

Step 3: Realtime event processing & decisioning (event-driven)

Realtime events are streamed into Redpoint via its collection and decision APIs. Upon receipt, Redpoint updates the in-memory customer profile and evaluates business rules, eligibility criteria, and model outputs to determine the appropriate next action. If the decision results in an on-channel response (such as web or app personalization), Redpoint returns the response directly to the requesting system. If the decision requires outbound engagement, Redpoint determines the channel and action and initiates orchestration through Braze. These decisions are logged and later aligned in Snowflake to support attribution and learning.

Step 4: Omnichannel execution & optimization (real-time & batch)

For outbound engagement, Redpoint passes audience context and personalization attributes to Braze. Braze manages campaign workflows, message templates, channel compliance, and delivery mechanics. Messages may be sent in real time (triggered by Redpoint) or as scheduled batch campaigns.

When OfferFit is enabled, it acts as an AI-decisioning layer that selects the optimal variant, offer, or timing for each customer. Braze executes these OfferFit-driven decisions while maintaining full control over delivery and channel enforcement. Braze records detailed execution telemetry, including send, delivery, failure, and engagement events, which are streamed back into Snowflake for downstream processing.

Step 5: Feedback, measurement & continuous learning (continuous)

Braze emits detailed engagement and disposition events (sends, opens, clicks, conversions, failures), which are delivered into Snowflake and aligned to customer identity. These outcomes are shaped into Redpoint Feed Layouts and ingested into the CDP, updating customer profiles and influencing future segmentation and decisions.

OfferFit simultaneously consumes outcome signals to update its learning models, refining future treatment selection at the individual level. Aggregated results and decision metadata are persisted in Snowflake, enabling enterprise reporting, experimentation analysis, and model governance.

Redpoint closes the loop by using these outcomes to drive subsequent real-time and batch decisions, while Snowflake and Databricks provide the analytical foundation for deeper insight and continuous optimization. The cycle then repeats, with each interaction informing the next.

Data security and privacy

Throughout these steps, data security and privacy are maintained via appropriate measures. For example, only non-PII customer identifiers are used in Braze ↔ OfferFit communications (OfferFit doesn’t receive raw personal data), and all API calls between Redpoint, Braze, and Databricks are authenticated over HTTPS. Redpoint acts as the governance brain, enforcing preferences (if a profile is marked email opt-out, Redpoint won’t send that user to an email campaign in Braze) and ensuring compliance with regulations (the unified profile can store consent flags that Braze will also honor in its sending logic).

Benefits of integrated architecture

Combining the strengths of Redpoint, Databricks, OfferFit, and Braze provides capabilities that would be difficult to achieve with any single platform alone:

Complete 360° customer view

Redpoint serves as the system responsible for data standardization and identity resolution, ensuring that data from all channels and systems—such as Braze engagement events, transactional data, digital interactions, and analytics outputs—are linked to a single customer profile. Snowflake provides the governed foundation where raw and curated datasets are aligned to Redpoint Feed Layouts before ingestion.

This approach ensures that an email click, mobile app interaction, or in-store purchase all update the same customer record, providing a holistic and continuously refreshed customer view. This unified foundation improves segmentation accuracy, personalization quality, and downstream decisioning.

Realtime engagement & responsiveness

Realtime events flow into Redpoint through its collection and decision APIs, where customer profiles are updated immediately and evaluated against decision logic. When an action is required, Redpoint can respond directly on the originating channel or orchestrate outbound engagement through Braze.

Braze executes messages in real time while honoring channel-specific rules such as opt-in status, frequency caps, and deliverability requirements. Engagement outcomes flow back into Snowflake and Redpoint, allowing journeys and suppression logic to adjust dynamically—preventing over-messaging and ensuring consistent cross-channel coordination.

AI-driven personalization & continuous optimization

OfferFit applies reinforcement learning and contextual experimentation to outbound marketing decisions, selecting the optimal treatment for each customer based on historical behavior and real-time outcomes. These decisions are executed by Braze and measured through engagement and conversion signals.

Outcome data flows back into Snowflake and Redpoint, where it supports both enterprise reporting and continuous learning. OfferFit uses this feedback to refine future decisions, ensuring personalization improves over time. Because OfferFit operates on data unified through Redpoint and executed through Braze, its optimization remains grounded in accurate identity and reliable delivery.

Scalable analytics & innovation

Databricks provides a scalable analytics and machine learning environment where large datasets can be explored and modeled without impacting operational systems. Snowflake publishes curated, identity-aligned datasets to Databricks for feature engineering, modeling, and experimentation.

Outputs such as propensity scores, lifetime value predictions, and behavioral segments are written back to Snowflake and ingested into Redpoint via feed layouts. This ensures that advanced analytics are operationalized within the CDP and immediately usable for segmentation, decisioning, and orchestration.

Clear role separation & reduced redundancy

Responsibilities are clearly defined:

• Redpoint: data standardization, identity resolution, segmentation, decisioning

• Braze: omnichannel orchestration, message delivery, engagement tracking

• OfferFit: experimentation and AI-driven optimization

• Databricks: advanced analytics and machine learning

• Snowflake: governed data foundation and integration hub

This division ensures that no platform is forced to perform outside of its strengths, while tight integration ensures that each system amplifies the others. Insights produced by data teams directly influence customer experiences, and marketers benefit from AI-driven optimization without added operational complexity.

Closed-loop measurement & attribution

Braze engagement and outcome events are delivered into Snowflake and ingested into Redpoint, where they are linked to customer profiles and campaigns. This enables unified measurement across channels and touchpoints, supporting attribution, performance reporting, and journey optimization.

OfferFit consumes the same outcome signals to refine its learning models, while Redpoint uses the data to update segments, suppressions, and real-time decisions. The result is a feedback loop where every customer response informs future strategy and execution.

Composable, flexible, and future-proof design

The architecture follows modern composable CDP principles. Snowflake, Redpoint, Braze, OfferFit, and Databricks are loosely coupled through standardized feeds, APIs, and data contracts. This allows new tools, channels, or data sources to be introduced with minimal rework.

All components are cloud-based SaaS platforms, scaling elastically without on-prem infrastructure or custom middleware. Teams across marketing, data science, and IT can work in their preferred tools while benefiting from a shared, integrated foundation.

Together, Snowflake, Redpoint, Databricks, Braze, and OfferFit form a closed-loop customer engagement ecosystem. Snowflake provides the governed data foundation, Redpoint standardizes and unifies customer data, Databricks enables advanced analytics, OfferFit continuously optimizes decisions, and Braze executes experiences at scale.

This architecture ensures that identity, analytics, AI, and orchestration work as a single system. Every interaction is informed by accurate data, every outcome feeds back into learning, and every component contributes to continuously improving customer experience. The result is not just better campaigns, but a durable, future-proof platform for personalized engagement.