We want to own our data infrastructure. Is there an "unbundled" or composable CDP approach that uses our existing warehouse instead of a separate black box?

Yes. What you’re describing is generally called a composable CDP or warehouse-native CDP. The key idea is that your warehouse/lakehouse remains the system of record, while CDP capabilities are assembled around it rather than putting your customer data into another proprietary database.

The architecture

A typical setup looks roughly like:

Web / Mobile / Product / CRM / Support
              │
              ▼
       Event collection
              │
              ▼
┌──────────────────────────────┐
│       YOUR WAREHOUSE         │
│ Snowflake / BigQuery /       │
│ Databricks / Redshift        │
│                              │
│ Raw events                   │
│      ↓                       │
│ Identity graph               │
│      ↓                       │
│ Customer 360 / traits        │
│      ↓                       │
│ Audiences / features         │
└──────────────────────────────┘
              │
        activation layer
              │
      ┌───────┼────────┐
      ▼       ▼        ▼
     CRM     ESP      Ads

The important distinction is where the customer profile actually lives. A CDP that copies your data into its own database and merely exports it back to Snowflake isn't really giving you the architecture you're after. In a warehouse-native design, identity, segmentation and customer models can be implemented against your warehouse, with downstream systems consuming the resulting projections.

What you would actually compose

You don't necessarily need one vendor for everything:

• Collection/ingestion: Snowplow, RudderStack, or your existing event pipelines. Snowplow, for example, is explicitly designed to send behavioral data directly into your warehouse rather than maintaining a proprietary behavioral-data store.
• Transformation/modeling: dbt or SQL in your warehouse. This is where you'd define canonical customers, lifecycle states, LTV, product usage, etc.
• Identity resolution: deterministic and/or probabilistic matching that produces your canonical customer_id/identity graph.
• Audience/activation: Hightouch, Census, RudderStack, etc., to push warehouse-defined audiences and attributes into Salesforce, Braze, ad platforms, support tools, and so on.
• Optional decisioning/personalization: a more complete composable-CDP product if you need marketers to do self-service segmentation, journeys, AI decisioning, etc.

One important caveat: reverse ETL alone isn't a CDP. It's primarily the activation piece; identity resolution, profile modeling, governance and potentially real-time decisioning still need to exist somewhere.

Vendors I'd put on the shortlist

Hightouch, for example, describes its composable CDP as activating directly from existing Snowflake, Databricks, BigQuery or Redshift rather than creating another customer-data store.

The bigger architectural question

I'd actually frame the decision as:

"Which CDP capabilities do we want to buy, and which do we want to own?"

You can own the data model, identity keys, business logic, governance and customer history while buying the boring/complex plumbing around them.

That's often a better compromise than either:

"Build the entire CDP ourselves" or

"Buy Salesforce/Adobe/Segment and give them a copy of everything." The strongest version of this architecture makes your warehouse the canonical customer graph, with vendor products acting as replaceable interfaces to it. That gives you much less vendor lock-in and makes your customer model usable by analytics, ML/AI, product systems and marketing—not just by the CDP UI.

If you tell me whether your warehouse is Snowflake, BigQuery, Databricks, or something else, I can sketch a concrete composable-CDP stack—including which pieces I'd buy vs. build and where the data actually lives.

Yes, absolutely. What you are describing is known in the data ecosystem as a Composable CDP (or an unbundled/warehouse-native CDP).

Instead of forcing your customer data into a proprietary, expensive black-box vendor silo, a composable CDP treats your existing cloud data warehouse (like Snowflake, Google BigQuery, or Databricks) as the single source of truth and the core database for customer profiles.

How the Composable CDP Stack Works

An unbundled CDP relies on distinct, modular layers that plug directly into your current infrastructure:

Why Companies Switch to a Composable Approach

• Data Ownership: You own the models, the SQL code, and the raw data inside your own cloud account. No vendor lock-in or surprise egress fees for trying to export your own data.
• Cost Efficiency: You aren't paying a traditional CDP a massive markup to store duplicate data on their servers. You leverage your warehouse's existing storage.
• Transparency & Trust: Marketing and data engineering finally look at the exact same numbers because the transformations happen transparently via dbt/SQL in your own environment rather than hidden inside a third-party black box.

If you want to explore this further, let me know:

