A lead that submits your form at 9pm and gets a reply at 10am tomorrow is a lead your competitor, who replied at 9:04pm, has a fair chance of taking. The data on this is boringly consistent: response inside five minutes dramatically outperforms response inside an hour. This is the automation that gets you there — the same one we deploy for every small sales team we work with.

What you’re building

The complete flow, in one picture:

Lead source (form/ad/platform)
  → intake normalization
  → dedup against CRM
  → scoring (simple rules)
  → assignment (round-robin or rules)
  → instant notification + auto-acknowledgement
  → escalation timer if nobody acts within X minutes

It looks like a lot. In practice it’s one Make scenario (or n8n workflow) with 8-12 modules, built in about 90 minutes the first time and 30 minutes for every team after.

Why routing beats “we check the form a few times a day”

Three failure modes of manual lead handling, all eliminated by this flow:

  1. The overnight/weekend gap. Leads arrive when leads want to arrive. The automation doesn’t sleep.
  2. The ding-a-ling problem. A form notification among 200 emails gets seen in 40 minutes or not at all. A Slack ping to a named person with the lead’s details gets seen immediately.
  3. The forgotten follow-up. A lead acknowledged once and never contacted again. The escalation timer makes this structurally impossible.

Step 1: One intake trigger per source

Start with your single highest-volume lead source — don’t build five integrations on day one. If it’s a web form (Typeform, Tally, native website form), use the native integration. If leads arrive by email (many industry directories and marketplaces still work this way), trigger on Gmail/Outlook with a sender+subject filter, and parse fields like we did in the Gmail-to-Sheets guide — the parsing machinery is identical.

Normalize the output: everything downstream wants the same shape — {name, email, phone, source, message, timestamp} — regardless of which source it came from. One module per source that outputs the normalized shape, and the rest of the flow never knows or cares where a lead came from.

Step 2: Deduplicate before anything else

New lead → search CRM (or sheet) for existing record by email. Three outcomes, each routed differently:

  • Exact match exists → this is a returning lead: update the “last contact requested” timestamp, route to the existing owner, skip the scoring-for-new step.
  • No match → proceed.
  • Fuzzy match (same domain, different person — e.g., second person from the same company) → proceed as new lead but tag same-domain-existing-contact for the assignee to see.

Skipping the dedup step doesn’t save time; it guarantees the embarrassing “hi, nice to meet you!” email to someone your colleague spoke with last week. Build the dedup step.

Step 3: Score with rules, not vibes

For small teams, simple additive scoring beats any ML pitch:

+30  company email domain (not gmail/yahoo/etc.)
+20  message mentions budget or timeline
+20  source = referral
+10  phone number provided
+10  title contains decision-maker words
-20  message contains "student" / "homework" / "for a class"

Where do these numbers come from? Ours are calibrated from roughly a year of closed-won/closed-lost data on small B2B pipelines — adjust to your reality. The point isn’t mathematical precision; it’s that a number lets you route high-temperature leads to humans fast and let the lukewarm ones queue for batch follow-up.

Implementation: one router module with five filters, or a single formula module. Either tool supports it in native no-code.

Step 4: Assign a human

Two viable patterns for teams under ~10 people:

Round-robin: increment a counter in a small tracking sheet, assign to sales[ N mod team_size ]. Simple, fair, done in one module.

Territory rules: by geography, company size, or product line — a router with your rules. More setup, better fit when your reps have genuine specializations.

Do not build anything smarter than this. Lead-assignment ML for a 5-person team is procrastination with a data science flavor. This whole step should take 20 minutes.

Step 5: The notification that actually gets seen

This is where the 5-minute goal is won or lost. New high-score lead → Slack mobile push to the assigned rep’s DM, with the lead’s name, company, message excerpt, and a one-tap link to the CRM record. Also (not instead): an auto-acknowledgement email to the lead — “Hi {name}, got your note — {rep} will reach out shortly” — because the acknowledgement is what the lead experiences while your rep finds a quiet moment.

The acknowledgement email is boring and doubles reply rates when the rep follows up. Send it from your domain, not a no-reply black hole, and you’ve already improved on 60% of the market.

Step 6: The escalation timer

Here’s the part nobody builds and everybody needs. The lead was assigned — but what if the rep is on a train through a tunnel?

Use your automation tool’s sleep/resume or scheduled-delay capability: after assignment, schedule a follow-up check in 15 minutes. If the CRM record still shows status = uncontacted (the rep updates status on contact), then: (a) notify the rep again with escalation language, (b) after another interval, notify the manager or roll to the backup rep.

