n8n e CRM: automatizzare il processo di vendita end-to-end

Il processo di vendita è pieno di lavoro manuale

Se usi un CRM come HubSpot, Pipedrive o Salesforce, sai che lo strumento da solo non basta. Il vero problema non è registrare i contatti, ma tutto quello che succede intorno: qualificare i lead, assegnarli alla persona giusta, aggiornare gli stage, inviare follow-up al momento giusto, generare report. Queste attività manuali consumano fino al 30% del tempo del team commerciale, tempo che dovrebbe essere speso a parlare con i clienti.

n8n permette di automatizzare l'intero ciclo di vendita, dal primo contatto alla chiusura del deal, mantenendo il CRM come fonte unica di verità.

Architettura: n8n come motore del CRM

Il concetto è semplice: il CRM resta l'interfaccia per il team commerciale, n8n lavora dietro le quinte per automatizzare tutto il lavoro ripetitivo.

Lead entra (form, ads, email)
  -> n8n qualifica e arricchisce
  -> CRM riceve il lead qualificato
  -> n8n gestisce i follow-up automatici
  -> Commerciale interviene quando serve
  -> n8n aggiorna stage e notifica
  -> Deal chiuso -> n8n attiva onboarding

Automazione 1: cattura lead da fonti multiple

Il problema

I lead arrivano da 5-10 canali diversi: form del sito, Meta Ads, Google Ads, LinkedIn, email, telefonate, fiere. Inserirli manualmente nel CRM è lento e spesso si perdono contatti.

Il workflow n8n

Fonti multiple (webhook/polling):
  -> Form sito web (Webhook)
  -> Meta Lead Ads (polling ogni 5 min)
  -> Google Ads conversioni (Webhook)
  -> LinkedIn Lead Gen (polling ogni 15 min)
  -> Email parsed (IMAP trigger)

Per ogni lead:
  -> Normalizza dati (nome, email, telefono, fonte)
  -> Verifica duplicati nel CRM
  -> IF nuovo:
     -> Crea contatto nel CRM
     -> Assegna punteggio iniziale
     -> Trigger workflow di qualificazione
  -> IF esistente:
     -> Aggiorna attività nel CRM
     -> Notifica owner del contatto

Normalizzazione dati

// Nodo Code: standardizza i dati del lead
const raw = $json;

const normalized = {
  first_name: (raw.nome || raw.first_name || raw.firstName || '')
    .trim()
    .replace(/^\w/, c => c.toUpperCase()),
  last_name: (raw.cognome || raw.last_name || raw.lastName || '')
    .trim()
    .replace(/^\w/, c => c.toUpperCase()),
  email: (raw.email || raw.mail || raw.e_mail || '')
    .trim()
    .toLowerCase(),
  phone: (raw.telefono || raw.phone || raw.tel || '')
    .replace(/[^+\d]/g, ''),
  company: raw.azienda || raw.company || raw.organization || '',
  source: raw._source || 'website',
  utm_source: raw.utm_source || '',
  utm_medium: raw.utm_medium || '',
  utm_campaign: raw.utm_campaign || '',
  created_at: new Date().toISOString()
};

// Validazione base
if (!normalized.email || !normalized.email.includes('@')) {
  throw new Error(`Email non valida: ${normalized.email}`);
}

return [{ json: normalized }];

Deduplicazione

// Cerca nel CRM se il contatto esiste già
// Nodo HubSpot/Pipedrive: Search Contacts by email
// Poi nel nodo IF:
$json.results.length === 0  // true = nuovo lead

Automazione 2: lead routing intelligente

Il problema

Assegnare i lead alla persona giusta del team è critico. Un lead assegnato male ha il 50% in meno di probabilità di conversione.

Regole di routing

Ecco le regole più comuni per le PMI italiane:

1. Per zona geografica: lead del Nord Italia a Marco, Centro a Laura, Sud a Giuseppe
2. Per dimensione azienda: enterprise (50+ dipendenti) al senior, PMI al junior
3. Per fonte: lead da partner al referente partner, lead organici al team standard
4. Per prodotto/servizio: a seconda dell'interesse espresso
5. Round robin: distribuzione equa quando non ci sono criteri specifici

Implementazione in n8n

// Nodo Code: logica di routing
const lead = $json;

// Mappa regioni -> commerciali
const geoRouting = {
  'Lombardia': '[email protected]',
  'Piemonte': '[email protected]',
  'Veneto': '[email protected]',
  'Emilia-Romagna': '[email protected]',
  'Toscana': '[email protected]',
  'Lazio': '[email protected]',
  'Umbria': '[email protected]',
  'Campania': '[email protected]',
  'Sicilia': '[email protected]',
  'Puglia': '[email protected]'
};

// Determina regione dal CAP o dalla provincia
const region = lead.region || detectRegion(lead.postal_code);
let assignee = geoRouting[region];

// Override: lead enterprise al senior
if (lead.company_size && lead.company_size > 50) {
  assignee = '[email protected]';
}