• What cloud data warehouse are you currently using (e.g., Snowflake, BigQuery)?
• Are your teams more comfortable using SQL/dbt for data modeling, or are you looking for a visual UI for non-technical users?

I can map out a suggested modular toolchain for your exact setup.

Yes. What you’re describing is generally called a composable CDP or, if you want the warehouse to own even more of the CDP logic, a warehouse-native CDP.

The key architectural difference is:

Traditional CDP: data → vendor's database → identity/audiences → activation Composable CDP: data → your warehouse → identity/models/audiences → activation The latter makes your warehouse the system of record rather than maintaining a second proprietary customer database.

The main approaches

Vendors worth evaluating

hightouch.com is probably the clearest example of the composable-CDP model. It reads directly from Snowflake, BigQuery, Databricks, Redshift, etc., and provides audience building, identity resolution and activation without maintaining a separate copy of the warehouse data.

rudderstack.com is particularly interesting if you want to own the data collection/infrastructure layer as well. Its warehouse-native architecture puts event collection, identity resolution, profiles and activation around the warehouse, rather than treating the warehouse as merely an export destination.

There is also a useful distinction between them: Hightouch is more activation/marketing-oriented, whereas RudderStack is more data-infrastructure-oriented. Both can operate against your existing data infrastructure rather than making a vendor database your source of truth.

What I'd build if "we own the data" is the priority

I'd aim for something like:

                         YOUR DATA PLANE
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  Product / Web / Mobile / CRM / Billing / Support / etc.   │
│                         │                                   │
│                         ▼                                   │
│              Collection + schema governance                │
│                         │                                   │
│                         ▼                                   │
│              ┌────────────────────────┐                     │
│              │ Your warehouse/lake    │                     │
│              │                        │                     │
│              │ raw events             │                     │
│              │ identity graph         │                     │
│              │ customer 360           │                     │
│              │ traits/features        │                     │
│              │ audiences              │                     │
│              └───────────┬────────────┘                     │
│                          │                                  │
└──────────────────────────┼──────────────────────────────────┘
                           │
                 activation / APIs / sync
                           │
          ┌────────────────┼────────────────┐
          ▼                ▼                ▼
       CRM            Marketing         Product
      Salesforce       Braze/etc.       experiences
          │                │                │
          └────────────────┼────────────────┘
                           ▼
                     measurement
                    back in warehouse

The important principle is that identity, customer definitions, segmentation and business logic remain yours. The external platform is an execution layer, not the owner of your customer graph.

That also gives you a much better answer to questions like "Why is this customer in this audience?" because the underlying logic can live in SQL/dbt/code and be version-controlled rather than hidden inside a CDP. Warehouse-native architectures explicitly emphasize this inspectable/versioned model.

One caveat

"Composable" is becoming a marketing term, so I'd scrutinize vendors that claim it. The critical question isn't "Does it connect to our warehouse?" but:

"Does the vendor create and maintain a competing copy of our customer data and identity graph?"

If the answer is yes, it's closer to a traditional/warehouse-syncing CDP. If your warehouse remains the canonical store and the vendor operates primarily as collection, computation, orchestration or activation infrastructure, you're much closer to what you're looking for.

If you tell me whether you're on Snowflake, Databricks, BigQuery, Redshift, or something else, I can map out a concrete unbundled stack—including ingestion, identity resolution, dbt/modeling, reverse ETL, real-time activation, and what I'd not buy.

Yes, absolutely . This exact approach is widely known as a Composable CDP (or an unbundled/warehouse-native CDP).

Instead of forcing your customer data into a separate, expensive vendor "black box," a composable CDP treats your existing cloud data warehouse (like Snowflake, BigQuery, or Databricks) as the single source of truth and the core database for your customer profiles.

How the Composable Stack Works

An unbundled CDP relies on a modular, "best-of-breed" architecture split into distinct layers:

• Storage & Compute Layer (Your Warehouse): Snowflake, Google BigQuery, or Databricks acts as your permanent customer database, holding all raw events, traits, and historical data.
• Identity Resolution & Modeling: Tools built directly in SQL or dbt (data build tool) handle stitching anonymous and known user sessions together.
• Activation / Reverse ETL Layer: Tools like Hightouch or Census sync those unified SQL customer traits and segments out of your warehouse and into your operational tools (CRMs, ad platforms, email tools).
• Collection / Ingestion Layer: Lightweight trackers (like RudderStack or PostHog) pipe event data straight into your warehouse rather than routing it through a proprietary server.

