n8n Sales & CRM Automation: 50+ Templates for Revenue Growth#

1
// Unified lead capture from multiple sources
2
const leadSources = {
3
  webform: {
4
    webhook: '/api/leads/webform',
5
    fields: ['name', 'email', 'company', 'phone', 'message'],
6
    validation: true
7
  },
8
  linkedin: {
9
    integration: 'LinkedIn Sales Navigator',
10
    trigger: 'new_connection',
11
    enrichment: true
12
  },
13
  email: {
14
    parser: 'email_parser_node',
15
    patterns: ['inquiry', 'demo_request', 'pricing'],
16
    autoReply: true
17
  },
18
  chatbot: {
19
    platform: 'Intercom',
20
    qualification: ['budget', 'timeline', 'decision_maker'],
21
    handoff: 'qualified_leads'
22
  }
23
};
24

25
// Lead normalization
26
function normalizeLead(source, rawData) {
27
  const lead = {
28
    id: generateLeadId(),
29
    source: source,
30
    capturedAt: new Date().toISOString(),
31
    data: {},
32
    metadata: {}
33
  };
34

35
  // Map fields based on source
36
  switch(source) {
37
    case 'webform':
38
      lead.data = {
39
        firstName: rawData.name.split(' ')[0],
40
        lastName: rawData.name.split(' ').slice(1).join(' '),
41
        email: rawData.email.toLowerCase(),
42
        company: rawData.company,
43
        phone: formatPhoneNumber(rawData.phone)
44
      };
45
      break;
46
    case 'linkedin':
47
      lead.data = extractLinkedInData(rawData);
48
      break;
49
    // ... other sources
50
  }
51

52
  return lead;
53
}

1
// Comprehensive lead enrichment workflow
2
async function enrichLead(lead) {
3
  const enrichmentTasks = [];
4

5
  // 1. Company data enrichment
6
  enrichmentTasks.push(
7
    enrichCompanyData(lead.data.company || lead.data.domain)
8
  );
9

10
  // 2. Contact enrichment
11
  enrichmentTasks.push(
12
    enrichContactData(lead.data.email)
13
  );
14

15
  // 3. Social media profiles
16
  enrichmentTasks.push(
17
    findSocialProfiles(lead.data.email, lead.data.name)
18
  );
19

20
  // 4. Technographic data
21
  if (lead.data.domain) {
22
    enrichmentTasks.push(
23
      getTechnographics(lead.data.domain)
24
    );
25
  }
26

27
  // Execute all enrichment tasks in parallel
28
  const results = await Promise.all(enrichmentTasks);
29

30
  // Merge enriched data
31
  const enrichedLead = {
32
    ...lead,
33
    enrichment: {
34
      company: results[0],
35
      contact: results[1],
36
      social: results[2],
37
      technographics: results[3],
38
      enrichedAt: new Date().toISOString()
39
    }
40
  };
41

42
  // AI analysis for insights
43
  const aiInsights = await generateAIInsights(enrichedLead);
44
  enrichedLead.aiInsights = aiInsights;
45

46
  return enrichedLead;
47
}
48

49
// AI insights generation
50
async function generateAIInsights(lead) {
51
  const prompt = `
52
    Analyze this lead and provide insights:
53

54
    Company: ${lead.enrichment.company.name}
55
    Industry: ${lead.enrichment.company.industry}
56
    Size: ${lead.enrichment.company.employees}
57
    Revenue: ${lead.enrichment.company.revenue}
58
    Technologies: ${lead.enrichment.technographics.join(', ')}
59
    Recent News: ${lead.enrichment.company.recentNews}
60

61
    Provide:
62
    1. Buying propensity score (0-100)
63
    2. Best engagement approach
64
    3. Potential pain points
65
    4. Recommended products/services
66
    5. Optimal outreach timing
67
  `;
68

69
  const insights = await callGPT4(prompt);
70
  return parseAIResponse(insights);
71
}

