Third-Party and SaaS Integration Questions

Approach
I would resolve identities with a layered matching strategy. Identity resolution means deciding which records refer to the same person. I would use deterministic rules first, then probabilistic rules when the evidence is weaker.

Trust and merge rules

• Treat login-linked identifiers such as verified email or account ID as high trust.
• Treat anonymous cookies as temporary and link them only after a login or strong correlation.
• Prefer source systems that own the data, for example the billing system for account status.
• Keep conflicting attributes as separate fields with lineage when the source is uncertain.

Example
A browser cookie c123 later logs in as jane@example.com and maps to account A77. I would merge those into one person profile because the login creates a strong bridge. If another record also uses jane@example.com but has a different customer since 2021, I would not auto-merge until I verify whether it is a shared inbox or a duplicate account.

Decision rule
Merge when confidence is high and the identifiers form a clear chain. Keep separate when the match could create a false positive, because over-merging is harder to undo than under-merging.

Strategy
I would define a single source of truth per data domain, not one for everything. Source of truth means the system that is allowed to make the final decision for a field. For consent and preferences, I would usually pick one authoritative consent service and make the others read-through or replica systems.

Conflict resolution rules

• Prefer the authoritative system for that field, such as the compliance tool for consent.
• Use timestamps only within the same trust tier, not across all systems blindly.
• If two updates conflict and neither clearly wins, keep the last known safe state and queue manual review.
• Store source, timestamp, and reason so every decision is auditable.

Example
If the website records email opt-out at 10:01 and the CRM sends an older preference snapshot at 10:05, I would still keep the opt-out because the website is the higher-trust source for user actions and the CRM update is likely stale.

Practical rule
For each field, I would document who can write, who can read, and how conflicts resolve. That prevents every team from claiming ownership and makes outages much easier to recover from.

Trace the issue
I would trace the record at each hop using a correlation ID, which is a unique identifier carried through logs and events. Then I would compare counts at every boundary: source emitted, ingestion received, transform accepted, warehouse loaded, report queried.

What I would inspect

• Structured logs for dropped records or filter rules
• Traces for latency spikes or retries
• Checkpoints or offsets in the queue or stream
• Destination row counts and partition counts
• Quarantine tables for records rejected by validation

Example
If the source sent 1,000 records, ingestion received 1,000, and the warehouse loaded 998, the problem is likely in transformation or load. If the warehouse has 1,000 but the report shows 998, the issue is probably the report filter, not the pipeline.

Automated validation
I would add contract tests for payload shape, replay tests against saved real events, and synthetic canary records that must appear end to end. I would also alert on count drift, not just on API errors, because a healthy API can still lose business data silently.

Design
I would insert an anti-corruption layer between the vendor and the rest of the stack. That means the integration layer translates vendor payloads into a stable internal contract, and the downstream systems only see the internal shape.

Components

• Vendor adapter for each API or webhook version
• Canonical schema with versioning
• Transformer service that maps vendor fields to internal fields
• Contract tests that verify each adapter against sample payloads
• Replay pipeline so old events can be reprocessed through the new adapter

Example
If the vendor changes email_address to primary_email, only the adapter changes. Downstream systems still receive email. If the vendor adds a new field, I can ignore it until a consumer needs it, which avoids a cascade of changes.

How this prevents repeat pain
I would document field ownership, use schema validation at the edge, and run a parallel test environment before cutover. Then when the next vendor change arrives, the blast radius stays inside one adapter instead of spreading across every consumer.

Decision factors
I would compare three options against four needs: speed to launch, complexity, maintainability, and latency. A native connector is simplest when the CRM and marketing tool already support the fields and schedule you need. An integration platform is good when you want faster setup, monitoring, and moderate customization. A custom API integration fits when rules are unique, scale is high, or data freshness matters.

Example
If the team only needs a nightly sync of name, email, and campaign status, a native connector is usually enough. If they later need updates within 5 minutes when a lead converts, I would move toward an API-based or event-driven design, because batch sync may be too slow.

My rule
Start with the least complex option that still meets the business need. If near-real-time updates become required, I would favor a design with webhooks or APIs plus retries and monitoring, because it gives better control over freshness and failure handling than a purely batch connector.