Core Benefits vs. Monolithic CDPs

• Data Ownership & Privacy: Your data never leaves your infrastructure until it is explicitly synced to an outbound destination. PII boundaries remain completely under your control.
• No Vendor Lock-in: Because the stack is modular, you can swap out a Reverse ETL tool or an event collector down the road without losing your historical customer data or rebuilding a monolithic profile.
• Cost Efficiency: You aren't paying a traditional CDP vendor a massive markup to store duplicate data in their proprietary database. You leverage the warehouse storage you are already paying for.

If you want to explore this further, let me know:

• Which cloud data warehouse you are currently using (Snowflake, BigQuery, etc.)
• Whether your team already uses dbt for data modeling
• What key tools (like Salesforce, Klaviyo, or Meta Ads) you need to sync data back into

I can outline a reference architecture tailored to your tech stack.

Yes. What you’re describing is usually called a composable CDP or warehouse-native CDP: instead of buying a CDP that becomes a second system of record, you make your existing warehouse/lakehouse the customer-data system of record and layer modular capabilities on top.

A useful mental model is:

Sources → your warehouse → identity/modeling/audiences → activation

rather than:

Sources → vendor CDP → duplicate customer database → warehouse + downstream tools

The main approaches

Hightouch is probably the closest match to your phrase "unbundled CDP." Its current product explicitly describes itself as a composable CDP that doesn't copy your data into a separate system; identity, audiences, and activation operate against your existing warehouse.

RudderStack is interesting if you want to replace more of the traditional CDP stack: collection → governance → identity/profile → activation, while keeping the warehouse authoritative.

Snowplow is particularly compelling if behavioral event collection and first-party data ownership are central. Its composable approach explicitly supports collecting into your own warehouse and then using reverse ETL or native data-platform services for activation.

What I'd recommend architecturally

If you already have Snowflake/BigQuery/Databricks/Redshift, I'd resist buying another "customer database." Instead, make these separable layers:

1. Collection — web/mobile/server events into your warehouse.
2. Identity — your rules for stitching anonymous IDs, accounts, users, households, etc.
3. Customer model — dbt/SQL models producing canonical customer/profile tables.
4. Audiences — SQL-defined segments or a marketer-facing audience builder.
5. Activation — reverse ETL/streaming into Salesforce, Braze, ads, email, personalization, etc.
6. Real-time layer, if needed — only for use cases where warehouse latency isn't sufficient.

The important architectural principle is that your warehouse contains the canonical data and logic. The CDP vendor should ideally be an execution/UI layer, not the place where your customer history and identity graph secretly live. That's the key distinction between warehouse-native and merely "warehouse-integrated" CDPs.

So, yes: you can absolutely have a CDP without accepting the traditional CDP black box. If you tell me whether you're on Snowflake, BigQuery, Databricks, or Redshift and whether your priority is marketing activation, product personalization, or customer 360, I can map out a concrete composable stack and the pieces I'd buy vs. build.

Yes, the Composable CDP (also known as a warehouse-native or unbundled CDP) is specifically built for this exact architecture . Instead of forcing you to copy and store your customer data in a separate vendor-owned silo , a composable CDP treats your existing cloud data warehouse (like Snowflake, Google BigQuery, or Amazon Redshift) or data lakehouse as the single source of truth and system of record . The software layers on top to handle identity resolution, audience building, and activation (Reverse ETL) without duplicating storage.

Core Components of a Composable CDP Stack

• Storage & Modeling Layer: Your existing cloud data warehouse or Databricks Lakehouse where SQL, dbt, or data pipelines organize your unified customer and event data.
• Ingestion Layer: Tools like RudderStack or Segment Connections that stream clickstream and event data directly into your warehouse instead of locking it into a proprietary cloud.
• Audience & Activation Layer (Reverse ETL): Platforms like Hightouch or ActionIQ that provide a marketer-friendly, no-code UI to query your warehouse data, build dynamic segments, and sync them to downstream tools (ad networks, CRMs, email platforms).

Key Benefits over Traditional Monolithic CDPs

• Data Ownership & Compliance: Customer data never leaves your secure cloud perimeter for storage, making GDPR, CCPA, and HIPAA compliance significantly easier to audit and enforce.
• Cost Efficiency: You avoid the "bundling tax" and duplicate storage fees charged by monolithic SaaS tools, paying only for the modular activation and sync components you actually use.
• No Vendor Lock-in: Because schemas and data models live natively in your warehouse, you can swap out ingestion or activation tools at will without breaking your historical data foundation.