In Make this is a second scenario triggered by “watch records” + a filter on status + a time-since condition; in n8n it’s a Wait node inside the same workflow. Either way, the effect is a system that notices neglect on its own — the difference between “we have a process” and “we have a hope.”

A worked example: the two-week turnaround

The first team we deployed this exact system for was a four-person B2B software consultancy. Their before-state is the one we find almost everywhere: leads arrived in a shared inbox from three sources (website form, a directory listing, occasional referrals via email), someone checked “when they got a chance,” and the median first response time was 14 hours. Overnight and weekend leads — which their directory source produced plenty of — waited until Monday morning. Nobody knew how many leads they’d lost, because nobody was counting.

The build took an afternoon. We normalized their two form sources (one native integration, one email-parse — the machinery from our Gmail-to-Sheets guide handles the email one), set up round-robin assignment across two reps, wrote the scoring rules with the founder in 30 minutes, and configured the escalation timer at 15 minutes with the founder as the second-level escalation.

The first week was calibration, running in shadow mode: the automation logged its routing decisions while the team kept working manually. That week surfaced two rules we’d gotten wrong — directory leads were scoring lower than their close rate justified, and the “company domain” signal was worth more than we’d guessed. We tuned the scores, cut over, and let it run.

The numbers after 90 days: median response time went from 14 hours to 4 minutes (the acknowledgement email fires within seconds; the rep’s real reply median was 47 minutes — the automation buys speed, the rep still has to buy the conversation). Contact rate — the share of leads actually reached by a human within 24 hours — went from 71% to 96%, and the gap was almost entirely overnight and weekend leads. The founder’s summary after a quarter: “we didn’t sell more because we got better at selling; we sold more because we stopped starting conversations three days late.”

The escalation timer fired 11 times in 90 days — a rep on a call, one phone stolen by a toddler, one genuine on a train through a tunnel. Eleven leads that would have previously waited unknowingly got contacted anyway. That’s the part of the system nobody notices until it saves them.

Troubleshooting checklist

When lead routing misbehaves, the failure is almost always in one of four places:

  • Symptom: leads arriving but no notification. Cause: the intake normalization broke — usually a form source changed a field name, so the normalized shape has nulls and the router filters everything out. Fix: add a “null check” branch that flags malformed leads to a Slack channel instead of dropping them; never let a filter silently discard data.
  • Symptom: same lead assigned to two reps. Cause: the dedup search ran before a previous run’s row committed, or the counter sheet (for round-robin) raced between two simultaneous leads. Fix: rare, but if you see it twice in a month, add a one-second delay before the assignment step or switch the counter to an auto-increment sheet column.
  • Symptom: rep notifications arriving but acknowledgement emails not sending. Cause: the email module’s “from” address isn’t verified on your domain — the send fails and, depending on error settings, fails quietly. Fix: verify the sending domain (SPF/DKIM and your automation tool’s sender verification) on day one; this is the most common “why is our automation half-working” ticket we get.
  • Symptom: escalation timer never fires even for genuinely neglected leads. Cause: the status field the timer checks isn’t being updated by the reps, so every lead looks “uncontacted” and the filter logic inverts. Fix: pick a status convention the reps will actually maintain (“contacted = any logged call/email”) and make updating it a one-click action in the CRM; a monitoring rule nobody maintains is worse than none because it provides false confidence.

For reference, our production version in Make:

Stage Modules
Intake (per source) 2 × number of sources
Dedup + search 2
Scoring + routing 3
Assignment 2
Notifications (Slack + email) 3
Acknowledgement email 1
Escalation scenario 4

Roughly 15-20 operations per lead. At 300 leads a month, that’s ~5,000 operations — Make Core ($9) covers it with room. This is not an expensive automation; it’s cheaper than the coffee budget of the sales team it protects.

Where teams take it next

  • Ad platform webhooks as additional intake sources (the normalized-shape pattern makes each new source a 20-minute addition)
  • Enrichment (company size, industry) inserted between dedup and scoring, which sharpens the routing rules
  • Speed-to-lead reporting: the sheet already records submission and contact timestamps, so a monthly “median minutes to first touch” number falls out for free — and it’s the single metric that makes this whole system’s value legible to management

Build the core loop first. Everything above is incremental afterthought; the intake-dedup-route-notify-escalate spine is what ensures no lead ever goes cold again.