How to Prevent Duplicate Records with Proper Field Mapping?

Before creating new record:
1. Check if Email already exists in CRM
2. If exists → Update existing record with new First Name/Last Name (if changed)
3. If not exists → Create new record

Prevents duplicates: Yes (email-based matching)

Company mapping logic:
1. Search CRM for Company where Name = [Company_Name from source]
2. If match found → Associate contact with existing company
3. If no match found → Create new company with Name = [Company_Name]
4. Associate contact with company (new or existing)

Fuzzy matching option:
- Search for company where Name is 85%+ similar (accounts for "Acme Corp" vs "Acme Corporation")
- If fuzzy match found → Prompt for confirmation or auto-match based on threshold

Before creating contact:
1. Check if Email exists in CRM
2. If exists → Update contact fields + verify company association
3. If not exists → Create contact + associate with company (matched or created)

Before creating company:
1. Check if Company Name exists (exact or fuzzy match)
2. If exists → Use existing company record
3. If not exists → Create new company record

Prevents duplicates: Yes (email for contacts, name matching for companies)

Full Name = [FirstName] + " " + [LastName]

Example:
FirstName: "John"
LastName: "Smith"
Full Name: "John Smith"

Parse Full Name:
1. Split on first space: "John Smith" → ["John", "Smith"]
2. First element → First Name: "John"
3. Remaining elements joined → Last Name: "Smith"

Edge cases:
- "John Robert Smith" → First: "John", Last: "Robert Smith"
- "Mary" (no last name) → First: "Mary", Last: "" (empty)
- "Dr. John Smith Jr." → Needs more complex parsing

Before creating record:
1. Parse Full Name into First Name + Last Name
2. Check if Email exists in CRM
3. If exists → Update First Name + Last Name on existing record
4. If not exists → Create new record

Prevents duplicates: Yes (email still serves as unique identifier)

Enrichment workflow:
1. Identify contact by email (existing record required)
2. Identify associated company via contact's company lookup
3. Update company fields with enrichment data
4. DO NOT create new contact if email doesn't exist
5. DO NOT create new company if not associated

Critical: Enrichment runs on existing data only

Prevents duplicates: Yes (only updates, never creates)

IF source_form = "Enterprise Lead Form":
  Map to Contact with Lifecycle Stage = "Sales Qualified Lead"
  Require Company association (lookup required)
  Map all extended fields (title, department, phone, etc.)
  
ELSE IF source_form = "Newsletter Signup":
  Map to Contact with Lifecycle Stage = "Subscriber"
  Company association optional
  Map only email + name (skip extended fields)
  
ELSE IF source_form = "Event Registration":
  Map to Contact with Lifecycle Stage = "Lead"
  Create associated Event Attendance record
  Map event-specific fields to custom object

