Data Cleansing and Enrichment HubSpot Workflow

What is HubSpot CRM Data Hygiene?

In today’s data-driven business environment, the quality of your CRM data directly impacts your marketing effectiveness, sales efficiency, and customer service quality.

HubSpot’s Operations Hub provides powerful tools to automate the process of cleaning, standardizing, and enriching your contact and company data, ensuring your teams work with accurate, complete, and up-to-date information.

Why Data Cleansing and Enrichment Matters

High-quality data is the foundation of effective business operations. An automated data cleansing and enrichment workflow addresses several critical business challenges:

Reduces duplicate records: Eliminates redundant contacts and companies that create confusion
Standardizes formatting: Ensures consistent data formats for properties like phone numbers and addresses
Fills information gaps: Completes missing data points through third-party enrichment
Maintains data accuracy: Regularly updates changing information
Improves segmentation: Enables more precise targeting based on complete data
Enhances reporting: Provides more accurate analytics and insights
Increases system adoption: Builds team trust in CRM data

Research shows that poor data quality costs businesses an average of 15-25% of their revenue.

By implementing automated data cleansing and enrichment, you can significantly reduce these costs while improving operational efficiency.

Setting Up Your Data Cleansing and Enrichment Workflow

Let’s build a comprehensive workflow that automatically identifies and resolves data quality issues while enriching your records with valuable additional information.

Step 1: Define Your Data Quality Standards

Before building the workflow, establish clear standards for your data:

Required fields: Which properties must be populated
Formatting rules: How phone numbers, addresses, and other data should be formatted
Naming conventions: Standards for company names, contact names, etc.
Duplicate criteria: What constitutes a duplicate record
Data freshness: How often data should be updated

Step 2: Create the Base Workflow

Navigate to Automation > Workflows in your HubSpot account
Click “Create workflow” > “From scratch”
Select “Contact-based” workflow (create separate workflows for companies)
Name it “Contact Data Quality Automation”

Step 3: Set Up Regular Data Audit Triggers

Begin with a scheduled trigger to regularly audit your data:

Set enrollment trigger: “Contact create date is known” (all contacts)
Add a “Delay” action to space out processing (e.g., enroll 100 contacts per day)
Add a “Re-enroll” setting to run this workflow monthly

Step 4: Implement Duplicate Detection

Identify and merge duplicate contacts:

Add a custom code action to identify potential duplicates (see advanced implementation below)
Add an “If/then branch” to check if duplicates were found
If duplicates exist:
- Add a “Create task” action for manual review if confidence is medium
- Add a “Set property value” action to mark as duplicate
- For high-confidence duplicates, add a “Create note” with merge recommendation

Step 5: Format Standardization

Ensure consistent data formats:

Add a “Format data” action for phone numbers
Add a “Format data” action for addresses
Add a “Format data” action for company names
Add a “Format data” action for contact names (proper capitalization)

Step 6: Data Enrichment

Fill in missing information:

Add an “If/then branch” to check for missing company information
If company information is incomplete:
- Add a “Enrich with company data” action using third-party data providers
- Add a “Set property value” action to update industry, company size, etc.
Add an “If/then branch” to check for missing contact information
If contact information is incomplete:
- Add a “Enrich with contact data” action using third-party data providers
- Add a “Set property value” action to update job title, seniority, etc.

Step 7: Data Validation

Verify critical data points:

Add an “If/then branch” to check email deliverability
If email is undeliverable:
- Add a “Set property value” action to mark as invalid
- Add a “Create task” action for manual verification
Add an “If/then branch” to check phone number validity
If phone number is invalid:
- Add a “Set property value” action to mark as invalid
- Add a “Create task” action for manual verification

Step 8: Data Scoring and Reporting

Implement data quality scoring:

Add a custom code action to calculate data quality score (see advanced implementation)
Add a “Set property value” action to update data quality score
Add an “If/then branch” based on score
If score is below threshold:
- Add a “Create task” for data enrichment
- Add a “Send email” to record owner requesting updates

Advanced Implementation: Custom Code for Intelligent Data Cleansing and Enrichment

Implement this custom code to create a sophisticated data quality management system that detects duplicates, standardizes formats, and calculates quality scores:

				
					// Custom code for intelligent data cleansing and enrichment
