Eliminate inbound lead dropoffs by 80 percent

The moment a form submission lands, your stack starts lying to you: the website says “thanks,” the CRM says “new,” Slack says “someone handle it,” and two days later you’re asking why the demo calendar looks empty. It’s not a lead problem. It’s an intake problem.

This playbook is about building a working inbound intake and qualification system that actually moves work forward, using four tools with hard roles: Webflow as the front door, n8n as the traffic controller, Supabase as the source of truth, and Perplexity as the fast research layer that turns raw leads into actionable context.

Here’s the operational stance: if you can’t replay a lead’s journey step-by-step from submission to booked meeting, you don’t have a pipeline—you have a chain of guesses. And guesses don’t scale.

Webflow collects structured fields, but also captures the messy signals you usually ignore (free-text problem description, company URL, role). n8n pulls that payload, normalizes it, and runs a deterministic routing policy you can version like code. Then it writes every event into Supabase: lead record, enrichment snapshot, status changes, owner assignment, and timestamps. No more “which system is right?” conversations. One table wins.

Perplexity gets invoked only after the lead is stored, so enrichment can fail without losing the lead. It looks up the company, summarizes what they do, flags obvious disqualifiers, and returns a short briefing n8n attaches back to Supabase and pushes to the right human.

The next section will walk step-by-step through: schema design in Supabase, the n8n flow (ingest → validate → store → enrich → route), and the minimum routing rules that stop high-intent leads from rotting in the gap between systems.

Here’s how I’d implement this in a real company with a real bottleneck: the “hot lead, cold follow-up” gap.

Scenario: a B2B analytics startup running Webflow landing pages. They get 15–30 inbound forms/day. The CEO wants every “demo request” answered in 10 minutes. Sales says they never saw half of them. Marketing says Webflow shows conversions. Slack is a graveyard of “someone take this.”

The first attempt is always the same mistake: n8n grabs the Webflow payload, calls Perplexity immediately, waits for enrichment, then posts to Slack. It feels smart. It’s also brittle. One Perplexity timeout and the whole workflow errors out. No Slack alert. No CRM entry. The lead exists only in Webflow. Two days later someone asks, “did we get a form from Northwind?” and nobody can prove it. Where did it go? Good question.

Fix: write first, enrich second. Always.

Step flow I’d ship:
Webflow form submission hits an n8n webhook. n8n validates required fields (email, company, intent type). It normalizes (lowercase email, strip tracking params, parse URL host). Then it inserts into Supabase immediately: leads table row plus an events table row (event_type = submitted, payload = raw JSON, received_at timestamp). If insert fails, n8n retries and alerts ops. Deterministic.

Then enrichment runs async. n8n enqueues a job row in Supabase (enrichment_jobs with status = queued). A second n8n workflow polls queued jobs, calls Perplexity using company_url and free-text problem, stores the response as enrichment_snapshots, and writes an event (event_type = enriched). If Perplexity fails, job status = failed, error saved. Lead still routes.

Routing: a small ruleset. If intent = demo AND role contains founder/VP AND company_size >= 10, assign owner = AE1, push Slack with a one-paragraph brief. If email domain is gmail and message contains “student,” mark as low_priority. Everything else goes to SDR queue. Not perfect. But replayable.

Because the real win isn’t “automation.” It’s being able to answer, exactly, why one lead got a meeting and another silently didn’t.

Here’s the part people skip: turning this “playbook” into something a real team can live with for six months without it becoming a museum of half-working automations.

If we implement this inside an actual company, we need to treat it like a product with owners, contracts, and failure budgets. Start with a single promise: every inbound submission gets a durable ID within 5 seconds. That’s your heartbeat. Everything else is optional. If that heartbeat breaks, nothing downstream matters.

So we operationalize it. We set up a small on-call style loop, even if it’s just one person rotating weekly: if webhook volume drops to zero, if Supabase inserts error above a threshold, if enrichment jobs pile up, you get paged in Slack. Not “someone take this.” An actual named alert with a runbook link: check Webflow form settings, check n8n execution logs, check Supabase connectivity, replay failed executions by lead_id.

Then we add human-safe interfaces. Sales shouldn’t live in Supabase tables, so we give them one view: “Hot Leads Queue” filtered by routing status, SLA timer, and owner. The SLA timer is key; it turns hand-wavy urgency into an operational metric. Every lead gets a next_action_at timestamp. If it’s overdue, it escalates. Quietly at first (DM owner), then loudly (channel + manager). No exceptions.

We also need to be honest about enrichment. Perplexity is a research layer, not a judge. Don’t let it auto-disqualify leads. Let it flag risk: ambiguous industry, likely student, consulting firm, tiny headcount, competitor. Humans make the call, but they make it faster because the context is waiting.

Finally, we version the routing rules like code. Tiny changes create chaos. Put rules in a table with an effective_date and a changelog. When someone asks “why did this go to SDR instead of AE,” you don’t debate. You point to the rule that fired and the exact payload that triggered it. That’s what makes the system feel boring in the best way.