Enterprise Lead deduplication:
1. Match by email
2. If exists with Lifecycle Stage < "Sales Qualified Lead" → Upgrade stage
3. If exists with Lifecycle Stage >= "Sales Qualified Lead" → Update details only
4. Enforce company match (don't create contact without valid company)

Newsletter deduplication:
1. Match by email
2. If exists → Set newsletter opt-in flag, don't overwrite lifecycle stage
3. If not exists → Create with minimal data
4. Don't require company (B2C audience)

Event Registration deduplication:
1. Match by email
2. If exists → Create Event Attendance record linked to existing contact
3. If not exists → Create contact + Event Attendance record
4. Multiple event registrations link to same contact (prevents duplicates)

Exact match logic:
1. Normalize source company name (trim whitespace, title case)
2. Query: SELECT * FROM companies WHERE LOWER(name) = LOWER([source_name])
3. If single match found → Use that company
4. If zero or multiple matches → Proceed to Tier 2

Example:
Source: "Acme Corporation"
CRM: "Acme Corporation"
Result: MATCH (exact)

Source: "Acme Corp"
CRM: "Acme Corporation"
Result: NO MATCH (proceed to Tier 2)

Normalized match logic:
1. Remove entity types: Inc, Inc., Corp, Corp., LLC, Ltd, Limited, Company, Co
2. Remove leading "The"
3. Remove extra spaces and punctuation
4. Query normalized form

Example:
Source: "Acme Corp."
Normalized: "Acme"
CRM: "Acme Corporation"
Normalized: "Acme"
Result: MATCH

Source: "The Home Depot Inc."
Normalized: "Home Depot"
CRM: "Home Depot"
Normalized: "Home Depot"
Result: MATCH

def normalize_company_name(name):
    # Remove entity types
    entity_types = ['Inc.', 'Inc', 'Corp.', 'Corp', 'LLC', 'Ltd', 
                   'Limited', 'Company', 'Co.', 'Co', 'Corporation']
    
    normalized = name
    for entity_type in entity_types:
        normalized = normalized.replace(f' {entity_type}', '')
    
    # Remove leading "The"
    if normalized.startswith('The '):
        normalized = normalized[4:]
    
    # Remove extra whitespace and punctuation
    normalized = normalized.strip()
    normalized = ' '.join(normalized.split())  # Collapse multiple spaces
    
    return normalized

# Examples:
normalize_company_name("Acme Corporation") → "Acme"
normalize_company_name("The Home Depot Inc.") → "Home Depot"
normalize_company_name("International Business Machines Corp") → "International Business Machines"
```

**Tier 3: Fuzzy Match (String Similarity)**

Use string similarity algorithms for typos and variations:
```
Fuzzy match logic:
1. Calculate similarity score between source and each CRM company name
2. Use Levenshtein distance, Jaro-Winkler, or similar algorithm
3. If similarity > 85% threshold AND only one match → Use that company
4. If similarity > 85% AND multiple matches → Present for manual review
5. If similarity < 85% → Create new company

Example:
Source: "Acme Corpration" (typo)
CRM: "Acme Corporation"
Similarity: 94%
Result: MATCH (high similarity, likely same company)

Source: "Acme Industries"
CRM: "Acme Corporation"
Similarity: 72%
Result: NO MATCH (too different, likely different companies)

from difflib import SequenceMatcher

def similarity_score(str1, str2):
    """Calculate similarity between two strings (0-100%)"""
    return SequenceMatcher(None, str1.lower(), str2.lower()).ratio() * 100

def fuzzy_match_company(source_name, crm_companies, threshold=85):
    """Find best matching company using fuzzy string matching"""
    
    normalized_source = normalize_company_name(source_name)
    
    matches = []
    for crm_company in crm_companies:
        normalized_crm = normalize_company_name(crm_company['name'])
        score = similarity_score(normalized_source, normalized_crm)
        
        if score >= threshold:
            matches.append({
                'company': crm_company,
                'score': score
            })
    
    # Sort by score descending
    matches.sort(key=lambda x: x['score'], reverse=True)
    
    if len(matches) == 0:
        return None  # No match, create new company
    elif len(matches) == 1:
        return matches[0]['company']  # Single match, use it
    else:
        return matches  # Multiple matches, require manual review

# Example:
fuzzy_match_company("Acme Corpration", crm_companies)
→ Returns Acme Corporation (94% match)

fuzzy_match_company("Acme Industries", crm_companies)
→ Returns None (72% < 85% threshold, create new)
```

### Domain-Based Company Matching

Often more reliable than name matching:
```
Domain match logic:
1. Extract domain from contact email: john@acme.com → acme.com
2. Query companies WHERE website_domain = 'acme.com'
3. If single match found → Associate contact with that company
4. If zero matches → Proceed to name-based matching
5. If multiple matches → Use most recently updated

Example:
Contact email: john.smith@acme.com
Domain extracted: acme.com
CRM Company: "Acme Corporation" (website: acme.com)
Result: MATCH (domain-based, most reliable)

Benefit: Bypasses name variation issues entirely

import re

def extract_domain(email):
    """Extract domain from email address"""
    match = re.search(r'@([\w.-]+)', email)
    return match.group(1) if match else None

def match_company_by_domain(email, crm_companies):
    """Match company by email domain"""
    domain = extract_domain(email)
    
    if not domain:
        return None
    
    # Query CRM companies with matching domain
    for company in crm_companies:
        if company.get('website_domain') == domain:
            return company
    
    return None

# Example:
match_company_by_domain("john@acme.com", crm_companies)
→ Returns company with website_domain = "acme.com"
```

**Domain matching limitations:**

- Generic email domains: gmail.com, yahoo.com, hotmail.com (consumer emails, no company match)
- Shared domains: Multiple small companies using same email provider domain
- Subdomain variations: mail.acme.com vs acme.com
- Country-specific domains: acme.com vs acme.co.uk (same company, different domains)

**Solution:** Use domain matching as first attempt, fall back to name matching if domain match fails.

### The Hybrid Matching Approach

Combine all methods for maximum accuracy:
```
Hybrid company matching workflow:

Step 1: Domain Match (if email available)
  - Extract domain from email
  - Query companies by domain
  - If single match → DONE (99% confidence)
  - If no match → Continue to Step 2

Step 2: Exact Name Match
  - Query companies by exact name
  - If single match → DONE (95% confidence)
  - If no match → Continue to Step 3

Step 3: Normalized Name Match
  - Remove entity types, normalize spacing
  - Query companies by normalized name
  - If single match → DONE (90% confidence)
  - If no match → Continue to Step 4

Step 4: Fuzzy Name Match
  - Calculate similarity scores with all companies
  - If score > 90% AND single match → DONE (85% confidence)
  - If score > 85% AND multiple matches → Manual review queue
  - If score < 85% → Continue to Step 5

Step 5: Create New Company
  - No match found through any method
  - Create new company record
  - Flag for later review (possible duplicate requiring manual verification)
```

This multi-tier approach prevents false matches (accidentally merging different companies) while minimizing false negatives (creating duplicates of existing companies).

Implementing these algorithms alongside your [field naming standards](#) creates a robust duplicate prevention system.

---

## Import Field Mapping Best Practices

CSV imports are a major duplicate source when mapped incorrectly. Following your [field structure guidelines](#), proper import mapping prevents thousands of duplicates.

### Pre-Import Data Standardization

Clean data before mapping begins:

**Step 1: Validate required fields**
```
Required field checklist:
☑ Email column exists and contains valid email addresses
☑ Contact name columns (First Name + Last Name OR Full Name for splitting)
☑ Company name column (if B2B)
☐ Phone column (optional but recommended)

Validation query:
- Count rows with missing email: Should be 0%
- Count rows with invalid email format: Should be <1%
- Count rows with missing name: Should be 0%
```

**Step 2: Standardize formats**

Before import, clean data:
```
Email standardization:
- Convert to lowercase: "John@Acme.com" → "john@acme.com"
- Trim whitespace: " john@acme.com " → "john@acme.com"
- Remove duplicates within import file

Company standardization:
- Apply normalization: "Acme Corp." → "Acme"
- Title case: "ACME CORPORATION" → "Acme"
- Consolidate variations: Multiple rows for "Acme Corp", "Acme Corporation", "Acme" → Single "Acme"

Name standardization:
- Title case: "john smith" → "John Smith", "MARY JOHNSON" → "Mary Johnson"
- Split full names if needed: "John Smith" → "John" + "Smith"
```

**Step 3: Deduplicate import file**

Remove duplicates within the import file before uploading to CRM:
```
Deduplication within import file:
1. Sort by email
2. Identify rows with duplicate emails
3. Merge duplicate rows (keep most complete data)
4. Result: One row per unique email

Example:
Row 1: john@acme.com, John, Smith, Acme, VP Sales
Row 2: john@acme.com, John, Smith, , (missing company and title)

After merge:
Row: john@acme.com, John, Smith, Acme, VP Sales (most complete)
```

This prevents importing 10,000 rows where 2,000 are duplicates within the file itself.

### Import Mapping Configuration

**Mapping approach 1: Use import wizard with field matching**

Most CRMs provide import wizards:
```
Import wizard steps:
1. Upload CSV file
2. Map columns to CRM fields:
   
   CSV Column         CRM Field              Notes
   ───────────────────────────────────────────────────────
   Email           → Email                  (Dedup key)
   First Name      → First Name             (Standard field)
   Last Name       → Last Name              (Standard field)
   Company         → Company (lookup)       (Match existing OR create new)
   Title           → Job Title              (Standard field)
   Phone           → Phone                  (Standard field)

3. Configure deduplication:
   ☑ Match on Email (update if exists, create if new)
   ☑ Match companies by name (with fuzzy matching)
   
4. Preview and validate
5. Execute import
```

**Mapping approach 2: Create data transformation template**

For recurring imports, create reusable template:
```
Template: Trade Show Lead Import

Source columns expected:
- Full Name
- Email
- Organization
- Job Title
- Booth Interaction

Transformation logic:
1. Split Full Name → First Name + Last Name
2. Map Email → Email (dedup key)
3. Match Organization → Company lookup
4. Map Job Title → Job Title
5. Map Booth Interaction → Lead Source = "Trade Show [Event Name]"
6. Set Lifecycle Stage = "Lead"
7. Set Lead Source Detail = Booth interaction notes

Saves 20-30 minutes per import by reusing configuration
```

### Handling Import Errors and Exceptions

Not all rows import successfully. Handle failures:

**Error type 1: Required field missing**
```
Row 547: Email is blank
Action: Skip row, log error
Resolution: Manually obtain email and create contact OR discard lead
```

**Error type 2: Invalid format**
```
Row 892: Email "john.smith" (missing @domain)
Action: Skip row, log error
Resolution: Correct email format and re-import
```

**Error type 3: Company match ambiguous**
```
Row 1034: Company "ABC" matches 3 companies (ABC Corp, ABC Industries, ABC Services)
Action: Queue for manual review
Resolution: User selects correct company from options
```

**Error type 4: Duplicate within import**
```
Row 245: john@acme.com
Row 678: john@acme.com (duplicate of row 245)
Action: Merge rows before import (keep most complete)
Resolution: Import single merged row
```

**Import error report:**
```
Import Summary:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total rows in file: 5,000
Successfully imported: 4,687 (93.7%)
Skipped (errors): 313 (6.3%)

Error breakdown:
- Missing email: 145 rows
- Invalid email format: 82 rows
- Ambiguous company match: 54 rows
- Duplicate within file: 32 rows

Action required:
- Review error log: errors_2024_02_24.csv
- Correct errors and re-import failed rows
```

This transparency allows fixing issues without corrupting CRM with bad data.

---

## Integration Field Mapping Patterns

Integrations sync data continuously, so mapping errors multiply over time.

### Bi-Directional Sync Field Mapping

When two systems sync in both directions, field mapping must prevent infinite loops:

**Scenario: CRM ↔ Marketing Automation Sync**

**Challenge:** 
- Contact created in CRM → Syncs to Marketing Automation
- Marketing Automation enriches contact → Syncs back to CRM
- CRM sees "update" → Syncs back to Marketing Automation
- Loop continues infinitely

**Solution: Field-level sync direction control**
```
Field sync configuration:

Field              CRM → MA    MA → CRM    Reasoning
─────────────────────────────────────────────────────────────
Email              ✓           ✗           CRM is master for contact info
First Name         ✓           ✗           CRM is master
Last Name          ✓           ✗           CRM is master
Lifecycle Stage    ✗           ✓           MA is master (tracks engagement)
Lead Score         ✗           ✓           MA calculates score
Email Opt-In       ↔           ↔           Bi-directional (changes in either)
Last Activity Date ✗           ✓           MA tracks email activity
Company            ✓           ✗           CRM is master for relationships
```

Legend:
- ✓ = One-way sync (master to slave)
- ✗ = No sync
- ↔ = Bi-directional sync

This prevents sync loops by establishing master system per field.

**Loop prevention timestamp strategy:**
```
Sync logic with timestamp checking:

Before syncing field:
1. Check last_modified_timestamp on both systems
2. If CRM timestamp > MA timestamp → Sync CRM → MA
3. If MA timestamp > CRM timestamp → Sync MA → CRM
4. If timestamps equal → No sync needed (already in sync)

Prevents: Syncing unchanged data and creating unnecessary update loops

// Webhook payload from webinar platform
{
  "attendee_email": "john@acme.com",
  "attendee_name": "John Smith",
  "company_name": "Acme Corporation",
  "webinar_title": "Product Demo - Jan 2025",
  "attended": true,
  "watch_duration_minutes": 42
}

// Field mapping logic
async function handleWebinarAttendance(webhookPayload) {
  
  // Step 1: Parse source data
  const email = webhookPayload.attendee_email.toLowerCase().trim();
  const fullName = webhookPayload.attendee_name;
  const [firstName, ...lastNameParts] = fullName.split(' ');
  const lastName = lastNameParts.join(' ');
  const companyName = webhookPayload.company_name;
  
  // Step 2: Find or create contact
  let contact = await findContactByEmail(email);
  
  if (!contact) {
    // Create new contact
    contact = await createContact({
      email: email,
      firstName: firstName,
      lastName: lastName,
      lifecycleStage: 'Lead',
      leadSource: 'Webinar'
    });
  }
  
  // Step 3: Find or create company
  let company = await findCompanyByName(companyName);
  
  if (!company) {
    company = await createCompany({
      name: normalizeCompanyName(companyName)
    });
  }
  
  // Step 4: Associate contact with company
  if (contact.companyId !== company.id) {
    await updateContact(contact.id, {
      companyId: company.id
    });
  }
  
  // Step 5: Create webinar attendance record
  await createActivity({
    contactId: contact.id,
    companyId: company.id,
    type: 'Webinar',
    subject: webhookPayload.webinar_title,
    completed: webhookPayload.attended,
    duration: webhookPayload.watch_duration_minutes,
    date: new Date()
  });
  
  // Step 6: Update engagement score
  await updateContact(contact.id, {
    engagementScore: contact.engagementScore + 10 // Bonus for webinar attendance
  });
}

async function handleWebinarAttendance(webhookPayload) {
  try {
    // Mapping logic here...
    
  } catch (error) {
    // Log error for debugging
    console.error('Webinar webhook processing failed:', {
      payload: webhookPayload,
      error: error.message,
      timestamp: new Date()
    });
    
    // Queue for retry
    await queueFailedWebhook(webhookPayload, error.message);
    
    // Alert admin if critical
    if (isCriticalError(error)) {
      await sendAlertEmail({
        subject: 'CRM Integration Error',
        body: `Webinar webhook failed: ${error.message}`
      });
    }
  }
}
```

Robust error handling prevents failed syncs from silently corrupting data.

---

> **✅ Best Practice: The "Test Integration with Duplicates" Rule**
> 
> Before enabling any integration in production, test with data containing intentional duplicates. Send the same contact through the integration 5 times and verify only 1 CRM record is created/updated. This catches mapping errors before they create thousands of duplicates in production.

---

## Field Mapping Audit and Monitoring

Field mapping isn't set-and-forget. Continuous monitoring catches mapping drift before it creates duplicate problems.

### The Monthly Mapping Audit

**Audit checklist:**
```
Monthly Field Mapping Audit - [Date]

WEB FORMS
☐ Contact form → Email field maps to standard Email field
☐ Contact form → Company maps to Company lookup (not text field)
☐ Contact form → Name parsing works correctly (First + Last)
☐ Duplicate detection enabled (email-based matching)
☐ Test submission: Verify no duplicate created

MARKETING AUTOMATION
☐ Email field bi-directional sync working
☐ Company association syncing correctly
☐ Lifecycle stage mapping matches expected values
☐ Lead score syncing without errors
☐ Check error logs for sync failures

CSV IMPORTS
☐ Latest import mapping template reviewed
☐ Import error rate <5%
☐ Company matching working (not creating duplicate companies)
☐ Required fields enforced

INTEGRATIONS (API)
☐ Webhook endpoints responding correctly
☐ Error rate <1% for API calls
☐ Retry logic functioning for failed syncs
☐ Object associations creating properly (contact → company)

DEDUPLICATION METRICS
☐ Duplicate rate: [Current %] (Target: <5%)
☐ New duplicates created this month: [Count]
☐ Source of duplicates identified: [Web form / Import / Integration]
☐ Corrective action taken: [Description]
```

**Audit frequency:**
- First 3 months after new integration: Weekly
- Months 4-12: Bi-weekly  
- After 12 months with <2% duplicate rate: Monthly

### Automated Mapping Health Monitoring

Set up automated alerts for mapping failures:

**Alert 1: Duplicate creation spike**
```
Trigger: New duplicate records > 50 per day
Alert: Email to CRM Admin + Sales Ops Manager
Message: "Duplicate creation spike detected. 127 duplicates created in last 24 hours. 
         Primary source: Web contact form. Review field mapping immediately."

Investigation: Check recent form submissions for mapping errors
```

**Alert 2: Required field population drop**
```
Trigger: Contacts created with blank Email field > 5%
Alert: Email to CRM Admin
Message: "Required field not populating. 15% of contacts created today have blank email. 
         Check web form to Email field mapping."

Investigation: Review form field mapping configuration
```

**Alert 3: Company association failure**
```
Trigger: Contacts created without company association > 20%
Alert: Email to CRM Admin
Message: "Company mapping failing. 34% of contacts created today lack company association.
         Company field may be mapping to text instead of lookup."

Investigation: Check company field mapping on all data sources
```

**Alert 4: Integration sync errors**
```
Trigger: API integration errors > 10 per hour
Alert: Slack notification to #crm-alerts channel
Message: "Marketing automation sync errors spiking. 23 errors in last hour.
         Check integration logs."

Investigation: Review API error logs for mapping-related failures
```

These automated alerts catch mapping problems within hours instead of discovering them months later during data quality audits.

### The Field Mapping Change Log

Maintain documentation of all mapping changes:
```
FIELD MAPPING CHANGE LOG

Date: 2024-02-24
Changed by: Sarah Johnson, CRM Administrator
Integration: HubSpot Marketing Automation → Salesforce CRM

Change:
BEFORE: HubSpot "Company" field → Salesforce "Company_Name__c" (custom text field)
AFTER: HubSpot "Company" field → Salesforce "Account" (standard lookup field)

Reason:
Previous mapping created text field instead of account association, causing duplicate companies
and preventing proper reporting on accounts.

Impact:
- Existing contacts: 12,400 contacts had company in text field
- Migration: Matched 89% to existing accounts, created 11% new accounts
- Future contacts: Will properly associate with account records

Testing:
- Test sync with 10 contacts: ✓ All properly associated with accounts
- Verified no duplicate accounts created: ✓ Passed
- Checked rollback procedure: ✓ Documented

Approved by: Mike Chen, VP Sales Operations
```

This change log enables:
- Understanding why mappings changed
- Troubleshooting issues introduced by changes
- Rollback if changes cause problems
- Knowledge transfer when admins change

Return to your [complete CRM architecture guide](#) to see how field mapping fits into overall system design.

---

## Field Mapping Anti-Patterns

Common mapping mistakes that guarantee duplicates:

### Anti-Pattern 1: The Text Field Shortcut

**What it looks like:**

Mapping all source fields to text fields rather than proper field types:
```
Source: Company name → CRM: Company_Name__c (text field)
Source: Email → CRM: Email_Address__c (text field)  
Source: Phone → CRM: Phone_Number__c (text field)
```

**Why it fails:**
- Bypasses CRM's built-in duplicate detection (which uses standard fields)
- Prevents relationship formation (no company object association)
- Breaks automation (workflows trigger on standard field updates)

**Fix:** Map to standard CRM fields:
```
Source: Company name → CRM: Account (standard lookup)
Source: Email → CRM: Email (standard email field)
Source: Phone → CRM: Phone (standard phone field)
```

### Anti-Pattern 2: The "Always Create New" Mode

**What it looks like:**

Integration configured to always create new records instead of checking for existing:
```
Integration setting: "Insert Only" (instead of "Upsert")

Result:
- Every sync creates new record
- Even if email already exists in CRM
- Duplicate count grows by 100-500+ daily
```

**Why it fails:**
- No deduplication logic
- Each source system event creates new CRM record
- Database fills with duplicates

**Fix:** Use upsert mode:
```
Integration setting: "Upsert" or "Update or Insert"
Match key: Email field
Logic: IF email exists → Update record, ELSE → Create new record

Result: One CRM record per unique email, regardless of sync frequency
```

### Anti-Pattern 3: The Case-Sensitive Matching

**What it looks like:**

Matching using case-sensitive comparison:
```
Source: john@acme.com
CRM: John@Acme.com
Match logic: john@acme.com == John@Acme.com → FALSE (case-sensitive)
Result: Creates duplicate (treats as different emails)
```

**Why it fails:**
- Email standards are case-insensitive (john@acme.com = John@Acme.com)
- Case-sensitive matching creates duplicates of same person
- Users don't consistently use same capitalization

**Fix:** Use case-insensitive matching:
```
Match logic: LOWER(source.email) == LOWER(crm.email)
Example: LOWER(john@acme.com) == LOWER(John@Acme.com) → TRUE
Result: Correctly identifies as same email, updates existing record
```

### Anti-Pattern 4: The Partial Email Matching

**What it looks like:**

Matching on partial email or email domain only:
```
Source: john.smith@acme.com
Match logic: CONTAINS(crm.email, 'acme.com')
Matches: john.smith@acme.com, jane.doe@acme.com, mike.wilson@acme.com (all match)
Result: Associates source contact with wrong existing contact
```

**Why it fails:**
- Domain matching catches multiple people at same company
- Updates wrong person's record with source data
- Creates data corruption (John Smith's data overwrites Jane Doe's record)

**Fix:** Use exact full email matching:
```
Match logic: source.email == crm.email (exact match)
Example: john.smith@acme.com only matches john.smith@acme.com
Result: Updates correct person's record, no data corruption
```

### Anti-Pattern 5: The Forgotten Data Type Conversion

**What it looks like:**

Source and CRM have different data types for same field:
```
Source: Employee Count = "500" (text/string)
CRM: Employee Count = Number field
Mapping: Direct mapping without conversion
Result: Mapping fails, field stays empty OR converts incorrectly
```

**Why it fails:**
- CRM rejects text value for number field
- Field remains unpopulated
- Reporting breaks (can't calculate averages on empty field)

**Fix:** Add data type conversion:
```
Mapping logic:
1. Parse source "500" to integer 500
2. Validate it's numeric (reject "Around 500")
3. Map converted value to CRM number field

Result: CRM receives proper integer value, reporting works