exports.main = (functionContext, sendResponse) => {
  // Get contact properties from the workflow
  const { 
    contact_id, 
    email,
    firstname,
    lastname,
    phone,
    company,
    address,
    jobtitle,
    industry,
    create_date,
    last_modified_date
  } = functionContext.parameters;
  
  // Initialize HubSpot client
  const hubspot = require('@hubspot/api-client');
  const hubspotClient = new hubspot.Client({
    accessToken: process.env.PRIVATE_APP_ACCESS_TOKEN
  });
  
  async function processContactData() {
    try {
      // Check for duplicates
      const duplicateResults = await findDuplicates(contact_id, email, firstname, lastname, company);
      
      // Standardize data formats
      const standardizedData = standardizeDataFormats({
        firstname,
        lastname,
        phone,
        company,
        address,
        jobtitle
      });
      
      // Calculate data quality score
      const qualityScore = calculateDataQualityScore({
        email,
        firstname,
        lastname,
        phone,
        company,
        address,
        jobtitle,
        industry,
        create_date,
        last_modified_date
      });
      
      // Identify missing critical fields
      const missingFields = identifyMissingFields({
        email,
        firstname,
        lastname,
        phone,
        company,
        jobtitle,
        industry
      });
      
      // Generate enrichment recommendations
      const enrichmentRecommendations = generateEnrichmentRecommendations(missingFields);
      
      // Return the processing results
      sendResponse({
        statusCode: 200,
        body: {
          contact_id: contact_id,
          duplicate_check: {
            duplicates_found: duplicateResults.duplicatesFound,
            potential_duplicates: duplicateResults.potentialDuplicates,
            confidence_score: duplicateResults.confidenceScore,
            recommended_action: duplicateResults.recommendedAction
          },
          standardized_data: standardizedData,
          data_quality: {
            quality_score: qualityScore.overallScore,
            completeness_score: qualityScore.completenessScore,
            accuracy_score: qualityScore.accuracyScore,
            recency_score: qualityScore.recencyScore,
            quality_category: getQualityCategory(qualityScore.overallScore)
          },
          missing_fields: missingFields,
          enrichment_recommendations: enrichmentRecommendations
        }
      });
    } catch (error) {
      // Handle errors
      sendResponse({
        statusCode: 500,
        body: {
          error: error.message
        }
      });
    }
  }
  
  // Helper function to find duplicates
  async function findDuplicates(contactId, email, firstName, lastName, company) {
    // In a real implementation, this would query HubSpot for potential duplicates
    // using various matching criteria
    
    // For this example, we'll simulate finding duplicates
    const searchCriteria = [];
    
    if (email) {
      searchCriteria.push({ property: 'email', value: email });
    }
    
    if (firstName && lastName) {
      searchCriteria.push({ 
        property: 'name', 
        value: `${firstName} ${lastName}`,
        company: company
      });
    }
    
    // Mock results
    const mockDuplicates = [
      {
        id: "123456",
        email: email,
        name: `${firstName} ${lastName}`,
        company: company,
        create_date: "2023-05-15T10:30:00Z",
        similarity_score: 0.92
      }
    ];
    
    // Determine if we have high-confidence duplicates
    const highConfidenceDuplicate = mockDuplicates.some(dup => dup.similarity_score > 0.9);
    
    // Determine recommended action
    let recommendedAction;
    if (highConfidenceDuplicate) {
      recommendedAction = "AUTO_MERGE";
    } else if (mockDuplicates.length > 0) {
      recommendedAction = "MANUAL_REVIEW";
    } else {
      recommendedAction = "NONE";
    }
    
    return {
      duplicatesFound: mockDuplicates.length > 0,
      potentialDuplicates: mockDuplicates,
      confidenceScore: highConfidenceDuplicate ? "HIGH" : (mockDuplicates.length > 0 ? "MEDIUM" : "LOW"),
      recommendedAction: recommendedAction
    };
  }
  
  // Helper function to standardize data formats
  function standardizeDataFormats(contactData) {
    const standardized = { ...contactData };
    
    // Standardize names (proper case)
    if (standardized.firstname) {
      standardized.firstname = properCase(standardized.firstname);
    }
    
    if (standardized.lastname) {
      standardized.lastname = properCase(standardized.lastname);
    }
    
    // Standardize phone numbers (E.164 format)
    if (standardized.phone) {
      standardized.phone = standardizePhoneNumber(standardized.phone);
    }
    
    // Standardize company name
    if (standardized.company) {
      standardized.company = standardizeCompanyName(standardized.company);
    }
    
    // Standardize job title
    if (standardized.jobtitle) {
      standardized.jobtitle = standardizeJobTitle(standardized.jobtitle);
    }
    
    return standardized;
  }
  
  // Helper function for proper case
  function properCase(text) {
    if (!text) return text;
    
    return text.toLowerCase()
      .split(' ')
      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
      .join(' ');
  }
  
  // Helper function to standardize phone numbers
  function standardizePhoneNumber(phone) {
    if (!phone) return phone;
    
    // Remove all non-numeric characters
    let cleaned = phone.replace(/\D/g, '');
    
    // Handle US numbers (simple example)
    if (cleaned.length === 10) {
      return `+1${cleaned}`;
    } else if (cleaned.length === 11 && cleaned.startsWith('1')) {
      return `+${cleaned}`;
    }
    
    // For other cases, just add + if missing
    if (!phone.startsWith('+')) {
      return `+${cleaned}`;
    }
    
    return phone;
  }
  
  // Helper function to standardize company names
  function standardizeCompanyName(company) {
    if (!company) return company;
    
    // Convert to proper case
    let standardized = properCase(company);
    
    // Handle common abbreviations and formats
    const replacements = {
      'Inc': 'Inc.',
      'Llc': 'LLC',
      'Llp': 'LLP',
      'Corp': 'Corp.',
      'Co': 'Co.',
      'Ltd': 'Ltd.'
    };
    
    Object.entries(replacements).forEach(([search, replace]) => {
      // Replace at the end of the string
      const regex = new RegExp(`\\b${search}\\b`, 'g');
      standardized = standardized.replace(regex, replace);
    });
    
    return standardized;
  }
  
  // Helper function to standardize job titles
  function standardizeJobTitle(title) {
    if (!title) return title;
    
    // Convert to proper case
    let standardized = properCase(title);
    
    // Standardize common titles
    const titleMappings = {
      'Ceo': 'CEO',
      'Cfo': 'CFO',
      'Cto': 'CTO',
      'Cmo': 'CMO',
      'Vp': 'VP',
      'Svp': 'SVP',
      'Avp': 'AVP',
      'Dir': 'Director',
      'Sr': 'Senior',
      'Jr': 'Junior',
      'Mgr': 'Manager'
    };
    
    Object.entries(titleMappings).forEach(([search, replace]) => {
      const regex = new RegExp(`\\b${search}\\b`, 'g');
      standardized = standardized.replace(regex, replace);
    });
    
    return standardized;
  }
  
  // Helper function to calculate data quality score
  function calculateDataQualityScore(contactData) {
    // Calculate completeness score (0-100)
    const criticalFields = ['email', 'firstname', 'lastname', 'company'];
    const importantFields = ['phone', 'jobtitle', 'industry'];
    const allFields = [...criticalFields, ...importantFields, 'address'];
    
    let completenessScore = 0;
    let fieldsPresent = 0;
    
    // Count critical fields (worth 10 points each)
    criticalFields.forEach(field => {
      if (contactData[field] && contactData[field].trim() !== '') {
        completenessScore += 10;
        fieldsPresent++;
      }
    });
    
    // Count important fields (worth 5 points each)
    importantFields.forEach(field => {
      if (contactData[field] && contactData[field].trim() !== '') {
        completenessScore += 5;
        fieldsPresent++;
      }
    });
    
    // Add points for address (worth 5 points)
    if (contactData.address && contactData.address.trim() !== '') {
      completenessScore += 5;
      fieldsPresent++;
    }
    
    // Calculate accuracy score (0-100)
    let accuracyScore = 100;
    
    // Check email format
    if (contactData.email && !isValidEmail(contactData.email)) {
      accuracyScore -= 25;
    }
    
    // Check phone format
    if (contactData.phone && !isValidPhone(contactData.phone)) {
      accuracyScore -= 15;
    }
    
    // Calculate recency score (0-100)
    let recencyScore = 100;
    
    if (contactData.last_modified_date) {
      const lastModified = new Date(contactData.last_modified_date);
      const now = new Date();
      const daysSinceModified = Math.floor((now - lastModified) / (1000 * 60 * 60 * 24));
      
      // Reduce score for older records
      if (daysSinceModified > 365) {
        recencyScore = 25; // Very old
      } else if (daysSinceModified > 180) {
        recencyScore = 50; // Old
      } else if (daysSinceModified > 90) {
        recencyScore = 75; // Somewhat recent
      }
    }
    
    // Calculate overall score (weighted average)
    const overallScore = Math.round(
      (completenessScore * 0.5) + 
      (accuracyScore * 0.3) + 
      (recencyScore * 0.2)
    );
    
    return {
      overallScore,
      completenessScore,
      accuracyScore,
      recencyScore,
      fieldsPresent,
      totalFields: allFields.length
    };
  }
  
  // Helper function to check email validity
  function isValidEmail(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
  }
  
  // Helper function to check phone validity
  function isValidPhone(phone) {
    // Simple check for now - at least 10 digits
    const digitCount = phone.replace(/\D/g, '').length;
    return digitCount >= 10;
  }
  
  // Helper function to get quality category
  function getQualityCategory(score) {
    if (score >= 90) {
      return "EXCELLENT";
    } else if (score >= 75) {
      return "GOOD";
    } else if (score >= 50) {
      return "FAIR";
    } else {
      return "POOR";
    }
  }
  
  // Helper function to identify missing fields
  function identifyMissingFields(contactData) {
    const missingFields = [];
    
    // Check critical fields
    if (!contactData.email || contactData.email.trim() === '') {
      missingFields.push({
        field: "email",
        importance: "CRITICAL",
        enrichment_source: "MANUAL"
      });
    }
    
    if (!contactData.firstname || contactData.firstname.trim() === '') {
      missingFields.push({
        field: "firstname",
        importance: "CRITICAL",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    if (!contactData.lastname || contactData.lastname.trim() === '') {
      missingFields.push({
        field: "lastname",
        importance: "CRITICAL",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    if (!contactData.company || contactData.company.trim() === '') {
      missingFields.push({
        field: "company",
        importance: "CRITICAL",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    // Check important fields
    if (!contactData.phone || contactData.phone.trim() === '') {
      missingFields.push({
        field: "phone",
        importance: "HIGH",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    if (!contactData.jobtitle || contactData.jobtitle.trim() === '') {
      missingFields.push({
        field: "jobtitle",
        importance: "HIGH",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    if (!contactData.industry || contactData.industry.trim() === '') {
      missingFields.push({
        field: "industry",
        importance: "MEDIUM",
        enrichment_source: "THIRD_PARTY"
      });
    }
    
    return missingFields;
  }
  
  // Helper function to generate enrichment recommendations
  function generateEnrichmentRecommendations(missingFields) {
    const recommendations = [];
    
    // Group by enrichment source
    const thirdPartyFields = missingFields.filter(field => 
      field.enrichment_source === "THIRD_PARTY"
    );
    
    const manualFields = missingFields.filter(field => 
      field.enrichment_source === "MANUAL"
    );
    
    // Add third-party enrichment recommendation if applicable
    if (thirdPartyFields.length > 0) {
      recommendations.push({
        action: "THIRD_PARTY_ENRICHMENT",
        fields: thirdPartyFields.map(f => f.field),
        priority: thirdPartyFields.some(f => f.importance === "CRITICAL") ? "HIGH" : "MEDIUM",
        suggested_providers: ["Clearbit", "ZoomInfo", "DiscoverOrg"]
      });
    }
    
    // Add manual enrichment recommendation if applicable
    if (manualFields.length > 0) {
      recommendations.push({
        action: "MANUAL_ENRICHMENT",
        fields: manualFields.map(f => f.field),
        priority: manualFields.some(f => f.importance === "CRITICAL") ? "HIGH" : "MEDIUM",
        suggested_methods: ["Email verification", "LinkedIn research", "Direct outreach"]
      });
    }
    
    return recommendations;
  }
  
  // Execute the main function
  processContactData();
};

This serverless function creates a sophisticated data quality management system that detects duplicates, standardizes data formats, calculates quality scores, and recommends enrichment actions. The output can be used to automatically update records, create tasks for manual review, and trigger enrichment processes.

Integrating with Third-Party Data Providers

To maximize the impact of your data cleansing and enrichment workflow, integrate it with third-party data providers:

Set up API connections to data enrichment services like Clearbit, ZoomInfo, or DiscoverOrg
Add custom code actions to query these services for additional data
Implement logic to selectively update fields based on confidence scores
Create a record of enrichment activities in the contact timeline

Example integration with a data provider:

				
					// Example code snippet for third-party data enrichment
const axios = require('axios');

async function enrichContactData(email, company) {
  try {
    // Call third-party API (example using Clearbit)
    const response = await axios.get(`https://person.clearbit.com/v2/people/find?email=${email}`, {
      headers: {
        'Authorization': `Bearer ${process.env.CLEARBIT_API_KEY}`
      }
    }) ;
    
    // Extract relevant data
    const enrichedData = {
      firstname: response.data.name.givenName,
      lastname: response.data.name.familyName,
      jobtitle: response.data.employment.title,
      company: response.data.employment.name,
      industry: response.data.employment.sector,
      linkedin_url: response.data.linkedin.handle,
      twitter_url: response.data.twitter.handle,
      bio: response.data.bio
    };
    
    return {
      success: true,
      data: enrichedData,
      source: 'Clearbit'
    };
  } catch (error) {
    console.error('Enrichment error:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

Measuring Success

To evaluate the effectiveness of your data cleansing and enrichment workflow, monitor these key metrics:

Data quality score: Average quality score across your database
Duplicate rate: Percentage of records identified as duplicates
Field completion rate: Percentage of required fields that are populated
Enrichment success rate: Percentage of records successfully enriched
Data decay rate: How quickly your data becomes outdated
Cost savings: Reduction in manual data maintenance time
Marketing performance: Improvement in email deliverability and engagement

Real-World Impact

A well-implemented data cleansing and enrichment workflow delivers significant business benefits. One of our B2B technology clients achieved:

63% reduction in duplicate records
42% improvement in email deliverability
28% increase in form conversion rates
35% higher email engagement rates
52% reduction in time spent on manual data maintenance
18% increase in lead-to-opportunity conversion

The key to their success was combining automated cleansing processes with strategic third-party data enrichment and regular data quality audits.

Best Practices for Data Cleansing and Enrichment

Start with clear standards: Define what “good data” looks like for your organization.
Implement preventive measures: Use form validation and duplicate detection at data entry points.
Prioritize critical records: Focus initial efforts on high-value segments of your database.
Balance automation with human review: Use automation for routine tasks but maintain human oversight
Document your data model: Maintain clear documentation of properties, formats, and relationships.
Create a data governance team: Assign clear ownership for data quality
Implement regular audits: Schedule periodic comprehensive reviews of your database.

By implementing this data cleansing and enrichment workflow, you’ll create a more reliable foundation for your marketing, sales, and service operations, ultimately driving better business results through higher-quality data.

Daniel Lynch

Daniel Lynch is a multidisciplinary digital strategist and technologist with deep expertise in AI, SEO, CRM systems, and full-stack web development. As Founder and CEO of Empathy First Media, he leads the design and execution of data-driven marketing ecosystems for enterprise and mid-market clients in healthcare, construction, and finance. Daniel’s background in civil engineering informs his analytical approach to digital problem-solving, from architecting high-performance WordPress platforms to implementing scalable CRM and RevOps infrastructures in HubSpot. His technical competencies span advanced search engine optimization (technical SEO, schema markup, RankMath/Yoast), plugin performance auditing, AI chatbot deployment, and algorithmic lead generation workflows. He has successfully managed hundreds of custom website builds, optimizing UX and LCP/CLS performance with tools like WP Rocket, GTMetrix, Cloudflare APO, and adaptive image compression technologies. Daniel specializes in converting complex digital challenges into actionable, measurable solutions, leveraging AI and automation to drive operational efficiency and marketing ROI. His agency’s proprietary “Algorithmic Empathy” methodology combines psychological messaging with systemized analytics to deliver industry-leading outcomes in digital engagement, lead acquisition, and brand visibility.

Meet The Author