5 posts tagged with "automation"

const ICP_CRITERIA = {
  firmographic: {
    employeeRange: { min: 50, max: 1000, weight: 0.2 },
    revenueRange: { min: 5000000, max: 100000000, weight: 0.15 },
    industries: {
      include: ['SaaS', 'Technology', 'Financial Services', 'Healthcare'],
      exclude: ['Government', 'Education'],
      weight: 0.15
    },
    geographies: {
      include: ['US', 'Canada', 'UK', 'Germany'],
      weight: 0.05
    }
  },
  
  technographic: {
    required: ['Salesforce', 'HubSpot'],
    positive: ['Outreach', 'SalesLoft', 'Gong'],
    negative: ['Competitor X', 'Legacy CRM'],
    weight: 0.15
  },
  
  departmentSignals: {
    hasSalesTeam: { minSize: 5, weight: 0.1 },
    hasMarketingTeam: { minSize: 2, weight: 0.05 },
    hasRevOps: { weight: 0.1 }
  }
};

async function aggregateAccountData(companyId) {
  // CRM data
  const crmData = await crm.getCompany(companyId);
  const contacts = await crm.getContacts({ companyId });
  const deals = await crm.getDeals({ companyId });
  const activities = await crm.getActivities({ companyId });
  
  // Enrichment data
  const enrichment = await clearbit.enrich(crmData.domain);
  const techStack = await builtwith.getTechStack(crmData.domain);
  
  // Website behavior
  const webActivity = await analytics.getCompanyActivity(companyId, {
    days: 30
  });
  
  // Email engagement
  const emailEngagement = await emailPlatform.getEngagement(companyId);
  
  // Social signals
  const linkedInActivity = await linkedin.getCompanySignals(crmData.domain);
  
  // News and events
  const recentNews = await newsApi.getCompanyNews(crmData.name, { days: 90 });
  
  // Competitor mentions
  const competitorSignals = await detectCompetitorActivity(companyId);
  
  return {
    company: crmData,
    contacts,
    deals,
    activities,
    enrichment,
    techStack,
    webActivity,
    emailEngagement,
    linkedInActivity,
    recentNews,
    competitorSignals
  };
}

async function scoreAccount(accountData) {
  // Calculate structured scores
  const icpScore = calculateICPScore(accountData, ICP_CRITERIA);
  const engagementScore = calculateEngagementScore(accountData);
  const intentScore = calculateIntentScore(accountData);
  
  // Use Claude for qualitative analysis
  const qualitativeAnalysis = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1000,
    system: `You are a B2B sales strategist analyzing accounts for 
prioritization. You excel at identifying hidden buying signals and 
assessing account quality beyond basic metrics.

Provide:
1. OPPORTUNITY_SCORE (0-100): Likelihood to close
2. VALUE_SCORE (0-100): Potential deal size relative to effort
3. TIMING_SCORE (0-100): Urgency/readiness to buy
4. KEY_INSIGHTS: 2-3 critical observations
5. RECOMMENDED_APPROACH: Best first touch strategy`,
    messages: [{
      role: 'user',
      content: `Analyze this account for prioritization:

COMPANY: ${accountData.company.name}
INDUSTRY: ${accountData.enrichment.industry}
SIZE: ${accountData.enrichment.employeeCount} employees
REVENUE: $${accountData.enrichment.annualRevenue}
TECH STACK: ${accountData.techStack.join(', ')}

RECENT ACTIVITY:
- Website visits: ${accountData.webActivity.pageviews} (${accountData.webActivity.uniqueVisitors} unique)
- Pages viewed: ${accountData.webActivity.topPages.join(', ')}
- Email engagement: ${accountData.emailEngagement.openRate}% open, ${accountData.emailEngagement.clickRate}% click
- Last activity: ${accountData.webActivity.lastActivity}

CONTACTS:
${accountData.contacts.map(c => `- ${c.name} (${c.title}): ${c.engagementScore} engagement`).join('\n')}

RECENT NEWS:
${accountData.recentNews.map(n => `- ${n.headline}`).join('\n')}

COMPETITOR SIGNALS:
${accountData.competitorSignals.length > 0 ? accountData.competitorSignals.join('\n') : 'None detected'}

RELATIONSHIP HISTORY:
- Previous deals: ${accountData.deals.length}
- Total activities: ${accountData.activities.length}
- Last touch: ${accountData.activities[0]?.date || 'Never'}

Provide your analysis as JSON.`
    }],
    response_format: { type: 'json_object' }
  });
  
  const aiAnalysis = JSON.parse(qualitativeAnalysis.content[0].text);
  
  // Combine all scores
  return {
    companyId: accountData.company.id,
    companyName: accountData.company.name,
    scores: {
      icp: icpScore,
      engagement: engagementScore,
      intent: intentScore,
      opportunity: aiAnalysis.OPPORTUNITY_SCORE,
      value: aiAnalysis.VALUE_SCORE,
      timing: aiAnalysis.TIMING_SCORE
    },
    composite: calculateComposite({
      icp: icpScore,
      engagement: engagementScore,
      intent: intentScore,
      ...aiAnalysis
    }),
    insights: aiAnalysis.KEY_INSIGHTS,
    recommendedApproach: aiAnalysis.RECOMMENDED_APPROACH,
    tier: determineTier(/* composite score */)
  };
}