1
// Multi-factor lead scoring system
2
class LeadScoringEngine {
3
  constructor() {
4
    this.weights = {
5
      demographic: 0.25,
6
      firmographic: 0.30,
7
      behavioral: 0.25,
8
      engagement: 0.20
9
    };
10
  }
11

12
  calculateScore(lead) {
13
    const scores = {
14
      demographic: this.scoreDemographic(lead),
15
      firmographic: this.scoreFirmographic(lead),
16
      behavioral: this.scoreBehavioral(lead),
17
      engagement: this.scoreEngagement(lead)
18
    };
19

20
    // Calculate weighted score
21
    let totalScore = 0;
22
    for (const [category, weight] of Object.entries(this.weights)) {
23
      totalScore += scores[category] * weight;
24
    }
25

26
    // Apply AI adjustment
27
    const aiAdjustment = this.getAIAdjustment(lead);
28
    totalScore = totalScore * (1 + aiAdjustment);
29

30
    return {
31
      totalScore: Math.min(100, Math.round(totalScore)),
32
      breakdown: scores,
33
      grade: this.getGrade(totalScore),
34
      recommendation: this.getRecommendation(totalScore, lead)
35
    };
36
  }
37

38
  scoreDemographic(lead) {
39
    let score = 0;
40

41
    // Job title scoring
42
    const titleScore = {
43
      'C-Level': 30,
44
      'VP': 25,
45
      'Director': 20,
46
      'Manager': 15,
47
      'Other': 5
48
    };
49
    score += titleScore[this.classifyTitle(lead.jobTitle)] || 5;
50

51
    // Department scoring
52
    if (lead.department === 'target_department') score += 20;
53

54
    // Location scoring
55
    if (this.isTargetLocation(lead.location)) score += 10;
56

57
    return score;
58
  }
59

60
  scoreFirmographic(lead) {
61
    let score = 0;
62

63
    // Company size
64
    if (lead.company.employees >= 100 && lead.company.employees <= 1000) {
65
      score += 25;
66
    } else if (lead.company.employees > 1000) {
67
      score += 20;
68
    }
69

70
    // Revenue
71
    if (lead.company.revenue >= 10000000) score += 25;
72

73
    // Industry
74
    if (this.targetIndustries.includes(lead.company.industry)) {
75
      score += 20;
76
    }
77

78
    // Technology stack match
79
    const techMatch = this.calculateTechMatch(lead.technographics);
80
    score += techMatch * 10;
81

82
    return score;
83
  }
84

85
  scoreBehavioral(lead) {
86
    let score = 0;
87

88
    // Website activity
89
    score += Math.min(20, lead.websiteVisits * 2);
90
    score += Math.min(15, lead.pagesViewed * 0.5);
91
    score += lead.downloadedContent ? 15 : 0;
92
    score += lead.watchedDemo ? 20 : 0;
93

94
    // Form submissions
95
    score += Math.min(15, lead.formsSubmitted * 5);
96

97
    return score;
98
  }
99

100
  scoreEngagement(lead) {
101
    let score = 0;
102

103
    // Email engagement
104
    score += lead.emailsOpened * 2;
105
    score += lead.emailsClicked * 5;
106

107
    // Meeting engagement
108
    score += lead.meetingsScheduled * 20;
109
    score += lead.meetingsAttended * 25;
110

111
    // Response time
112
    if (lead.avgResponseTime < 3600) score += 10; // Less than 1 hour
113

114
    return Math.min(100, score);
115
  }
116
}

