N8N CRM Automation: Pipedrive, HubSpot & Salesforce Integration

Lead Scoring Function Node:

const lead = $input.first().json;
let score = 0;

// Job Seniority (max 30 points)
const seniorityScores = {
  'C-Level': 30,
  'VP': 25,
  'Director': 20,
  'Manager': 15,
  'Individual Contributor': 5
};
score += seniorityScores[lead.seniority] || 0;

// Company Size (max 25 points)
const employees = lead.company?.employees || 0;
if (employees > 1000) score += 25;
else if (employees > 500) score += 20;
else if (employees > 100) score += 15;
else if (employees > 50) score += 10;
else score += 5;

// Industry Match (max 20 points)
const targetIndustries = ['Software', 'Technology', 'SaaS', 'E-commerce'];
if (targetIndustries.some(ind => lead.company?.industry?.includes(ind))) {
  score += 20;
}

// Email Domain Quality (max 15 points)
const domain = lead.email.split('@')[1];
if (!['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com'].includes(domain)) {
  score += 15; // Business email
}

// Form Completion Quality (max 10 points)
const fieldsCompleted = Object.keys(lead).filter(k => lead[k]).length;
if (fieldsCompleted > 8) score += 10;
else if (fieldsCompleted > 5) score += 5;

// Lead Quality Category
let quality = 'Low';
if (score >= 80) quality = 'High';
else if (score >= 50) quality = 'Medium';

return [{
  json: {
    ...lead,
    leadScore: score,
    leadQuality: quality,
    scoringDetails: {
      seniority: seniorityScores[lead.seniority] || 0,
      companySize: Math.min(25, Math.ceil(employees / 50) * 5),
      industryMatch: targetIndustries.some(ind => lead.company?.industry?.includes(ind)) ? 20 : 0,
      emailQuality: 15,
      completeness: fieldsCompleted > 8 ? 10 : 5
    }
  }
}];

Slack Notification (High-Value Leads):

Channel: #hot-leads

Message:
🔥 NEW HIGH-VALUE LEAD 🔥

Name: {{$json["firstName"]}} {{$json["lastName"]}}
Company: {{$json["company"]["name"]}}
Title: {{$json["jobTitle"]}}
Email: {{$json["email"]}}
Phone: {{$json["phone"]}}

━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 LEAD INTELLIGENCE
━━━━━━━━━━━━━━━━━━━━━━━━━━
Lead Score: {{$json["leadScore"]}}/100 ⭐
Quality: {{$json["leadQuality"]}}
Source: {{$json["leadSource"]}}

Company Size: {{$json["company"]["employees"]}} employees
Industry: {{$json["company"]["industry"]}}
Revenue: ${{$json["company"]["revenue"]}}M

━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 ACTION REQUIRED
━━━━━━━━━━━━━━━━━━━━━━━━━━
Assigned to: @{{$json["assignedToName"]}}
Expected Response: Within 15 minutes
CRM Link: {{$json["crmUrl"]}}

🔗 LinkedIn: {{$json["socialProfiles"]["linkedin"]}}

CALL NOW: {{$json["phone"]}}

CRM Event Trigger (New Lead Created, Deal Stage Changed)
         ↓
  Determine Sequence Type (based on lead score, source, stage)
         ↓
  Create Sequence Entry in Database
  (Track: sequence_id, lead_id, current_step, next_send_time)
         ↓
  Schedule Trigger (Checks every hour for due emails)
         ↓
  Query Database for Emails Due to Send
         ↓
  For Each Email:
    ├── Check if lead replied (if yes, pause sequence)
    ├── Check if lead unsubscribed (if yes, stop sequence)
    ├── Personalize email with lead data
    ├── Calculate optimal send time (based on past engagement)
    ├── Send email via SendGrid/Mailgun/SES
    ├── Track send in CRM activity timeline
    ├── Update sequence step
    └── Schedule next email
         ↓
  Monitor Email Events (opens, clicks, replies)
         ↓
  If Reply Detected:
    ├── Pause sequence
    ├── Notify assigned sales rep
    └── Update lead status to "Engaged"

Function Node - Calculate Best Send Time:

const lead = $input.first().json;

// Get historical engagement data (from previous node)
const engagementHistory = $('Get Engagement History').all().map(item => item.json);

// Analyze past open times
const openTimes = engagementHistory
  .filter(e => e.action === 'email_open')
  .map(e => {
    const date = new Date(e.timestamp);
    return {
      hour: date.getHours(),
      dayOfWeek: date.getDay(),
      opened: true
    };
  });

// Find most common open hour and day
const hourCounts = {};
const dayCounts = {};

openTimes.forEach(ot => {
  hourCounts[ot.hour] = (hourCounts[ot.hour] || 0) + 1;
  dayCounts[ot.dayOfWeek] = (dayCounts[ot.dayOfWeek] || 0) + 1;
});

// Determine optimal send time
let optimalHour = 10; // Default: 10 AM
let optimalDay = 2; // Default: Tuesday

if (Object.keys(hourCounts).length > 0) {
  optimalHour = parseInt(Object.keys(hourCounts).reduce((a, b) =>
    hourCounts[a] > hourCounts[b] ? a : b
  ));
}

if (Object.keys(dayCounts).length > 0) {
  optimalDay = parseInt(Object.keys(dayCounts).reduce((a, b) =>
    dayCounts[a] > dayCounts[b] ? a : b
  ));
}

// If no history, use industry best practices
if (openTimes.length === 0) {
  // B2B: Tuesday-Thursday, 10 AM or 2 PM
  const industryDefaults = {
    'B2B': { hour: 10, day: 2 }, // Tuesday 10 AM
    'B2C': { hour: 19, day: 0 }, // Sunday 7 PM
    'SaaS': { hour: 14, day: 3 }  // Wednesday 2 PM
  };

  const defaults = industryDefaults[lead.industry] || industryDefaults['B2B'];
  optimalHour = defaults.hour;
  optimalDay = defaults.day;
}

// Calculate next occurrence of optimal day/time
const now = new Date();
const nextSend = new Date();
nextSend.setHours(optimalHour, 0, 0, 0);

// Advance to next optimal day
while (nextSend.getDay() !== optimalDay || nextSend <= now) {
  nextSend.setDate(nextSend.getDate() + 1);
}

return [{
  json: {
    leadId: lead.id,
    optimalHour,
    optimalDay,
    nextSendTime: nextSend.toISOString(),
    confidence: openTimes.length > 5 ? 'High' : openTimes.length > 0 ? 'Medium' : 'Low',
    basedOnData: openTimes.length > 0
  }
}];