// Override: lead da partner
if (lead.source === 'partner_referral') {
  assignee = '[email protected]';
}

// Fallback: round robin
if (!assignee) {
  const team = ['[email protected]', '[email protected]', '[email protected]'];
  const index = Date.now() % team.length;
  assignee = team[index];
}

return [{ json: { ...lead, assignee } }];

Notifica immediata

Quando un lead viene assegnato, il commerciale deve saperlo subito:

Canale Slack #vendite:

Nuovo lead assegnato a @marco

Nome: {{ firstName }} {{ lastName }}
Azienda: {{ company }}
Fonte: {{ source }}
Score: {{ score }}/100

Azioni rapide:
- Profilo CRM: {{ crmUrl }}
- Chiama: {{ phone }}
- Email: {{ email }}

Automazione 3: lead scoring con dati di comportamento

Il problema

Non tutti i lead hanno lo stesso valore. Un visitatore che ha scaricato 3 guide, visitato la pagina prezzi e aperto 5 email ha un potenziale molto diverso da chi ha solo compilato un form.

Il modello di scoring

// Nodo Code: calcola lead score
const lead = $json;
let score = 0;

// Dati demografici (max 40 punti)
if (lead.company) score += 10;
if (lead.job_title && lead.job_title.match(/CEO|CTO|Direttore|Manager/i)) score += 15;
if (lead.company_size > 10) score += 10;
if (lead.company_size > 50) score += 5;

// Comportamento (max 60 punti)
if (lead.pages_visited > 5) score += 10;
if (lead.pricing_page_visited) score += 15;
if (lead.demo_requested) score += 20;
if (lead.downloads > 0) score += 5 * Math.min(lead.downloads, 3);
if (lead.email_opens > 3) score += 5;
if (lead.email_clicks > 1) score += 10;

// Penalità
if (lead.email && lead.email.match(/@(gmail|yahoo|hotmail)\./)) score -= 5;
if (lead.unsubscribed) score -= 20;

// Classificazione
let category;
if (score >= 70) category = 'hot';
else if (score >= 40) category = 'warm';
else if (score >= 20) category = 'cool';
else category = 'cold';

return [{
  json: {
    ...lead,
    score,
    category,
    scored_at: new Date().toISOString()
  }
}];

Azioni basate sullo score

Score	Categoria	Azione
70-100	Hot	Notifica immediata al commerciale, chiamata entro 1 ora
40-69	Warm	Email di nurturing personalizzata, follow-up in 2 giorni
20-39	Cool	Inserimento in sequenza email educativa
0-19	Cold	Nurturing automatico a lungo termine

Automazione 4: follow-up automatici basati sullo stage

Il problema

Il 44% dei commerciali rinuncia dopo il primo follow-up, ma l'80% delle vendite richiede almeno 5 contatti. Le sequenze automatiche risolvono questo problema.

Sequenza per lead warm (score 40-69)

Giorno 0: Email di benvenuto personalizzata
  -> Attendi 2 giorni
  -> Verifica: ha aperto l'email?
  -> IF si:
     Giorno 2: Email con case study del suo settore
     -> Attendi 3 giorni
     Giorno 5: Email con invito a demo
     -> Attendi 2 giorni
     Giorno 7: Follow-up telefonico (task al commerciale)
  -> IF no:
     Giorno 3: Re-invio con oggetto diverso
     -> Attendi 4 giorni
     Giorno 7: Ultimo tentativo via LinkedIn

Template email per ogni stage

Stage: "Primo contatto"

Oggetto: {{ company }} + {{ yourCompany }}: una possibilità

Ciao {{ firstName }},

ho notato che hai visitato la nostra pagina {{ lastPage }}.
{{ if industry }}Lavoriamo con diverse aziende nel settore {{ industry }}
e potrei condividere come {{ casestudy_company }} ha ottenuto
{{ casestudy_result }}.{{ endif }}

Hai 15 minuti questa settimana per una breve call?

{{ signature }}

Stage: "Demo richiesta"

Oggetto: La tua demo di {{ product }} è pronta

Ciao {{ firstName }},

grazie per l'interesse in {{ product }}.
Ho preparato una demo personalizzata basata su {{ company }}.

Scegli lo slot che preferisci: {{ calendarLink }}

Nel frattempo, ecco un case study che potrebbe interessarti:
{{ caseStudyLink }}

{{ signature }}

Stage: "Proposta inviata"

Oggetto: La proposta per {{ company }} - prossimi passi

Ciao {{ firstName }},

ti scrivo per verificare se hai avuto modo di leggere la proposta
che ti ho inviato {{ daysAgo }} giorni fa.

Ci sono domande o punti che vorresti approfondire?

Possiamo organizzare una call di 15 minuti per rispondere
a qualsiasi dubbio: {{ calendarLink }}

{{ signature }}

Automazione 5: aggiornamento automatico deal stage

Il problema