function calculateComposite(scores) {
  // Weighted combination
  return (
    scores.icp * 0.2 +
    scores.engagement * 0.15 +
    scores.intent * 0.25 +
    scores.OPPORTUNITY_SCORE * 0.2 +
    scores.VALUE_SCORE * 0.1 +
    scores.TIMING_SCORE * 0.1
  );
}

async function generateDailyPrioritization(repId) {
  // Get rep's assigned accounts
  const accounts = await crm.getAccountsByRep(repId);
  
  // Score all accounts (parallelize for speed)
  const scoredAccounts = await Promise.all(
    accounts.map(async account => {
      const data = await aggregateAccountData(account.id);
      return scoreAccount(data);
    })
  );
  
  // Sort by composite score
  const ranked = scoredAccounts.sort((a, b) => b.composite - a.composite);
  
  // Assign daily tiers
  const dailyList = {
    mustTouch: ranked.slice(0, 5).map(addContactReason),
    highPriority: ranked.slice(5, 15).map(addContactReason),
    standard: ranked.slice(15, 50).map(addContactReason),
    nurture: ranked.slice(50).map(addContactReason)
  };
  
  // Push to CRM and Slack
  await crm.updateDailyPriorities(repId, dailyList);
  await slack.sendDM(repId, formatPriorityList(dailyList));
  
  return dailyList;
}

function addContactReason(account) {
  return {
    ...account,
    whyNow: generateWhyNow(account),
    suggestedAction: getSuggestedAction(account),
    talkingPoints: getTalkingPoints(account)
  };
}

async function logPrioritizationOutcome(accountId, outcome) {
  const originalScore = await getHistoricalScore(accountId);
  
  await analyticsDb.log({
    accountId,
    scoredAt: originalScore.timestamp,
    composite: originalScore.composite,
    outcome: outcome, // 'converted', 'stalled', 'lost', 'disqualified'
    daysToOutcome: daysBetween(originalScore.timestamp, new Date()),
    dealValue: outcome === 'converted' ? await getDealValue(accountId) : null
  });
  
  // Quarterly: Retrain weights based on what actually converted
  if (isQuarterEnd()) {
    await retrainScoringWeights();
  }
}

async function retrainScoringWeights() {
  const outcomes = await analyticsDb.getOutcomes({ months: 6 });
  
  // Analyze which factors actually predicted conversions
  const analysis = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    messages: [{
      role: 'user',
      content: `Analyze these prioritization outcomes and recommend 
weight adjustments:

CONVERSIONS:
${outcomes.filter(o => o.outcome === 'converted').map(summarize).join('\n')}

LOSSES:
${outcomes.filter(o => o.outcome === 'lost').map(summarize).join('\n')}

Current weights: ${JSON.stringify(currentWeights)}

What factors were most predictive? Recommend new weights.`
    }]
  });
  
  // Update scoring algorithm
  await updateScoringWeights(analysis);
}

// 7am daily
cron.schedule('0 7 * * *', async () => {
  const reps = await crm.getActiveReps();
  
  for (const rep of reps) {
    const priorities = await generateDailyPrioritization(rep.id);
    
    await slack.sendDM(rep.slackId, {
      blocks: [
        {
          type: 'header',
          text: `🎯 Your Priority Accounts for Today`
        },
        {
          type: 'section',
          text: `*Must Touch (5 accounts)*\n${priorities.mustTouch.map(a => 
            `• *${a.companyName}* (Score: ${a.composite}) — ${a.whyNow}`
          ).join('\n')}`
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: 'View Full List',
              url: `https://crm.com/priorities/${rep.id}`
            }
          ]
        }
      ]
    });
  }
});