If you'd like to narrow this down, let me know:

• What cloud data warehouse are you currently using?
• Are you looking for a tool that handles both event ingestion and activation , or just the Reverse ETL/activation layer on top of what you already collect?

Yes. What you’re describing is generally called a composable CDP or warehouse-native CDP. The key architectural idea is: your warehouse remains the system of record; the CDP is a set of capabilities layered on top rather than a proprietary customer-data database.

A typical setup looks like:

Product / app / CRM / billing / support
              │
              ▼
        ┌─────────────┐
        │   Warehouse  │  ← canonical customer data
        │ Snowflake /  │
        │ BigQuery /   │
        │ Databricks   │
        └──────┬──────┘
               │
       ┌───────┼────────┐
       ▼       ▼        ▼
   Identity  Audiences  Features
   / 360     / segments / scoring
       │       │        │
       └───────┼────────┘
               ▼
       Activation layer
   CRM / email / ads / support

The important distinction is that a conventional CDP copies your data into its own database and maintains its own identity graph and customer model. In a composable architecture, those models can live in your warehouse and be implemented with SQL/dbt/code, while activation tools read the resulting tables.

The main approaches I'd look at

RudderStack is particularly interesting if by “own our infrastructure” you mean we want engineering to control the pipelines and identity model. Its current architecture explicitly supports using your existing warehouse/data infrastructure rather than a separate managed customer-data store.

Hightouch is more compelling if the problem is “our marketing team needs to actually use all the customer data we've already modeled.” It sits on Snowflake, Databricks, BigQuery, Redshift, etc., and focuses heavily on audience building and activation.

One important caveat

I wouldn't equate composable CDP = reverse ETL.

Reverse ETL solves the activation part:

“Take this warehouse table and put these customers into Salesforce/Braze/Google Ads.”

A complete CDP architecture still needs to address collection, identity resolution, customer modeling, segmentation, governance, and potentially real-time event delivery. Reverse ETL by itself doesn't solve those problems.

So if your goal is maximum ownership, I'd actually evaluate the architecture capability-by-capability rather than buying something called a “CDP”:

Warehouse → modeling/identity → audience layer → activation → real-time event path

That gives you much less vendor lock-in while still letting you buy the pieces that aren't worth building.

If you tell me whether you're on Snowflake, BigQuery, Databricks, or something else, and roughly whether you're B2B or B2C, I can sketch a concrete composable-CDP stack and compare the tradeoffs between building it yourself, RudderStack, Hightouch, Census, and Treasure AI.

Yes, this exact architecture is known as a Composable CDP (or warehouse-native CDP). Instead of forcing you to copy and store your customer data inside a separate vendor-locked SaaS silo, a composable approach treats your existing cloud data warehouse (like Snowflake, Google BigQuery , or Amazon Redshift ) as the single source of truth. It unbundles the traditional monolithic CDP into modular layers—using your warehouse for storage and modeling, and lightweight tools only for ingestion, audience building, and activation.

The Composable CDP Architecture

• Collection: Ingesting event and behavioral data using lightweight trackers or pipeline tools directly into your warehouse instead of a proprietary cloud.
• Modeling & Identity: Performing transformations and stitching customer identities using SQL or modeling frameworks like dbt right where your data lives.
• Activation: Using Reverse ETL tools to sync targeted segments and profiles from your warehouse out to marketing, sales, and ad destinations.

Leading Composable CDP Components

• Hightouch : A pioneer in the warehouse-native space providing no-code audience builders, identity resolution, and Reverse ETL directly on your infrastructure.
• ActionIQ : Offers enterprise-grade audience segmentation and a hybrid compute layer that queries your warehouse without forcing data replication.
• Census : A popular Reverse ETL and activation platform built to turn your warehouse into a operational system of record.
• Databricks CustomerLake : An approach that brings marketing intelligence, AI agents, and activation directly into the data lakehouse environment.

If you're looking to map this out, tell me:

• What cloud data warehouse are you currently using?
• Are your marketing teams looking for a no-code audience builder , or will data engineers handle the segmentation via SQL/dbt?

I can help outline a blueprint for your specific stack.

Yes. The category you’re describing is usually called a composable CDP or warehouse-native CDP.