1
// Intelligent lead routing system
2
class LeadRouter {
3
  constructor(salesTeam) {
4
    this.salesTeam = salesTeam;
5
    this.routingRules = this.initializeRules();
6
  }
7

8
  async routeLead(lead, score) {
9
    // Determine routing strategy
10
    const strategy = this.determineStrategy(lead, score);
11

12
    switch(strategy) {
13
      case 'round-robin':
14
        return await this.roundRobinAssignment(lead);
15
      case 'territory-based':
16
        return await this.territoryAssignment(lead);
17
      case 'skill-based':
18
        return await this.skillBasedAssignment(lead);
19
      case 'ai-optimized':
20
        return await this.aiOptimizedAssignment(lead, score);
21
      default:
22
        return await this.defaultAssignment(lead);
23
    }
24
  }
25

26
  async aiOptimizedAssignment(lead, score) {
27
    // Get rep performance data
28
    const repPerformance = await this.getRepPerformance();
29

30
    // Calculate match scores for each rep
31
    const matchScores = await Promise.all(
32
      this.salesTeam.map(async (rep) => {
33
        const score = await this.calculateRepMatch(rep, lead);
34
        return { rep, score };
35
      })
36
    );
37

38
    // Sort by match score and availability
39
    matchScores.sort((a, b) => {
40
      const scoreA = a.score * a.rep.availability;
41
      const scoreB = b.score * b.rep.availability;
42
      return scoreB - scoreA;
43
    });
44

45
    // Assign to best match
46
    const assignedRep = matchScores[0].rep;
47

48
    // Create assignment record
49
    const assignment = {
50
      leadId: lead.id,
51
      repId: assignedRep.id,
52
      assignedAt: new Date().toISOString(),
53
      strategy: 'ai-optimized',
54
      matchScore: matchScores[0].score,
55
      reason: this.generateAssignmentReason(lead, assignedRep)
56
    };
57

58
    // Notify rep
59
    await this.notifyRep(assignedRep, lead, assignment);
60

61
    return assignment;
62
  }
63

64
  async calculateRepMatch(rep, lead) {
65
    // Multiple factors for matching
66
    let matchScore = 0;
67

68
    // Industry expertise
69
    if (rep.expertise.includes(lead.company.industry)) {
70
      matchScore += 30;
71
    }
72

73
    // Company size experience
74
    if (rep.dealSizePreference === lead.company.size) {
75
      matchScore += 20;
76
    }
77

78
    // Geographic match
79
    if (rep.territory.includes(lead.location)) {
80
      matchScore += 15;
81
    }
82

83
    // Language match
84
    if (rep.languages.includes(lead.preferredLanguage)) {
85
      matchScore += 10;
86
    }
87

88
    // Workload balance
89
    const workloadScore = (1 - (rep.currentLeads / rep.maxLeads)) * 25;
90
    matchScore += workloadScore;
91

92
    // Historical success rate with similar leads
93
    const historicalSuccess = await this.getHistoricalSuccess(rep, lead);
94
    matchScore += historicalSuccess * 20;
95

96
    return matchScore;
97
  }
98
}

1
// Automated deal progression
2
class DealPipeline {
3
  constructor() {
4
    this.stages = [
5
      'Qualification',
6
      'Discovery',
7
      'Demo/Meeting',
8
      'Proposal',
9
      'Negotiation',
10
      'Closed Won',
11
      'Closed Lost'
12
    ];
13

14
    this.stageActions = {
15
      'Qualification': this.qualificationActions,
16
      'Discovery': this.discoveryActions,
17
      'Demo/Meeting': this.demoActions,
18
      'Proposal': this.proposalActions,
19
      'Negotiation': this.negotiationActions
20
    };
21
  }
22

23
  async progressDeal(deal, trigger) {
24
    const currentStage = deal.stage;
25
    const nextStage = this.determineNextStage(deal, trigger);
26

27
    if (nextStage && nextStage !== currentStage) {
28
      // Update deal stage
29
      deal.stage = nextStage;
30
      deal.stageChangedAt = new Date().toISOString();
31

32
      // Execute stage-specific actions
33
      await this.executeStageActions(deal, nextStage);
34

35
      // Update probability
36
      deal.probability = this.calculateProbability(deal);
37

38
      // Send notifications
39
      await this.notifyStakeholders(deal, currentStage, nextStage);
40

41
      // Log activity
42
      await this.logStageChange(deal, currentStage, nextStage, trigger);
43
    }
44

45
    return deal;
46
  }
47

48
  async executeStageActions(deal, stage) {
49
    const actions = this.stageActions[stage];
50
    if (actions) {
51
      await actions.call(this, deal);
52
    }
53
  }
54

55
  async proposalActions(deal) {
56
    // Generate proposal document
57
    const proposal = await this.generateProposal(deal);
58

59
    // Create approval workflow if needed
60
    if (deal.value > 50000) {
61
      await this.createApprovalWorkflow(deal, proposal);
62
    }
63

64
    // Schedule follow-up
65
    await this.scheduleFollowUp(deal, 3); // 3 days
66

67
    // Update forecast
68
    await this.updateForecast(deal);
69
  }
70

71
  async generateProposal(deal) {
72
    // AI-powered proposal generation
73
    const template = await this.getProposalTemplate(deal.product);
74

75
    const proposalData = {
76
      client: deal.company,
77
      products: deal.products,
78
      pricing: await this.calculatePricing(deal),
79
      terms: await this.getTerms(deal),
80
      customization: await this.generateCustomContent(deal)
81
    };
82

83
    // Generate with AI
84
    const aiContent = await this.generateAIContent(deal);
85
    proposalData.executiveSummary = aiContent.summary;
86
    proposalData.valueProposition = aiContent.value;
87

88
    return await this.createDocument(template, proposalData);
89
  }
90
}