async function syncToCRM(priorities) {
  for (const account of [...priorities.mustTouch, ...priorities.highPriority]) {
    await crm.updateCompany(account.companyId, {
      priority_tier: account.tier,
      ai_score: account.composite,
      last_scored: new Date(),
      recommended_action: account.suggestedAction,
      score_reasoning: account.insights.join(' | ')
    });
    
    // Create task if high priority
    if (account.tier === 'mustTouch') {
      await crm.createTask({
        companyId: account.companyId,
        subject: `Priority Touch: ${account.companyName}`,
        notes: account.whyNow,
        dueDate: new Date()
      });
    }
  }
}

// Real-time triggers
async function handleSignificantEvent(event) {
  const { accountId, eventType, data } = event;
  
  const significantEvents = [
    'pricing_page_visit',
    'competitor_search',
    'demo_request',
    'executive_engagement',
    'funding_announcement'
  ];
  
  if (significantEvents.includes(eventType)) {
    // Immediately rescore
    const newScore = await scoreAccount(await aggregateAccountData(accountId));
    
    // If jumped to Tier 1, alert immediately
    if (newScore.tier === 'mustTouch' && (await getPreviousTier(accountId)) !== 'mustTouch') {
      await sendUrgentAlert(accountId, newScore, event);
    }
  }
}

async function sendUrgentAlert(accountId, score, triggerEvent) {
  const rep = await crm.getAccountOwner(accountId);
  
  await slack.sendDM(rep.slackId, {
    text: `🚨 *HOT ACCOUNT ALERT*\n\n*${score.companyName}* just jumped to Tier 1!\n\nTrigger: ${triggerEvent.eventType}\n${score.whyNow}\n\nDrop what you're doing. This one's live.`
  });
}

// Process incoming transcript
async function processTranscript(transcript, meetingMetadata) {
  // Extract structured data using Claude
  const extraction = await claude.analyze({
    model: 'claude-3-5-sonnet',
    system: EXTRACTION_PROMPT,
    messages: [
      {
        role: 'user',
        content: `Meeting: ${meetingMetadata.title}
                  Date: ${meetingMetadata.date}
                  Attendees: ${meetingMetadata.attendees.join(', ')}
                  
                  Transcript:
                  ${transcript}`
      }
    ],
    response_format: { type: 'json_object' }
  });

  // Update CRM
  await hubspot.updateDeal(meetingMetadata.dealId, {
    notes: extraction.crmNotes,
    next_step: extraction.actionItems[0]?.task,
    last_meeting_date: meetingMetadata.date
  });

  // Create tasks for our action items
  for (const item of extraction.actionItems.filter(a => a.owner === 'us')) {
    await hubspot.createTask({
      subject: item.task,
      dueDate: item.dueDate || addDays(new Date(), 2),
      associatedDealId: meetingMetadata.dealId
    });
  }

  // Draft follow-up email
  await gmail.createDraft({
    to: meetingMetadata.prospectEmail,
    subject: extraction.followUpEmail.subject,
    body: extraction.followUpEmail.body
  });

  // Notify rep
  await slack.sendMessage({
    channel: meetingMetadata.repSlackId,
    text: formatSummary(extraction)
  });
  
  return extraction;
}

// Webhook handler for Zoom recording completion
app.post('/webhooks/zoom', async (req, res) => {
  const { recording_files, topic, start_time, participants } = req.body.payload;
  
  // Find transcript file
  const transcriptFile = recording_files.find(f => f.file_type === 'TRANSCRIPT');
  
  if (transcriptFile) {
    const transcript = await downloadZoomTranscript(transcriptFile.download_url);
    await processTranscript(transcript, {
      title: topic,
      date: start_time,
      attendees: participants.map(p => p.name)
    });
  }
  
  res.sendStatus(200);
});