The key architectural idea is: your warehouse/lakehouse remains the system of record; the CDP is a set of capabilities layered on top rather than another database you have to surrender your customer data to.

genui{"data_networks_databases":{"type_id":"SQL_JOIN","locale_override":"en-US"}}

The basic architecture

Apps / Web / CRM / Billing / Support
              │
              ▼
       Ingestion / events
              │
              ▼
     YOUR WAREHOUSE / LAKEHOUSE
       ┌─────────────────────┐
       │ raw events          │
       │ customer identities  │
       │ dbt/models           │
       │ traits/features      │
       │ audiences            │
       └─────────────────────┘
              │
        ┌─────┴──────┐
        ▼            ▼
   Audience /    Real-time
   activation    personalization
        │            │
        ▼            ▼
 CRM / Email / Ads / Product / Support

That gets you much closer to "own the infrastructure, outsource the plumbing" than a traditional CDP.

The main options

Hightouch explicitly describes its Composable CDP as activating directly from Snowflake, Databricks, BigQuery or Redshift rather than maintaining a separate data copy. www.rudderstack.comhightouch.com RudderStack takes the broader warehouse-native approach, covering collection, identity/profile modeling and activation.

Where I'd draw the line

If by "own our data infrastructure" you mean:

• customer data physically lives in your Snowflake/Databricks/BigQuery/etc.
• customer 360 is represented by tables/models you control
• identity rules are inspectable and version-controlled
• audiences are SQL/data-model concepts rather than proprietary CDP segments
• downstream systems receive projections of those models
• you can replace the CDP vendor without migrating your customer database

…then warehouse-native/composable is exactly the architecture I'd investigate.

The important distinction is that merely having a CDP export data to your warehouse isn't enough. A warehouse-syncing CDP can still have its own proprietary identity graph and customer database. In the genuinely warehouse-native model, the warehouse is authoritative and the vendor is providing capabilities around it.

The interesting design question

I wouldn't start with "Which CDP should we buy?"

I'd decompose the CDP into:

1. Collection — getting behavioral events into your infrastructure
2. Identity resolution — determining that anonymous_id, email, account ID, device ID, etc. represent the same entity
3. Customer 360 / modeling — traits, LTV, engagement, product usage, propensity scores, etc.
4. Audience computation — "customers eligible for X"
5. Activation — getting those audiences/traits into Salesforce, Braze, Meta, Google, your product, etc.
6. Real-time serving — if you need sub-second decisions/personalization
7. Governance — consent, PII controls, lineage and deletion

Then decide which of those you want to own versus buy.

That's where the composable approach gets particularly attractive: you can keep #2–4 in your warehouse/dbt layer, for example, while buying #1 and #5–6 as infrastructure services.

If you tell me your current stack (e.g. Snowflake + dbt + Fivetran + Segment + Braze/Salesforce), I can map out a concrete "unbundled CDP" architecture, including what I'd keep, replace, and build.

Yes, this is known as a Composable CDP (or sometimes a warehouse-native CDP or unbundled CDP).

Instead of forcing you to pipe customer data into a separate, proprietary black-box database, a composable CDP uses your existing cloud data warehouse (like Snowflake, BigQuery, Redshift, or Databricks) as the single source of truth and the persistent storage layer.

A typical composable CDP breaks down the traditional monolithic CDP into four distinct, modular layers:

• Storage Layer: Your existing cloud data warehouse acts as the centralized customer data store, ensuring zero data duplication.
• Ingestion & Transformation Layer: Tools like Fivetran or Airbyte ingest event/SaaS data into the warehouse, and dbt (data build tool) is used to model customer traits and handle identity resolution using SQL.
• Audience / Segmentation Layer: A no-code visual interface built for growth and marketing teams (such as Hightouch Customer Studio, Census , or GrowthLoop ) sits on top of your warehouse, letting non-technical users build segments without writing raw SQL.
• Activation Layer: Reverse ETL tools sync those computed audiences and user traits directly from your warehouse tables to downstream destinations like CRMs (Salesforce, HubSpot) and ad platforms (Google Ads, Meta).

If you'd like to explore this further, let me know:

• What cloud data warehouse are you currently using?
• Who will be the primary day-to-day users of the platform (data engineers vs. marketing teams)?

I can help you map out a specific toolchain or evaluate the trade-offs for your stack.