Somewhere in your CDP right now, there’s a customer who exists three times.
She browsed your site anonymously from her phone last week. She bought something in-store two days later using a personal email address. This morning, she opened a loyalty newsletter on her work laptop. To her, this was a typical week of being your customer. To your CDP, it may well be three different people. That means three separate profiles, three separate histories, and three separate chances to send her a redundant or contradictory message.
That gap, between how customers actually behave and what a CDP is able to see, is what identity resolution exists to close. It’s also, in our experience working alongside CDP teams, the most consistently underestimated part of standing up a customer data platform. Companies budget seriously for the CDP itself. They rarely budget with the same seriousness for the identity layer underneath it.
Why native CDP matching quietly falls short (and how to fix this)
It’s a reasonable assumption: you’ve bought a serious CDP (e.g., Adobe, Tealium, Twilio Segment, whichever fits your stack) so identity resolution should already be handled. And it is, to a point. Most CDPs are solid at deterministic matching: if two records share an exact identifier, such as the same email address, the same account ID, or same hashed phone number, the platform links them with justified confidence.
The trouble is how rarely real customers hand you an exact match. A shopper might browse your site anonymously on mobile, then check out in-store with a personal email address that’s never touched your website, then later open a marketing email on a work account. None of those three identifiers overlap. A CDP running on deterministic logic alone has no basis for treating them as the same person, so it won’t.
That’s not a flaw specific to any vendor. It’s a structural limit of deterministic-only matching: it can only resolve identities it’s explicitly handed a match for. Anything a customer does that doesn’t produce a shared identifier stays fragmented, no matter how capable the rest of the platform is.
Closing that gap is exactly the problem an identity resolution layer is built to solve. FullContact provides the foundational infrastructure layer that native CDPs lack. By integrating FullContact’s proprietary Identity Graph with your CDP, you bridge the gap between anonymous web traffic and deep person-level intelligence.
Our graph processes billions of independent, cross-channel data points, meaning that when a fragmented or partial identifier enters your CDP, FullContact resolves the identity, deduplicates the record, and maps it back to a single, persistent human profile in real time.
Deterministic and probabilistic matching, working together
Closing that gap takes a second method alongside deterministic logic: probabilistic matching. Instead of confirming a direct match, probabilistic matching estimates that two interactions belong to the same person based on patterns like device signals, IP and location overlap, and timing.
Deterministic matching is precise but narrow. Probabilistic matching is broader, but it’s inherently a matter of confidence rather than certainty. Used together, they cover far more customer behavior than either method could alone. Deterministic matches form the reliable core of a profile, while probabilistic matching extends that core to recognize the same person showing up on a new device or browser.
It’s worth being direct about something vendors don’t always volunteer: even deterministic matches aren’t infallible. Shared family email addresses, reassigned phone numbers, and ordinary data-entry typos can all produce a “confirmed” match that’s wrong. Good identity resolution treats deterministic matching as high-confidence, not error-proof, and builds in ways to catch and correct bad merges rather than just make them.
Why real-time matters more than it used to
A resolved identity that only updates once a week isn’t much better than no resolution at all. If your CDP reconciles identities in an overnight batch job, a customer who browses today and buys tomorrow may not get recognized as the same person until the batch runs, which is well after the moment where a relevant recommendation or a well-timed offer would have mattered.
Identity resolution increasingly needs to happen close to real time, as data arrives rather than on a schedule, so a CDP’s audience segments and next-best-action logic are working from a customer’s current state instead of last week’s.
When a user lands on your digital property, FullContact’s cloud-based APIs resolve and enrich their profile in under 150 milliseconds. This ultra-low latency means that your CDP can update its audience segments instantly, triggering hyper-relevant product recommendations, tailored ad-copy, or dynamic website modifications while the user is actively engaged.
This matters even more for the AI layer many CDPs now build on top of unified profiles: churn models, propensity scores, next-best-action recommendations. Those models are only as good as the data feeding them. A churn model trained on fragmented, duplicated profiles isn’t a slightly-worse churn model. It’s a frequently wrong model, because it’s learning from one customer’s history split across records that don’t know about each other.
The business case here is well established for personalization generally, even if it’s rarely quantified for identity resolution specifically. McKinsey’s research has found that companies with faster growth rates draw 40% more of their revenue from personalization than slower-growing peers (McKinsey, 2021). Personalization at that level of accuracy depends on knowing, correctly, that the person browsing today is the same person who bought last month. This is exactly the problem identity resolution is solving underneath it.
Privacy has to be part of the identity layer, not bolted on after
None of this holds up if it comes at the expense of consent. Building unified profiles across devices and channels only works if every one of those profiles respects what the customer actually agreed to.
Consent needs to travel with the identity, not sit behind it. If a customer opts out or requests deletion on one device, that preference should apply across every record resolved to their profile, not just the channel where they clicked “unsubscribe.” And the lineage connecting matched records needs to stay auditable, so your team can actually explain and honor a data subject access request rather than reconstructing one after the fact under time pressure.
FullContact integrates data minimization principles and privacy-aware data processing into every single graph query:
- Consent Synchronization: Real-time graph propagation ensures privacy updates automatically apply across all connected records instantly.
- Secure Data Hashing: Sensitive identifiers are protected using advanced cryptographic hashing methods both in transit and at rest, ensuring full compliance without sacrificing data utility.
- Transparent Governance: By maintaining clean, auditable lineages of how data points are linked, enterprises can confidently honor data subject access requests (DSARs) without friction.
None of this replaces your own legal review of GDPR, CCPA, or whatever else applies to your business. That’s still on you and your counsel. But an identity resolution layer that treats consent as a first-class part of the graph, rather than a downstream filter applied after the fact, makes that compliance work considerably less painful.
CDPs and CRMs are solving different problems
The two get conflated constantly.
A CRM, such as Salesforce, is built around known, structured relationships: contacts, accounts, deals, support tickets, sales stages. It’s excellent at tracking what happens once someone is already a named record in your system, and largely blind to anonymous or cross-device behavior before that point.
A CDP is built to ingest messy, high-volume data: web behavior, transactions, and app usage from both known and anonymous users across every channel. Identity resolution turns that chaotic stream into what a CRM’s rigid structure was never designed to produce: a single, real-time view of each customer across every touchpoint, going far beyond explicitly logged interactions.
The two aren’t competitors. In most real stacks, an identity resolution layer like FullContact is what makes the CDP a trustworthy upstream source for the CRM to draw from, instead of the two systems each maintaining a separate, half-true version of the same customer.
A few things worth asking before you commit to an approach
Does identity resolution replace my CDP, or work alongside it?
Alongside it. Identity resolution is the layer that decides which records belong to the same person; the CDP is what activates that unified profile into segments, campaigns, and models. Most enterprise CDPs handle basic deterministic matching natively and lean on a dedicated identity resolution layer like FullContact for everything probabilistic and offline.
What does integrating this actually involve?
Typically an API-based connection between your CDP and the identity resolution provider, so records get resolved as they’re ingested rather than in a separate batch step. The heavier lift is usually organizational, not technical. For instance, auditing what identifiers you’re actually collecting today and where the real gaps are.
How does this affect consent and opt-outs in practice?
A well-built identity graph propagates an opt-out across every record tied to that person, not just the channel where they opted out. You should ask vendors to walk you through exactly how that propagation works before you buy.
Is this only worth doing at enterprise scale?
Fragmentation shows up earlier than most teams expect. Even a mid-sized company running a website, an app, and in-store point of sale is already generating three identifier streams that don’t talk to each other by default.
Where this leaves you
Fixing this doesn’t require ripping out your CDP or starting over. It just requires an identity layer built for how real people actually behave: switching devices, using multiple email addresses, and shifting unpredictably between anonymous and known states.
If you’re trying to figure out where your own fragmentation is worst, and what closing that gap would actually take, that’s a conversation worth having with people who work in this layer every day. FullContact’s identity resolution team spends most of its time exactly there, and is glad to look at your specific CDP setup and tailor a solution for your business.