// Poll Gong for completed calls
async function pollGongCalls() {
  const recentCalls = await gong.getCalls({
    fromDateTime: subtractHours(new Date(), 1),
    toDateTime: new Date()
  });
  
  for (const call of recentCalls) {
    if (call.transcript && !processedCalls.has(call.id)) {
      await processTranscript(call.transcript, {
        title: call.title,
        date: call.started,
        attendees: call.parties.map(p => p.name),
        dealId: call.crmData?.dealId
      });
      processedCalls.add(call.id);
    }
  }
}

// Fireflies webhook for transcript ready
app.post('/webhooks/fireflies', async (req, res) => {
  const { transcript_url, meeting_title, attendees, date } = req.body;
  
  const transcript = await fetch(transcript_url).then(r => r.text());
  
  await processTranscript(transcript, {
    title: meeting_title,
    date: date,
    attendees: attendees
  });
  
  res.sendStatus(200);
});

// Analyze overall meeting sentiment
const sentimentAnalysis = await claude.analyze({
  messages: [{
    role: 'user',
    content: `Analyze the prospect's sentiment in this meeting. 
              Rate their engagement (1-10), buying intent (1-10), 
              and urgency (1-10). 
              
              Transcript: ${transcript}`
  }]
});

// Adjust follow-up timing based on sentiment
const followUpDelay = calculateDelay(sentimentAnalysis);

function calculateDelay({ engagement, buyingIntent, urgency }) {
  const score = (engagement + buyingIntent + urgency) / 3;
  
  if (score >= 8) return 'immediate';  // Hot lead - same day
  if (score >= 6) return 'next_day';   // Warm - next business day
  if (score >= 4) return '2_days';     // Neutral - give them space
  return '3_days';                      // Cool - longer nurture
}

// Identify primary and secondary contacts
const roles = await claude.analyze({
  messages: [{
    role: 'user',
    content: `Based on this transcript, identify:
              1. Primary decision maker
              2. Technical evaluator (if present)
              3. Champion/internal advocate (if present)
              
              For each, extract their key concerns and interests.
              
              Transcript: ${transcript}`
  }]
});

// Create tailored follow-ups for each stakeholder
for (const stakeholder of roles.identified) {
  await createPersonalizedFollowUp(stakeholder);
}

if (extraction.actionItems.length === 0) {
  // Create a "check-in" follow-up task
  await hubspot.createTask({
    subject: `Check-in: ${meetingMetadata.prospectCompany} - No clear next steps`,
    dueDate: addDays(new Date(), 3),
    notes: `Meeting ended without clear next steps. 
            Reach out to re-engage or close as stalled.
            
            Key topics discussed: ${extraction.keyTopics.join(', ')}`
  });
  
  // Alert rep to the ambiguity
  await slack.sendMessage({
    channel: meetingMetadata.repSlackId,
    text: `⚠️ No clear next steps from your call with ${meetingMetadata.prospectName}. 
           Review the summary and decide: pursue or pause?`
  });
}

const OBJECTION_CATEGORIES = [
  { id: 'price', patterns: ['too expensive', 'budget', 'cost', 'cheaper', 'price'], severity: 'high' },
  { id: 'timing', patterns: ['not right now', 'next quarter', 'not ready', 'too soon'], severity: 'medium' },
  { id: 'competition', patterns: ['looking at', 'comparing', 'competitor', 'other options'], severity: 'high' },
  { id: 'authority', patterns: ['need to talk to', 'not my decision', 'get approval', 'run it by'], severity: 'medium' },
  { id: 'trust', patterns: ['never heard of', 'new company', 'references', 'case studies'], severity: 'low' },
  { id: 'status_quo', patterns: ['we\'re fine', 'not broken', 'current solution works', 'happy with'], severity: 'high' },
  { id: 'urgency', patterns: ['think about it', 'get back to you', 'need time', 'not urgent'], severity: 'critical' }
];

async function detectObjection(transcript) {
  // First pass: pattern matching for speed
  for (const category of OBJECTION_CATEGORIES) {
    const pattern = new RegExp(category.patterns.join('|'), 'i');
    if (pattern.test(transcript.latestUtterance)) {
      return { detected: true, category: category.id, severity: category.severity };
    }
  }
  
  // Second pass: AI classification for nuanced objections
  const classification = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 200,
    messages: [{
      role: 'user',
      content: `Is this an objection? If so, classify it:
      
      "${transcript.latestUtterance}"
      
      Categories: price, timing, competition, authority, trust, status_quo, urgency, none
      
      Output JSON: { "isObjection": boolean, "category": string, "severity": "low"|"medium"|"high"|"critical" }`
    }]
  });
  
  return JSON.parse(classification.content[0].text);
}