I commerciali dimenticano di aggiornare lo stage nel CRM. Questo rende i report inaffidabili e il forecast delle vendite impreciso.

Il workflow

Trigger: eventi multipli
  -> Email risposta ricevuta -> Sposta a "In conversazione"
  -> Demo completata (calendario) -> Sposta a "Demo effettuata"
  -> Proposta aperta (tracking link) -> Sposta a "Proposta in valutazione"
  -> Contratto firmato (DocuSign webhook) -> Sposta a "Chiuso - Vinto"
  -> Nessuna attività per 14 giorni -> Sposta a "Stallo"
  -> Lead ha scritto "non interessato" -> Sposta a "Chiuso - Perso"

Implementazione: rilevamento stallo

// Schedule trigger: ogni giorno alle 8:00
// Cerca deal senza attività negli ultimi 14 giorni

const fourteenDaysAgo = new Date();
fourteenDaysAgo.setDate(fourteenDaysAgo.getDate() - 14);

// Query al CRM: deal aperti con ultima attività prima di 14 giorni fa
// Poi per ogni deal in stallo:

return deals.filter(deal => {
  const lastActivity = new Date(deal.last_activity_date);
  return lastActivity < fourteenDaysAgo
    && deal.stage !== 'closed_won'
    && deal.stage !== 'closed_lost';
}).map(deal => ({
  json: {
    deal_id: deal.id,
    deal_name: deal.title,
    owner: deal.owner_email,
    days_stale: Math.floor(
      (Date.now() - new Date(deal.last_activity_date)) / 86400000
    ),
    value: deal.value
  }
}));

Report stallo settimanale

Ogni lunedi mattina, il direttore commerciale riceve:

Report deal in stallo - Settimana {{ weekNumber }}

Deal senza attività da 14+ giorni:

1. {{ dealName }} - {{ value }} EUR ({{ daysStale }} giorni)
   Owner: {{ owner }}
   Ultimo contatto: {{ lastActivity }}

2. ...

Valore totale a rischio: {{ totalValue }} EUR
Azione consigliata: review con il team entro venerdì

Automazione 6: reporting automatico

Dashboard settimanale

Schedule Trigger (lunedi alle 8:00)
  -> Query CRM: metriche della settimana
  -> Calcola KPI
  -> Genera report
  -> Invia su Slack + email al management

KPI calcolati automaticamente

// Nodo Code: calcola metriche vendite
const deals = $json.deals;
const period = $json.period; // 'week'

const metrics = {
  // Pipeline
  new_leads: deals.filter(d => d.created_this_period).length,
  qualified_leads: deals.filter(d => d.score >= 40).length,
  demos_booked: deals.filter(d => d.stage === 'demo_scheduled').length,
  proposals_sent: deals.filter(d => d.stage === 'proposal_sent').length,

  // Conversioni
  deals_won: deals.filter(d => d.stage === 'closed_won').length,
  deals_lost: deals.filter(d => d.stage === 'closed_lost').length,
  revenue_won: deals
    .filter(d => d.stage === 'closed_won')
    .reduce((sum, d) => sum + d.value, 0),

  // Velocità
  avg_days_to_close: calculateAvgDaysToClose(deals),
  conversion_rate: (
    deals.filter(d => d.stage === 'closed_won').length /
    Math.max(deals.filter(d => d.created_this_period).length, 1) * 100
  ).toFixed(1),

  // Per commerciale
  by_rep: groupByRep(deals)
};

return [{ json: metrics }];

Integrazione specifica: HubSpot

HubSpot è il CRM più diffuso tra le PMI italiane. Ecco come configurare l'integrazione con n8n:

1. Credenziali: usa l'OAuth di HubSpot (più sicuro delle API key)
2. Nodi disponibili: Contact, Company, Deal, Ticket, Engagement
3. Webhook HubSpot: configura i workflow HubSpot per inviare webhook a n8n quando cambiano proprietà specifiche

HubSpot Trigger (contact.propertyChange)
  -> n8n riceve evento
  -> Esegue logica di business
  -> Aggiorna HubSpot via API

Integrazione specifica: Pipedrive

Pipedrive è popolare per la sua semplicità. L'integrazione n8n è nativa:

1. Credenziali: API token dal profilo Pipedrive
2. Nodi: Deal, Person, Organization, Activity, Note
3. Webhook: Pipedrive invia webhook per ogni cambio di stato

Risultati attesi

Con il processo di vendita automatizzato:

• 30% di tempo in più per il team commerciale da dedicare alle conversazioni
• 2x velocità di risposta ai nuovi lead (da ore a minuti)
• 15-20% in più di conversioni grazie a follow-up tempestivi
• Zero lead persi nella transizione tra canali
• Forecast affidabile grazie ad aggiornamenti automatici degli stage
• Visibilità completa su pipeline e performance individuali

---

Vuoi implementare l'automazione del tuo processo di vendita? Contattaci per una consulenza personalizzata.