1
// Automated sales activities and follow-ups
2
class SalesActivityAutomation {
3
  constructor() {
4
    this.activities = {
5
      email: this.sendEmail,
6
      call: this.scheduleCall,
7
      meeting: this.scheduleMeeting,
8
      task: this.createTask,
9
      linkedin: this.linkedInOutreach
10
    };
11
  }
12

13
  async createActivitySequence(lead, type = 'standard') {
14
    const sequences = {
15
      standard: [
16
        { day: 0, activity: 'email', template: 'welcome' },
17
        { day: 2, activity: 'linkedin', action: 'connect' },
18
        { day: 3, activity: 'call', priority: 'high' },
19
        { day: 5, activity: 'email', template: 'follow_up_1' },
20
        { day: 8, activity: 'call', priority: 'medium' },
21
        { day: 10, activity: 'email', template: 'value_prop' },
22
        { day: 14, activity: 'task', type: 'personal_outreach' }
23
      ],
24
      accelerated: [
25
        { day: 0, activity: 'call', priority: 'urgent' },
26
        { day: 0, activity: 'email', template: 'urgent_response' },
27
        { day: 1, activity: 'meeting', type: 'demo' },
28
        { day: 2, activity: 'email', template: 'proposal' }
29
      ],
30
      nurture: [
31
        { day: 0, activity: 'email', template: 'nurture_1' },
32
        { day: 14, activity: 'email', template: 'nurture_2' },
33
        { day: 30, activity: 'email', template: 'nurture_3' },
34
        { day: 45, activity: 'linkedin', action: 'share_content' },
35
        { day: 60, activity: 'email', template: 'check_in' }
36
      ]
37
    };
38

39
    const sequence = sequences[type];
40
    const scheduledActivities = [];
41

42
    for (const step of sequence) {
43
      const scheduledDate = this.addBusinessDays(new Date(), step.day);
44

45
      const activity = {
46
        leadId: lead.id,
47
        type: step.activity,
48
        scheduledDate: scheduledDate,
49
        status: 'scheduled',
50
        details: step,
51
        sequenceType: type
52
      };
53

54
      scheduledActivities.push(activity);
55

56
      // Create in CRM
57
      await this.createCRMActivity(activity);
58
    }
59

60
    return scheduledActivities;
61
  }
62

63
  async executeActivity(activity) {
64
    const handler = this.activities[activity.type];
65
    if (handler) {
66
      try {
67
        const result = await handler.call(this, activity);
68

69
        // Update activity status
70
        activity.status = 'completed';
71
        activity.completedAt = new Date().toISOString();
72
        activity.result = result;
73

74
        // Trigger next action based on result
75
        await this.handleActivityResult(activity, result);
76

77
      } catch (error) {
78
        activity.status = 'failed';
79
        activity.error = error.message;
80

81
        // Retry logic
82
        if (activity.retryCount < 3) {
83
          activity.retryCount = (activity.retryCount || 0) + 1;
84
          activity.status = 'scheduled';
85
          activity.scheduledDate = this.addHours(new Date(), 2);
86
        }
87
      }
88
    }
89

90
    return activity;
91
  }
92

93
  async sendEmail(activity) {
94
    // Get email template
95
    const template = await this.getEmailTemplate(activity.details.template);
96

97
    // Personalize content with AI
98
    const personalizedContent = await this.personalizeWithAI(
99
      template,
100
      activity.lead
101
    );
102

103
    // Add tracking
104
    const trackedContent = this.addEmailTracking(
105
      personalizedContent,
106
      activity.id
107
    );
108

109
    // Send email
110
    const result = await this.emailService.send({
111
      to: activity.lead.email,
112
      subject: personalizedContent.subject,
113
      html: trackedContent.html,
114
      trackingId: activity.id
115
    });
116

117
    return result;
118
  }
119
}