async function gatherObjectionContext(dealId, objection) {
  // Get deal and contact info
  const deal = await crm.getDeal(dealId);
  const contact = await crm.getContact(deal.primaryContactId);
  const company = await crm.getCompany(deal.companyId);
  
  // Get conversation history
  const previousCalls = await crm.getCallNotes(dealId);
  const emails = await crm.getEmails(dealId);
  
  // Find similar objections that were overcome
  const successfulHandles = await objectionDb.find({
    category: objection.category,
    industry: company.industry,
    outcome: 'overcome'
  });
  
  // Get competitor intel if competition objection
  let competitorIntel = null;
  if (objection.category === 'competition') {
    const mentioned = extractCompetitorMentions(previousCalls);
    competitorIntel = await getCompetitorBattlecards(mentioned);
  }
  
  return {
    deal,
    contact,
    company,
    conversationHistory: [...previousCalls, ...emails],
    successfulHandles,
    competitorIntel,
    currentCallTranscript: objection.transcript
  };
}

async function generateObjectionResponse(objection, context) {
  const systemPrompt = `You are a world-class sales coach generating 
real-time objection handling scripts. Your responses:

1. ACKNOWLEDGE the concern (don't dismiss or argue)
2. CLARIFY to understand the real issue
3. RESPOND with context-specific evidence
4. ADVANCE toward next steps

Guidelines:
- Keep total response under 30 seconds of speaking time (~75 words)
- Use the prospect's exact language when possible
- Reference specific things from their situation
- Include one concrete data point or example
- End with a question that moves forward

NEVER:
- Sound scripted or robotic
- Use generic platitudes
- Argue or get defensive
- Ignore the emotional component`;

  const response = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 500,
    system: systemPrompt,
    messages: [{
      role: 'user',
      content: `Generate an objection response for this situation:

OBJECTION CATEGORY: ${objection.category}
EXACT WORDS: "${objection.exactPhrase}"

PROSPECT CONTEXT:
- Name: ${context.contact.name}
- Title: ${context.contact.title}
- Company: ${context.company.name} (${context.company.industry})
- Company Size: ${context.company.employeeCount}
- Deal Value: $${context.deal.amount}

CONVERSATION CONTEXT:
- Stage: ${context.deal.stage}
- Days in pipeline: ${context.deal.daysInPipeline}
- Previous objections overcome: ${context.conversationHistory.filter(c => c.objectionOvercome).length}

${context.competitorIntel ? `COMPETITOR MENTIONED: ${context.competitorIntel.name}
Key Differentiator: ${context.competitorIntel.primaryDifferentiator}` : ''}

SUCCESSFUL HANDLES FOR SIMILAR SITUATIONS:
${context.successfulHandles.slice(0, 2).map(h => 
  `- "${h.objection}" → Response: "${h.response}" → Outcome: ${h.outcome}`
).join('\n')}

Generate a natural, conversational response the rep can use RIGHT NOW.`
    }]
  });
  
  return {
    script: response.content[0].text,
    category: objection.category,
    followUpQuestions: await generateFollowUps(objection, context),
    resources: await findRelevantResources(objection, context)
  };
}

// Option 1: Screen overlay
async function overlayDelivery(response, sessionId) {
  await callAssistant.showOverlay(sessionId, {
    type: 'objection_response',
    category: response.category,
    script: response.script,
    followUps: response.followUpQuestions,
    ttl: 60000 // Visible for 60 seconds
  });
}

// Option 2: Slack whisper
async function slackDelivery(response, repId) {
  await slack.sendDM(repId, {
    text: `🎯 *Objection Detected: ${response.category}*\n\n${response.script}`,
    attachments: [{
      title: 'Follow-up Questions',
      text: response.followUpQuestions.join('\n• ')
    }]
  });
}

// Option 3: Voice whisper (for phone calls)
async function voiceWhisper(response, callSessionId) {
  // Text-to-speech through the rep's earpiece
  await twilio.whisper(callSessionId, {
    text: `Objection: ${response.category}. Try: ${response.script.substring(0, 100)}`,
    voice: 'concise'
  });
}