Kit gratuito / Routing Stack
Routing Stack
Due blueprint in un solo file. La pipeline speed-to-lead a sette stadi e il layer di routing scritti per intero, così la pipeline e il layer che decide a chi va il lead stanno nello stesso documento e usano lo stesso contratto di evento.
Questo stack unisce due kit: il Speed-to-Lead Blueprint Pack per la pipeline, e il Kit di routing lead automatizzato per il layer che decide a chi appartiene il lead. Se non sai quale dei due è rotto, esegui prima il Workflow Audit Kit.
Parte 1 · Speed-to-Lead Blueprint Pack
Sette stadi, una pipeline: dalla cattura all'assegnazione del rep in meno di dieci secondi, con la configurazione e il comportamento in caso di failure scritti nero su bianco.
Ogni compilazione di form, conversione da annuncio e messaggio di chat passa per gli stessi sette stadi: validazione, dedupe, enrichment, scoring, routing e assegnazione. Questo pack è la versione costruibile di quella pipeline. Stadio per stadio, con le chiavi che imposti e il modo in cui ogni stadio fallisce.
La pipeline
Un unico endpoint webhook accetta compilazioni di form, trascrizioni di chat e conversioni da annuncio. I payload vengono normalizzati e controllati sullo schema prima che succeda qualsiasi altra cosa. Da lì il lead si muove da sinistra a destra, poi scrive e notifica.
ingress
|
v
[01 Capture] -> [02 Validation] -> [03 Dedupe] -> [04 Enrich] -> [05 Scoring]
|
v
[07 Assign] <- [06 Router] <- -----------------------------------+
| ^
| +---- conflict resolver (score or territory tie)
v
[CRM write] -> [Notifier: Slack / SMS / Email] -> [Dashboard readback]
dead-letter queue + correlation log on every hop| Stadio | Nome | Compito | Ti dice quando è sbagliato |
|---|---|---|---|
| 01 | Capture | Accetta una forma di evento da ogni sorgente | Il conteggio degli eventi cala o cambia la forma del payload |
| 02 | Validation | Scarta la spazzatura prima che diventi un record | Il tasso di reject sale sopra la baseline |
| 03 | Dedupe | Fai match prima di creare, unisci con una traccia cartacea | I nuovi record esplodono a fronte di traffico stabile |
| 04 | Enrich | Contesto firmografico e di intento in parallelo | Timeout dei provider, il cache hit rate cala |
| 05 | Scoring | Un solo punteggio di fit e comportamento, da 0 a 100 | La distribuzione dei punteggi si sposta senza un cambio di traffico |
| 06 | Router | Territorio, carico e disponibilità in un passaggio | Proprietari irrisolti, conflitti di territorio in coda |
| 07 | Assign | Affida a un rep o a una coda, avvia il timer SLA | Notifica non riconosciuta dentro la finestra |
Guida di costruzione stadio per stadio
Gateway di cattura
Input: form di sito e landing page, webinar e download di contenuti, Facebook Lead Ads, conversioni Google Ads, LinkedIn Lead Gen Forms, trascrizioni di chat Drift o Intercom.
Config: un unico endpoint pubblico. Normalizza ogni sorgente nel tuo contratto di evento interno prima che qualsiasi cosa a valle lo legga. Conserva event_id, correlation_id, idempotency_key, source_system, source_record_id, utm_source, utm_campaign. Conserva il payload grezzo accanto a quello normalizzato.
Guardrail: verifica della firma HMAC sull'endpoint prima dell'elaborazione. Le submission di test non autorizzate sono una vera fonte di record spazzatura.
Comportamento in caso di failure: risposta non-2xx al provider, payload persistito per il replay, alert se il tasso di errore si muove. Budget 150 ms.
Validazione
Input: l'evento normalizzato.
Config: controlli di schema e sanità. Campi obbligatori presenti. Formato email valido. Consenso catturato dove la normativa lo richiede. Campi enum limitati ai valori ammessi. Budget e urgenza controllati contro la lista su cui instradi. Contesto di sessione e UTM passano intatti.
Regola: rifiuta verso una coda di revisione, non scrivere un record parziale. Un contatto creato con un campo obbligatorio vuoto è peggio di nessun contatto, perché la sequenza di follow-up scatterà su dati vecchi.
Comportamento in caso di failure: conteggio dei reject e motivi registrati per campo, la dead-letter queue tiene il payload. Budget 100 ms.
Dedupe (Redis + fuzzy)
Input: evento validato.
Config: match deterministico su email e telefono. Match fuzzy su nome azienda e dominio normalizzato. Chiave Redis su email o telefono normalizzato. Soglia di match fuzzy configurabile. Quando il match è incerto, la coda di revisione vince.
Guardrail: la dedupe gira prima di qualsiasi assegnazione. Due rep che ricevono lo stesso buyer spezzano la pipeline.
Comportamento in caso di failure: log dei candidati, nessuna creazione, alert su match ambigui. Budget 100 ms.
Enrichment
Input: evento deduplicato.
Config: chiamate parallele a provider firmografici e di intento, con timeout rigido. Cache con TTL. Fallback su dati cached quando un provider va in timeout. Il punteggio di fit ha bisogno di dimensione azienda, settore e tecnologia; il punteggio di comportamento ha bisogno di pagine visitate, asset scaricati e campaign touches.
Guardrail: non bloccare mai la pipeline su un provider lento. Servi i dati cached e continua.
Comportamento in caso di failure: circuit breaker si apre, alert, servire i dati cached. Budget 3000 ms.
Scoring
Input: evento arricchito.
Config: un unico punteggio di fit e comportamento da 0 a 100. Fit da dimensione azienda, settore e tecnologia. Comportamento da pagine visitate, asset scaricati e campaign touches. Punteggio composto con pesi configurabili. Etichetta di routing derivata dal punteggio composto.
Guardrail: la distribuzione dei punteggi viene monitorata. Uno spostamento senza cambio di traffico è un segnale.
Comportamento in caso di failure: punteggio rule-based di fallback. Budget 400 ms.
Router
Input: evento con punteggio.
Config: regole di territorio, carico e disponibilità in un passaggio. Il proprietario viene risolto da territorio, linea di servizio e stato del rep. I conflitti vanno al conflict resolver. I lead ad alto valore bypassano la round robin.
Guardrail: nessun proprietario irrisolto. I conflitti vanno in coda, mai persi.
Comportamento in caso di failure: conflict resolver, poi coda manuale. Budget 250 ms.
Assign
Input: evento con proprietario risolto.
Config: scrivi sul CRM con chiave di idempotenza. Associa contatto, azienda, deal e nota. Avvia il timer SLA. Notifica il rep su Slack, SMS o email. Scrivi la riga di audit prima di notificare.
Guardrail: l'alert parte solo dopo che il CRM conferma. Un alert che parte prima della scrittura è una bugia che il team di vendita crederà.
Comportamento in caso di failure: retry, poi DLQ. Budget 300 ms.
Schema dello scenario Make.com
Sequenza di moduli in chiaro. Trattala come la forma della build. La config sopra è ciò che copi dentro. Metti gli error handler su ogni modulo che scrive.
1 Webhook (custom trigger) receives raw payload
2 HTTP: verify HMAC signature reject unsigned calls
3 Tools: set variable event_id, correlation_id, received_at
4 JSON: parse + schema validate required fields, types, enums
5 Router A: valid / invalid
5a Data store: append rejected dead-letter record with reason
5b Router B: match or new
6 Search: CRM contact by email
7 Search: CRM company by domain
8 Search: CRM open deals by contact
9 HTTP: Redis GET normalized key deterministic dedupe hit
10 HTTP: fuzzy score company/domain near match under threshold
11 Router C: create / update / conflict
11a HTTP: Clearbit enrich parallel, hard timeout
11b HTTP: Apollo enrich parallel, hard timeout
11c Tools: merge cached fallback
11d HTTP: scoring service 0 to 100 + routing label
11e Router D: territory + load + owner status
11f HTTP: conflict resolver ties and high-value leads
12 HTTP: CRM create or update idempotency key header
13 HTTP: CRM associate objects contact, company, deal, note
14 Data store: append audit row before, after, rule, owner
15 Slack: priority alert to rep
16 SMS / email: fallback channel
17 Error handler (attached to 4,9,11a,11b,11d,12,15)
-> HTTP: alert on-call
-> Data store: append failure with correlation_id
-> route to DLQ for replayMetti un token bucket davanti al CRM. Le operazioni bulk contro un tetto di 100 richieste al minuto lanceranno 429 nel momento in cui vai live con volume reale. Gestiscilo con concorrenza, backoff esponenziale e jitter invece di un semplice loop di retry.
Esempi di payload webhook
Cattura in ingresso (dalla sorgente al tuo endpoint)
{
"event_id": "sub_01HYT9C7M4",
"source_system": "tally",
"source_record_id": "audit_request",
"received_at": "2026-04-26T10:17:33.884Z",
"email": "[email protected]",
"phone": "+39 051 000 0000",
"full_name": "Elena Moretti",
"company_name": "Example Srl",
"company_domain": "example.com",
"budget_range": "5000_15000",
"urgency": "high",
"pain_summary": "Form submissions create duplicate contacts and never route to an owner.",
"consent_to_contact": true,
"utm_source": "linkedin",
"utm_campaign": "revops_q2",
"raw_payload_stored": true
}Contratto interno normalizzato (ogni sorgente mappa qui)
{
"event_id": "sub_01HYT9C7M4",
"correlation_id": "corr_lead_01HYT9C7M4",
"idempotency_key": "lead_intake:tally:audit_request:sub_01HYT9C7M4:[email protected]",
"source_system": "tally",
"source_record_id": "audit_request",
"email": "[email protected]",
"phone": "+39 051 000 0000",
"company_domain": "example.com",
"budget_range": "5000_15000",
"urgency": "high",
"pain_summary": "Form submissions create duplicate contacts and never route to an owner.",
"consent_to_contact": true,
"utm_source": "linkedin",
"utm_campaign": "revops_q2"
}Record post-stadio (ciò che riceve il CRM)
{
"correlation_id": "corr_lead_01HYT9C7M4",
"dedupe": {
"match_type": "deterministic_email",
"existing_contact_id": "123456789",
"action": "update_existing"
},
"enrichment": {
"status": "cached",
"sources": ["clearbit", "apollo"],
"employees": 120,
"industry": "software"
},
"score": { "total": 82, "fit": 74, "behaviour": 90 },
"routing": {
"label": "sales_priority",
"rule": "budget_5000_15000_and_urgency_high",
"owner_id": "987654321",
"owner_status": "active",
"territory": "italy_north"
},
"controls": {
"queue": "crm_revenue_events",
"retry_policy": "exponential_backoff_with_jitter",
"dead_letter_queue": "crm_failed_workflow_events",
"replay_safe": true
}
}Budget di latenza
Misurato stadio per stadio invece che stimato alla fine. Ogni stadio ha un tetto rigido. Se uno stadio supera il tetto, quello è l'alert.
| Stadio | Budget (ms) | Misurato a | In caso di superamento |
|---|---|---|---|
| Gateway di cattura | 150 | Entrata endpoint a evento normalizzato | Page se il p95 supera per 5 min |
| Validazione | 100 | Inizio controllo schema a pass o reject | Log dei motivi di reject, alert sul tasso |
| Lookup dedupe | 100 | Redis GET più confronto fuzzy | Alert sul tasso di cache miss |
| Enrichment (con timeout) | 3000 | Inizio chiamata parallela all'ultimo provider di ritorno | Circuit breaker, servi i dati cached |
| Scoring | 400 | Input assemblati a punteggio restituito | Punteggio rule-based di fallback |
| Router | 250 | Inizio regole a proprietario risolto | Conflict resolver, poi coda manuale |
| Assign | 300 | Proprietario risolto a ack di scrittura CRM | Retry, poi DLQ |
| Scrittura CRM | 900 | Richiesta API a risposta | Backoff, token bucket shed |
| Notifica | 400 | Ack di scrittura ad accettazione provider | Page on-call, non fare rollback |
| Dashboard readback | 200 | Scrittura a visibile sulla vista del rep | Avviso, non bloccante |
| Retry e allowance coda | 2000 | Peggior caso di un ciclo di retry | Dead-letter con correlation ID |
| Totale tipico | 7800 | Cattura ad assegnazione riconosciuta | Tetto rigido 10000 |
Il margine fino al tetto è deliberato. Assorbe un ciclo di retry e un provider lento.
Soglie di alert
Le soglie sono configurazione. Impostale prima del lancio, scrivi a chi paginano, e rivedile dopo il primo mese di traffico reale.
| Segnale | Soglia | Finestra | Azione |
|---|---|---|---|
| Tasso di errore endpoint di cattura | > 1% | 5 minuti | Page on-call, controlla la delivery del provider |
| Tasso di reject schema | > 3% | 15 minuti | Alert, scarica i motivi di reject per campo |
| p95 da cattura ad assegnazione | > 10000 ms | 15 minuti | Avviso prima, page se sostenuto per 1 ora |
| p95 di stadio sopra budget | > 1.5x budget | 15 minuti | Avviso che nomina lo stadio |
| Timeout provider di enrichment | > 10% | 15 minuti | Apri il circuito, servi i dati cached, alert |
| Cache hit rate | < 60% | 1 ora | Avviso, rivedi TTL e lista warm |
| Record duplicati creati | > 0 all'ora | 1 ora | Page, congela solo il passaggio di creazione |
| Proprietario o territorio irrisolto | > 0 | 15 minuti | Instrada alla coda manuale, alert ops |
| Notifica non riconosciuta | Primaria 60 s, secondaria 300 s | Per lead | Scala la catena automaticamente |
| Profondità dead-letter queue | > 0 per 10 minuti | 10 minuti | Page con payload e correlation ID |
| Risposte 429 del CRM | > 0 sostenuto | 5 minuti | Shed load, abbassa la concorrenza, alert |
Checklist di revisione settimanale
- Ogni elemento della dead-letter della settimana ha un proprietario e una decisione: replay, fix o drop.
- Le unioni di duplicati riviste, ognuna registrata con i suoi input.
- Conteggio delle escalation e trend del tempo di risoluzione.
- Le soglie di alert ricalibrate sui dati reali.
Piano di rollout
| Finestra | Build | Criterio di uscita |
|---|---|---|
| Settimane 1 e 2 | Strumentazione e dedupe | Tempi di risposta baseline misurati. Dedupe live sulla sorgente di lead a volume più alto. |
| Settimane 3 e 4 | Enrichment e scoring | Provider collegati, cache warm, scoring allenato sulle conversioni storiche. |
| Settimana 5 | Routing e notifica | Regole di territorio, catene di escalation e alert Slack o SMS funzionanti end to end. |
| Settimane 6 a 8 | Load test e cutover | Load test a volume pieno e drill di failure, poi ogni sorgente rimanente passa. |
Ordine di build se non puoi farlo tutto insieme
- Cattura e validazione. Un endpoint, un contratto, reject visibili.
- Dedupe. Cercare prima di creare batte ogni pulizia a valle.
- Assegnazione e notifica. Anche un router rozzo batte l'assenza di router.
- Percorso di failure. Dead-letter queue, correlation log, alert che paginano.
- Enrichment e scoring. Aggiungili quando i layer noiosi sono affidabili.
Gli stadi sopra il percorso di scrittura proteggono il record. Enrichment e scoring rendono il record più intelligente, non più corretto. Correggi la correttezza prima.
FAQ
Questo sostituisce il systems blueprint?
No. Il blueprint spiega l'architettura. Questo pack è la versione costruibile. Porta le chiavi e l'ordine dei moduli, più i payload, i budget e le soglie.
Quali strumenti di orchestrazione assume?
Make.com per lo schema, dato che gestisce bene iteratori annidati e gestione degli errori. Zapier, n8n e receiver API custom mappano sugli stessi confini di stadio.
E se il mio volume è piccolo adesso?
Mantieni gli stessi confini di stadio. Riduci i budget, tieni la dead-letter queue. Il volume cambia il dimensionamento. La forma resta la stessa.
Dove entra l'AI?
Classificando testo di pain disordinato, urgenza e fit nello scoring, con una lista chiusa di output ammessi e validazione sulla scelta. Il percorso di routing finale riceve comunque uno schema rigido.
Cosa succede dopo. Quando il pack non basta, gli stessi sistemi vengono consegnati come engagement per clienti. Il lavoro copre build speed-to-lead, revisione di CRM e workflow API, sistemi di qualificazione lead e workflow di produzione monitorati.
Parte 2 · Automated Lead Routing: ogni lead di proprietà in meno di dieci secondi
Ho scritto questo layer di routing per un firm che gestiva dodici canali di intake su tre sedi. Ottieni il payload del contratto e l'ordine di priorità. L'oggetto decisione esce da quelli, e la coda di failure cattura ciò che resta irrisolto.
Questo è il layer di routing che ricostruisco perché ogni lead che arriva al tuo CRM abbia un proprietario allegato. Stesso contratto, stesso ordine di priorità, stesso oggetto decisione che installo per i clienti. Lavora le sezioni in ordine. L'ordine è l'architettura.
Prima di iniziare
Ogni lead non piazzato affiora nella coda di failure con il suo motivo. Il form scatta, il CRM crea un contatto, la dashboard mostra attività. Poi il campo proprietario resta vuoto, il deal si apre in un'altra pipeline, e la sequenza di follow-up attende un campo di routing arrivato come null. La coda di failure lo cattura prima che la finestra di follow-up si chiuda.
Ho scritto questo layer per Meridian Legal Group, un firm che gestiva dodici canali di intake su tre sedi. La loro istanza HubSpot era diventata un cimitero di dati, con migliaia di contatti duplicati, lead assegnati a caso e timer SLA che giravano su carta. La ricostruzione parte un layer sotto gli alert. Parte dal contratto.
Sistema la proprietà prima di toccare la velocità. Dieci secondi di proprietà contano solo quando il rep può agire. Fai l'inventario del contratto prima di cambiare qualsiasi workflow. Scrivi cosa il form invia mentre è ancora vero.
Sezione 1 · Il contratto di routing che il tuo form deve inviare
Il routing inizia prima del CRM. Ogni sorgente, da un Typeform a un widget di chat a un foglio referral, deve atterrare in un payload stabile. Il motore di routing instrada solo ciò che il form invia. Blocca prima i nomi dei campi. Tutto a valle si appoggia a quei nomi.
Tabella 1A · Campi del contratto di routing (compila i vuoti)
Nomi API stabili che sopravvivono alle etichette di visualizzazione. L'etichetta UI del CRM cambia ogni volta che qualcuno rinomina una proprietà. Il contratto resta fisso.
| Campo del contratto | Tipo | Obbligatorio | Da dove viene | Cosa si rompe senza |
|---|---|---|---|---|
| event_id | string | sì | Generato all'intake | I retry creano assegnazioni duplicate |
| correlation_id | string | sì | Generato all'intake | Nessuna traccia end-to-end tra sistemi |
| idempotency_key | string | sì | source_system + source_record_id + email | Il replay assegna lo stesso lead due volte |
| source_system | enum | sì | Form, piattaforma ad, chat, import | Il routing per campagna non ha nulla su cui appoggiarsi |
| string | sì | Campo del form | La dedupe non trova match, quindi la risoluzione del proprietario si ferma. | |
| phone | string | sì* | Campo del form | Seconda chiave di match sparita, percorso SMS morto |
| company_domain | string | sì* | Dominio del sito o form | Il routing per territorio non ha nulla su cui appoggiarsi |
| service_requested | enum | sì | Selezione del form | Il routing per linea di servizio si ferma |
| territory | string | sì* | Form, IP o account | Il routing per territorio si ferma |
| budget_range | enum | sì* | Selezione del form | Il routing per priorità non ha nulla su cui appoggiarsi |
| urgency | enum | sì* | Selezione del form | Il routing per priorità non ha nulla su cui appoggiarsi |
| lead_score | integer | no | Calcolato a valle | Nessuna etichetta di priorità |
| existing_customer | boolean | sì* | Lookup CRM | La regola del cliente esistente non scatta |
| open_deal_exists | boolean | sì* | Lookup CRM | La regola del deal aperto non scatta |
| consent_to_contact | boolean | sì | Checkbox del form | Il canale di follow-up si blocca |
| utm_source | string | no | Parametro URL | Attribuzione persa |
| utm_campaign | string | no | Parametro URL | Attribuzione persa |
| pain_summary | string | no | Campo libero del form | Il contesto per il rep è perso |
Esempio di payload del contratto
event_id "evt_01J8XK2M9Q"
source_system "web_form"
source_record_id "submission_8841"
received_at "2026-10-19T14:22:08.418Z"
email "[email protected]"
phone "+15551234567"
company_domain "example.com"
service_requested "crm_workflow_repair"
territory "europe"
budget_range "5000_15000"
urgency "high"
lead_score 82
existing_customer false
open_deal_exists false
consent_to_contact true
utm_source "google"
utm_campaign "crm_workflow_cluster"
pain_summary "Owner assignment fails on web leads. High-intent buyers wait."Tabella 1B · Audit delle sorgenti: ogni canale onora il contratto?
Percorri ogni canale di intake e segna cosa invia. Un canale che non riesce a riempire un campo obbligatorio va sul percorso della coda di failure nella Sezione 5.
| Sistema sorgente | Campi obbligatori presenti | Campi che non può inviare | Proprietario / percorso di fallback |
|---|---|---|---|
| Form di contatto Tally | tutti gli obbligatori | nessuno | n/a |
| Form di chat | email, company_domain | phone, budget_range | coda di revisione per i campi mancanti |
| Import foglio referral | email, company_domain | urgency, consent | coda di revisione per i campi mancanti |
Il nome del contratto è il nome API. service_requested è il contratto. "Con cosa possiamo aiutarti?" è un'etichetta di form che qualcuno rinominerà il prossimo trimestre. Mappa le etichette ai campi del contratto al bordo, davanti al router.
Sezione 2 · Ordine di priorità: la relazione esistente batte il round robin
La maggior parte degli stack ha cinque regole di routing che si combattono. Il territorio dice un proprietario, la linea di servizio ne dice un altro, la campagna ne dice un altro, il round robin ne dice un altro. Senza un ordine di priorità fisso, il routing diventa casuale con passaggi in più. Questa è la gerarchia che installo. Leggila dall'alto verso il basso. La prima regola che fa match vince.
Tabella 2A · La gerarchia di priorità
| Ordine | Regola | Instrada a | Perché sta qui |
|---|---|---|---|
| 1 | Filtro spam e dati di contatto non validi | Log dei reject, mai il CRM | La spazzatura non deve raggiungere una coda umana |
| 2 | Cliente esistente | Proprietario di record esistente | La continuità batte la distribuzione |
| 3 | Deal aperto già esistente | Proprietario del deal corrente | Due proprietari su un buyer spezzano la pipeline |
| 4 | Severità critica o punteggio lead alto | Proprietario prioritario o revisione del founder | L'intento batte la geografia |
| 5 | Territorio o sede dell'ufficio | Proprietario del territorio | Proprietà locale prima dei pool generici |
| 6 | Linea di servizio o expertise | Proprietario di practice o prodotto | Lo specialista giusto, non il rep più vicino |
| 7 | Sorgente della campagna | Proprietario della campagna | I percorsi sensibili all'attribuzione restano intatti |
| 8 | Pool round robin | Prossimo rep attivo nella rotazione | Solo per lead genuinamente non reclamati |
| 9 | Nessun match | Coda di revisione manuale | I lead irrisolti non spariscono mai |
Il round robin è l'ultima regola, non la prima. Un lead che torna da un cliente esistente va al proprietario di record. Un lead che tocca un deal aperto va al proprietario del deal. Solo i lead genuinamente nuovi entrano nella rotazione. Questo è il fix che risolve la maggior parte dei problemi di ownership.
Sezione 3 · L'oggetto decisione, scritto una volta, eseguito ovunque
Costruisci la decisione prima che qualsiasi azione CRM venga eseguita. Il motore di regole produce un oggetto contro uno schema. Qualsiasi executor lo consuma, che sia Make, Zapier, n8n, un workflow HubSpot, un flusso GoHighLevel o un layer API custom. L'executor non decide. Esegue una decisione che esiste già.
Schema dell'oggetto decisione di routing
{
"routing_status": "assigned",
"routing_tier": "priority",
"target_owner_id": "user_789",
"target_team": "europe_intake",
"target_pipeline": "new_matter_intake",
"target_stage": "qualified_diagnostic",
"follow_up_sequence": "speed_to_lead_priority",
"manual_review_required": false,
"routing_reason": "Lead score 82, high urgency, service line crm_workflow_repair, territory europe, no open deal, owner capacity available.",
"trace": {
"event_id": "evt_01J8XK2M9Q",
"correlation_id": "corr_route_01J8XK2M9Q",
"idempotency_key": "lead_route:web_form:submission_8841:[email protected]"
}
}Tabella 3A · Campi dell'oggetto decisione
| Campo | Valori ammessi | Impostato da | Consumato da |
|---|---|---|---|
| routing_status | assigned | review | rejected | motore di regole | executor, audit log |
| routing_tier | priority | standard | review | punteggio lead e urgenza | selettore sequenza di follow-up |
| target_owner_id | ID utente CRM | riga gerarchia da 2 a 8 | scrittura proprietario CRM |
| routing_reason | frase umana | motore di regole | nota CRM, contesto vendite |
| manual_review_required | true | false | policy di failure | coda di revisione |
Tabella 3B · Template di routing_reason (compilane uno per riga della gerarchia)
Le vendite devono sapere perché il lead è atterrato lì. Una ragione scritta trasforma un'assegnazione misteriosa in una decisione ispezionabile. Usa una frase per riga, nominando l'evidenza che ha scattato.
| Riga della gerarchia | Template della ragione | Esempio compilato |
|---|---|---|
| 2 cliente esistente | Cliente esistente, proprietario di record è {owner_id}, relazione dal {date}. | Cliente esistente, proprietario di record è user_112, relazione dal 2024. |
| 3 deal aperto | ||
| 4 severità critica | ||
| 5 territorio | ||
| 6 linea di servizio | ||
| 7 campagna | ||
| 8 round robin | ||
| 9 revisione manuale |
Sezione 4 · Valida il proprietario, scrivi sul CRM, poi avvisa
L'ordine conta più della velocità qui. Deduplica prima dell'assegnazione, mai dopo. Valida il proprietario e lo stato della pipeline prima della scrittura. Invia l'alert solo dopo che il CRM conferma. Un alert che parte prima della scrittura è una bugia che il team di vendita crederà.
Conserva l'evento grezzo
Cosa controllo: il payload grezzo atterra nello storage prima che qualsiasi trasformazione venga eseguita.
Evidenza da raccogliere: il payload archiviato con event_id e received_at intatti.
Condizione di passaggio: ogni evento sorgente è ricostruibile anche se la catena fallisce a metà volo.
Failure comune: il gestore del webhook parsa prima e non conserva mai. Poi un cambio di payload del vendor distrugge le evidenze.
Deduplica prima dell'assegnazione
Cosa controllo: la ricerca di contatto e azienda gira prima che qualsiasi proprietario venga risolto.
Evidenza da raccogliere: risultati di match per email, telefono, dominio aziendale e lookup deal aperti.
Condizione di passaggio: un umano, un record contatto, un proprietario. I match esistenti aggiornano invece di creare.
Failure comune: instrada prima, deduplica dopo. Due rep ricevono lo stesso buyer e la pipeline si spezza.
Valida proprietario e stato della pipeline
Cosa controllo: il proprietario target esiste, è attivo, ha il team e il territorio giusti, e può ricevere questa sorgente.
Evidenza da raccogliere: risposta stato proprietario, esistenza pipeline, esistenza stadio, controllo deal aperti.
Condizione di passaggio: target_owner_id risolve a un utente live e target_pipeline / target_stage esistono entrambi.
Failure comune: un utente è uscito e il CRM ha mantenuto l'ID vivo. I lead si accumulano su un proprietario fantasma.
Scrivi sul CRM
Cosa controllo: la creazione o l'aggiornamento del CRM con chiave di idempotenza, poi l'associazione di contatto, azienda, deal e nota.
Evidenza da raccogliere: ID oggetto CRM, conferma di associazione, riga di audit.
Condizione di passaggio: una scrittura, un record, un proprietario. La chiave di idempotenza rende il replay sicuro.
Failure comune: scrivi due volte perché il provider ha ritentato. La chiave di idempotenza previene il secondo.
Avvisa dopo la conferma
Cosa controllo: l'alert parte solo dopo che il CRM conferma la scrittura.
Evidenza da raccogliere: timestamp di conferma CRM, timestamp di notifica.
Condizione di passaggio: notifica dopo conferma, sempre.
Failure comune: l'alert parte prima della scrittura. Il rep apre il CRM e il lead non c'è.
Sezione 5 · Coda di failure, ragione di routing, traccia di audit
Un routing fallito non deve mai sparire. Atterra in una coda di revisione con il payload grezzo e il tentativo di decisione. La ragione dell'errore e un'opzione di replay stanno accanto. È la sezione che trasforma "il lead è sparito" in una ricerca di cinque minuti.
Tabella 5A · Regole della coda di failure
| Trigger | Azione sulla coda | Comportamento di idempotenza | Passaggio umano |
|---|---|---|---|
| Email e telefono mancanti | manual_review | stessa chiave, nessuna creazione | l'operatore arricchisce o rifiuta |
| Candidati duplicati ambigui | manual_review | stessa chiave, nessuna creazione | l'operatore unisce o divide |
| Proprietario inattivo o sconosciuto | |||
| Pipeline o stadio mancante | |||
| Territorio non valido | |||
| Classificazione a bassa confidenza | |||
| Conflitto di retry del webhook | |||
| Errore API CRM dopo i tentativi massimi |
Formato della chiave di idempotenza
Una chiave per evento sorgente. La chiave è ciò che rende il replay sicuro: stessa chiave, stessa decisione, nessuna seconda assegnazione. Calcolala al bordo e falla scorrere in ogni scrittura.
idempotency_key = source_system + ":" + source_record_id + ":" + normalized_email
Esempio:
lead_route:web_form:submission_8841:[email protected]
Regola di replay:
if idempotency_key already assigned -> return existing owner_id, write nothing
if idempotency_key in flight -> return 409 to the provider, let it retry
if idempotency_key unknown -> run the full path from Step 1Tabella 5B · Campi della traccia di audit (ciò che ogni esecuzione conserva)
| Campo | Contiene | Perché un sales manager lo chiede |
|---|---|---|
| event_id | Un evento sorgente, un id | "Mostrami la submission esatta." |
| correlation_id | Collega l'evento tra sistemi | "Dove si è fermato questo lead?" |
| idempotency_key | Handle di dedupe e replay | "Perché questo contatto è qui due volte?" |
| routing_reason | Frase umana dietro l'assegnazione | "Perché è andato a Elena?" |
Blocco della policy di failure
failure_policy:
missing_contact_data -> manual_review
ambiguous_duplicate -> manual_review
inactive_owner -> fallback_owner_then_review
pipeline_missing -> stop_and_alert_operator
crm_api_rate_limit -> retry_with_backoff
invalid_ai_output -> manual_review
max_attempts -> 5
dead_letter_queue -> lead_routing_failed_events
observability:
store_raw_payload true
store_normalized_lead true
store_routing_decision true
store_crm_object_ids true
store_owner_assignment_reason true
enable_safe_replay trueChecklist di replay e revisione
- Ogni failure atterra da qualche parte di visibile: payload grezzo, tentativo di decisione, ragione dell'errore, proprietario nominato della coda.
- Il replay è idempotente: rieseguire la stessa
idempotency_keynon crea mai una seconda assegnazione di proprietario. - I tentativi massimi sono limitati: un evento bloccato va nella dead-letter queue invece di ritentare per sempre.
- I rate limit rallentano la coda: le risposte 429 del CRM fanno backoff invece di scartare i payload.
- La revisione manuale ha un SLA: un umano legge la coda secondo un calendario.
- La ragione di routing è conservata col record: le vendite possono leggere perché il lead è atterrato lì senza chiedere a ops.
Il firm ora gestisce dodici canali di intake su tre sedi, e i lead ricevono un proprietario entro dieci secondi dall'invio. Ogni assegnazione è ispezionabile attraverso la traccia di audit. I timer SLA che non esistevano ora scalano da soli. La ricostruzione è stata solo il layer di routing.
Dove si inserisce questo kit
Inizia qui se la pipeline non esiste ancora: il Speed-to-Lead Blueprint Pack è il blueprint di ingresso. Copre cattura, validazione, dedupe, enrichment, scoring, routing e assegnazione come un'unica pipeline. Questo kit è il layer di routing scritto per intero.
Se i duplicati sono il vero problema: vai sul CRM Automation Repair Kit. Unire contatti duplicati, correggere associazioni e mappare i campi ricadono tutti sotto il routing. Sistema il layer dei dati prima di aggiungere altre regole.
Per la build di produzione: Sistemare la pipeline è l'engagement che consegna il modello di scoring, il layer di routing e la coda di failure come un unico sistema. La prova è il case study Meridian Legal Group: dodici canali di intake, tre sedi, assegnazione entro dieci secondi.
Sezione 6 · FAQ
Devo ricostruire tutto il CRM per usare questo?
No. Il kit è il layer di routing. Porta il contratto, la gerarchia e l'oggetto decisione, più i gate di validazione e la coda di failure. Si posa davanti a qualsiasi CRM tu abbia già. Il CRM resta. Cambia la logica di proprietà.
E se il mio form invia solo parte del contratto?
Allora quella sorgente passa per il percorso di failure per quei campi, mentre il router resta sulle sue regole. La Tabella 1B è dove registri i gap. Un intake diagnostico breve con estrazione dietro uno schema rigido è di solito il fix più pulito di un form più lungo.
Dove sta la dedupe nella catena?
Prima dell'assegnazione, sempre. Cerca il contatto per email e telefono, l'azienda per dominio, e cerca deal aperti prima che qualsiasi proprietario si risolva. La dedupe dopo l'assegnazione crea due proprietari su un buyer e spezza la pipeline.
Make, Zapier e n8n possono tutti eseguire questo oggetto decisione?
Sì. È il punto di scrivere la decisione una volta sola. L'executor legge target_owner_id, target_pipeline, target_stage e routing_reason ed esegue le scritture. Scambia l'executor senza riscrivere una sola regola.
Cosa succede quando il routing non trova un proprietario da validare?
Il lead va nella coda di revisione manuale con il suo payload grezzo, il tentativo di decisione e la ragione dell'errore. Ogni lead mantiene il suo posto in coda col payload allegato. Irrisolto è uno stato con un proprietario e una coda dietro.
Puoi costruirlo per la mia firm?
Sì. Il kit sta in piedi da solo. Lo stesso routing lo costruisco come engagement per clienti: contratto, gerarchia, oggetto decisione, gate di validazione e coda di failure, consegnati come un unico sistema.
Ottieni il workbook compilabile
Tutto ciò che è sopra è tuo da leggere. Il workbook aggiunge i worksheet vuoti, così li compili sul tuo stack con i tuoi proprietari, campi e failure. Si apre in qualsiasi browser, su qualsiasi dispositivo, e salva mentre scrivi.