1
// Call and meeting analysis
2
class ConversationIntelligence {
3
  async analyzeCall(callRecording) {
4
    // Transcribe call
5
    const transcript = await this.transcribeAudio(callRecording);
6

7
    // Analyze with AI
8
    const analysis = await this.analyzeTranscript(transcript);
9

10
    return {
11
      transcript: transcript,
12
      summary: analysis.summary,
13
      sentiment: analysis.sentiment,
14
      keyPoints: analysis.keyPoints,
15
      nextSteps: analysis.nextSteps,
16
      competitorMentions: analysis.competitors,
17
      objections: analysis.objections,
18
      painPoints: analysis.painPoints,
19
      coachingOpportunities: analysis.coaching
20
    };
21
  }
22

23
  async analyzeTranscript(transcript) {
24
    const prompt = `
25
      Analyze this sales call transcript and provide:
26

27
      1. Executive Summary (2-3 sentences)
28
      2. Overall Sentiment (positive/neutral/negative with score)
29
      3. Key Discussion Points (bullet list)
30
      4. Identified Next Steps
31
      5. Competitor Mentions (company and context)
32
      6. Customer Objections
33
      7. Pain Points Discussed
34
      8. Coaching Opportunities for the sales rep
35

36
      Transcript: ${transcript}
37
    `;
38

39
    const analysis = await this.callAI(prompt);
40
    return this.parseAnalysis(analysis);
41
  }
42

43
  async generateFollowUpEmail(callAnalysis) {
44
    const prompt = `
45
      Based on this call analysis, generate a follow-up email:
46

47
      Key Points: ${callAnalysis.keyPoints.join(', ')}
48
      Next Steps: ${callAnalysis.nextSteps.join(', ')}
49
      Pain Points: ${callAnalysis.painPoints.join(', ')}
50

51
      The email should:
52
      1. Thank them for their time
53
      2. Summarize key discussion points
54
      3. Address any objections raised
55
      4. Outline clear next steps
56
      5. Provide value/resources related to their pain points
57
    `;
58

59
    return await this.generateContent(prompt);
60
  }
61
}

1
// Deal prediction and forecasting
2
class SalesPrediction {
3
  async predictDealOutcome(deal) {
4
    // Collect historical data
5
    const historicalDeals = await this.getHistoricalDeals({
6
      similar: true,
7
      to: deal
8
    });
9

10
    // Extract features
11
    const features = this.extractFeatures(deal);
12
    const historicalFeatures = historicalDeals.map(d =>
13
      this.extractFeatures(d)
14
    );
15

16
    // Run prediction model
17
    const prediction = await this.runPredictionModel(
18
      features,
19
      historicalFeatures
20
    );
21

22
    // Generate insights
23
    const insights = await this.generateInsights(deal, prediction);
24

25
    return {
26
      winProbability: prediction.probability,
27
      expectedCloseDate: prediction.closeDate,
28
      expectedValue: prediction.value,
29
      riskFactors: prediction.risks,
30
      recommendations: insights.recommendations,
31
      similarDeals: insights.similarDeals
32
    };
33
  }
34

35
  extractFeatures(deal) {
36
    return {
37
      // Deal characteristics
38
      dealSize: deal.value,
39
      dealAge: this.daysSinceCreation(deal),
40
      stage: deal.stage,
41
      stageVelocity: this.calculateVelocity(deal),
42

43
      // Engagement metrics
44
      emailsSent: deal.activities.emails,
45
      callsMade: deal.activities.calls,
46
      meetingsHeld: deal.activities.meetings,
47
      lastContactDays: this.daysSinceLastContact(deal),
48

49
      // Company characteristics
50
      companySize: deal.company.employees,
51
      industry: deal.company.industry,
52
      revenue: deal.company.revenue,
53

54
      // Relationship metrics
55
      stakeholderCount: deal.stakeholders.length,
56
      championIdentified: deal.champion !== null,
57
      decisionMakerEngaged: deal.decisionMakerEngaged,
58

59
      // Competitive landscape
60
      competitorsInvolved: deal.competitors.length,
61
      incumbentVendor: deal.incumbent !== null
62
    };
63
  }
64

65
  async generateInsights(deal, prediction) {
66
    const prompt = `
67
      Based on this deal analysis, provide strategic insights:
68

69
      Deal: ${JSON.stringify(deal)}
70
      Prediction: ${JSON.stringify(prediction)}
71

72
      Provide:
73
      1. Top 3 actions to increase win probability
74
      2. Main risks and mitigation strategies
75
      3. Optimal engagement strategy
76
      4. Resource allocation recommendations
77
    `;
78

79
    const insights = await this.callAI(prompt);
80
    return this.parseInsights(insights);
81
  }
82
}

1
// Automated commission calculation
2
class CommissionEngine {
3
  calculateCommission(rep, period) {
4
    const deals = this.getClosedDeals(rep, period);
5

6
    let commission = 0;
7

8
    for (const deal of deals) {
9
      const rate = this.getCommissionRate(rep, deal);
10
      const accelerators = this.getAccelerators(rep, deal);
11
      const spiffs = this.getSpiffs(deal);
12

13
      const baseCommission = deal.value * rate;
14
      const acceleratedCommission = baseCommission * accelerators;
15
      const totalDealCommission = acceleratedCommission + spiffs;
16

17
      commission += totalDealCommission;
18

19
      // Track for reporting
20
      this.trackCommission({
21
        rep: rep,
22
        deal: deal,
23
        base: baseCommission,
24
        accelerated: acceleratedCommission,
25
        spiffs: spiffs,
26
        total: totalDealCommission
27
      });
28
    }
29

30
    // Apply tier bonuses
31
    const tierBonus = this.calculateTierBonus(rep, commission);
32
    commission += tierBonus;
33

34
    return {
35
      total: commission,
36
      deals: deals.length,
37
      breakdown: this.getBreakdown(rep, period),
38
      tierBonus: tierBonus
39
    };
40
  }
41

42
  getCommissionRate(rep, deal) {
43
    // Base rates by product
44
    const baseRates = {
45
      'enterprise': 0.10,
46
      'professional': 0.08,
47
      'starter': 0.06
48
    };
49

50
    let rate = baseRates[deal.product] || 0.07;
51

52
    // Adjust for deal characteristics
53
    if (deal.multiYear) rate += 0.02;
54
    if (deal.isUpsell) rate -= 0.01;
55
    if (deal.value > 100000) rate += 0.01;
56

57
    return rate;
58
  }
59

60
  getAccelerators(rep, deal) {
61
    let accelerator = 1.0;
62

63
    // Quota attainment accelerator
64
    const quotaAttainment = rep.currentAttainment / rep.quota;
65
    if (quotaAttainment > 1.5) accelerator = 1.5;
66
    else if (quotaAttainment > 1.25) accelerator = 1.3;
67
    else if (quotaAttainment > 1.0) accelerator = 1.2;
68

69
    // New business accelerator
70
    if (deal.type === 'new_business') accelerator *= 1.1;
71

72
    // Strategic account accelerator
73
    if (deal.isStrategic) accelerator *= 1.15;
74

75
    return accelerator;
76
  }
77
}

1
// Real-time sales metrics and KPIs
2
class SalesDashboard {
3
  async generateMetrics(period = 'current_quarter') {
4
    const metrics = {
5
      revenue: await this.getRevenueMetrics(period),
6
      pipeline: await this.getPipelineMetrics(period),
7
      activity: await this.getActivityMetrics(period),
8
      conversion: await this.getConversionMetrics(period),
9
      forecast: await this.getForecastMetrics(period),
10
      team: await this.getTeamMetrics(period)
11
    };
12

13
    // Generate insights
14
    metrics.insights = await this.generateInsights(metrics);
15

16
    // Create alerts
17
    metrics.alerts = this.generateAlerts(metrics);
18

19
    return metrics;
20
  }
21

22
  async getRevenueMetrics(period) {
23
    return {
24
      closed: await this.getClosedRevenue(period),
25
      target: await this.getTarget(period),
26
      attainment: await this.getAttainment(period),
27
      avgDealSize: await this.getAvgDealSize(period),
28
      growthRate: await this.getGrowthRate(period),
29
      byProduct: await this.getRevenueByProduct(period),
30
      byRep: await this.getRevenueByRep(period),
31
      trend: await this.getRevenueTrend(period)
32
    };
33
  }
34

35
  async getPipelineMetrics(period) {
36
    const pipeline = await this.getPipeline(period);
37

38
    return {
39
      totalValue: pipeline.reduce((sum, deal) => sum + deal.value, 0),
40
      dealCount: pipeline.length,
41
      byStage: this.groupByStage(pipeline),
42
      velocity: await this.calculateVelocity(pipeline),
43
      coverage: await this.calculateCoverage(pipeline),
44
      health: await this.assessPipelineHealth(pipeline),
45
      atRisk: await this.identifyAtRiskDeals(pipeline),
46
      weighted: await this.calculateWeightedPipeline(pipeline)
47
    };
48
  }
49

50
  async generateInsights(metrics) {
51
    const prompt = `
52
      Analyze these sales metrics and provide insights:
53

54
      ${JSON.stringify(metrics)}
55

56
      Provide:
57
      1. Key performance highlights
58
      2. Areas of concern
59
      3. Recommended actions
60
      4. Forecast accuracy assessment
61
      5. Team performance insights
62
    `;
63

64
    const insights = await this.callAI(prompt);
65
    return this.parseInsights(insights);
66
  }
67
}

1
// Complete Salesforce automation
2
const salesforceWorkflow = {
3
  name: 'Salesforce Complete Automation',
4

5
  nodes: [
6
    {
7
      type: 'webhook',
8
      name: 'Lead Webhook',
9
      config: {
10
        path: '/salesforce/lead',
11
        method: 'POST'
12
      }
13
    },
14
    {
15
      type: 'salesforce',
16
      name: 'Check Duplicate',
17
      operation: 'search',
18
      query: 'SELECT Id FROM Lead WHERE Email = :email'
19
    },
20
    {
21
      type: 'if',
22
      name: 'Is New Lead',
23
      condition: '{{ $node["Check Duplicate"].json.totalSize === 0 }}'
24
    },
25
    {
26
      type: 'salesforce',
27
      name: 'Create Lead',
28
      operation: 'create',
29
      object: 'Lead',
30
      fields: {
31
        FirstName: '{{ $json.firstName }}',
32
        LastName: '{{ $json.lastName }}',
33
        Email: '{{ $json.email }}',
34
        Company: '{{ $json.company }}',
35
        LeadSource: '{{ $json.source }}',
36
        Status: 'New'
37
      }
38
    },
39
    {
40
      type: 'salesforce',
41
      name: 'Create Task',
42
      operation: 'create',
43
      object: 'Task',
44
      fields: {
45
        WhoId: '{{ $node["Create Lead"].json.id }}',
46
        Subject: 'Follow up with new lead',
47
        Priority: 'High',
48
        ActivityDate: '{{ $now.plus(1, "day").toISO() }}'
49
      }
50
    }
51
  ]
52
};

1
// HubSpot CRM automation
2
const hubspotWorkflow = {
3
  name: 'HubSpot Deal Automation',
4

5
  nodes: [
6
    {
7
      type: 'hubspot',
8
      name: 'Get Deals',
9
      operation: 'search',
10
      filters: {
11
        propertyName: 'dealstage',
12
        operator: 'EQ',
13
        value: 'qualifiedtobuy'
14
      }
15
    },
16
    {
17
      type: 'loop',
18
      name: 'Process Each Deal'
19
    },
20
    {
21
      type: 'hubspot',
22
      name: 'Get Contact',
23
      operation: 'get',
24
      resource: 'contact',
25
      id: '{{ $json.properties.associatedContactIds[0] }}'
26
    },
27
    {
28
      type: 'openai',
29
      name: 'Generate Proposal',
30
      prompt: 'Generate a proposal for {{ $json.properties.dealname }}'
31
    },
32
    {
33
      type: 'hubspot',
34
      name: 'Update Deal',
35
      operation: 'update',
36
      resource: 'deal',
37
      properties: {
38
        dealstage: 'proposalsent',
39
        proposal_generated: true,
40
        proposal_date: '{{ $now.toISO() }}'
41
      }
42
    }
43
  ]
44
};