n8n for the rest of us: lead workflows that don't need an engineer.

The standard premium-brand lead pipeline looks like this: visitor fills a form, the form sends an email to a generic inbox, the founder reads it three hours later (if at all), forwards it to a salesperson, who copies it into HubSpot the next morning. By the time anyone replies, the lead has already booked with a competitor.

This isn't a tooling problem. It's a design problem. You don't need engineers, you don't need a CRM custom-build, you don't need Salesforce. You need n8n and a clear understanding of three things: intent, latency, and observability.

What n8n actually is

n8n is a self-hostable workflow engine. Think Zapier or Make.com, except: you own the data, you pay per execution at roughly 1/10th the cost, and you can run anything you want — webhooks, scripts, conditionals, API calls, AI prompts — in one canvas.

The mental model: a flow is a chain of nodes. Each node receives JSON, does something to it, passes JSON to the next node. A "form submitted" event enters the chain; a "WhatsApp message sent" event exits it. Everything in between is your design.

The five-node lead flow

Here is the exact shape we ship for every WebBrandify client. It runs in under 3 seconds end-to-end, handles failure gracefully, and pings the principal on their phone:

┌─────────────┐    ┌────────────┐    ┌──────────────┐
│  Webhook    │───▶│  Sanitise  │───▶│  Score (AI)  │
│  (lead in)  │    │  (regex)   │    │  Claude API  │
└─────────────┘    └────────────┘    └──────┬───────┘
                                            │
              ┌─────────────────────────────┘
              ▼
       ┌────────────┐    ┌────────────────┐
       │  Route by  │───▶│  CRM (HubSpot) │
       │  intent    │    │  WhatsApp API  │
       └────────────┘    │  Slack #leads  │
                         └────────────────┘

Node 1 · Webhook

The form on your site POSTs JSON to a unique webhook URL. n8n generates this for you. The URL is private; brute-force is impractical. Add Cloudflare WAF rules to reject obviously-malformed payloads if you're paranoid.

Node 2 · Sanitise

Every payload runs through a JavaScript node that strips dangerous patterns: <script> tags, on-event handlers, javascript: URIs, SQL union patterns. Twelve lines of regex, runs in 0.4ms. This is the difference between "we got hacked" and "we sanitised."

Node 3 · Score

The lead JSON gets sent to Claude (or OpenAI) with a prompt: "Given this lead's segment, budget, and note field, return a score from 0-100 and a one-line rationale." The model returns structured JSON, which we attach to the lead object. Now the routing node has signal.

Node 4 · Route by intent

A switch node reads the AI score. Score > 80 → "principal alert" path (instant WhatsApp). Score 50-80 → "normal lead" path (CRM + Slack channel). Score < 50 → "nurture" path (just CRM, no notification). Each path runs in parallel.

Node 5 · Deliver

The terminal nodes are the third-party services. HubSpot's "create contact" endpoint. WhatsApp Business API. Slack incoming webhook. n8n has pre-built nodes for all of these — no API code needed.

The three things that make it production-grade

1. Failure tolerance

Every external API will eventually fail. HubSpot's endpoint will return a 502, WhatsApp will rate-limit, your CRM will be down for maintenance. Wrap every external node in a retry policy (n8n's built-in retry button, 3 attempts, exponential backoff) and a fallback path that at minimum logs the lead to a Google Sheet or fires a "I tried to route this and couldn't" alert.

2. Observability

n8n logs every execution. But that's not enough. You want to know when leads stop coming in, not just when they do. Set up a daily n8n flow that runs at 9am IST and checks: "did we receive at least N leads in the last 24h?" If not, ping yourself. This is how I caught the silent-failure bug I mentioned in the studio essay.

3. Idempotency

If your flow runs twice on the same lead (which happens — n8n retries, webhooks duplicate), you don't want two HubSpot contacts and two WhatsApp pings. Add a "has this lead ID already been processed?" check at the start. Reject duplicates. Trivial node, saves you from explaining to a client why they got 4 pings.

Self-hosting vs. n8n Cloud

Both work. Self-hosting on a $6/mo Hetzner VPS gives you unlimited executions and complete data sovereignty (important for EU/India compliance). n8n Cloud at $20/mo handles updates and uptime for you. For studios, I recommend self-host. For one-off founders just shipping a lead flow, Cloud is fine.

Whichever you pick: back up your workflows weekly. n8n exports them as JSON. Stash them in a private GitHub repo. You'll thank yourself the first time you accidentally delete a node.

Why this matters more than the CRM choice

Founders spend weeks comparing HubSpot vs. Pipedrive vs. Salesforce. None of that matters until your intake layer is solid. The CRM is a database with a UI. The intake layer is what determines whether the database ever gets the data.

Build the n8n flow first. Then pick a CRM. Then plug it in as a terminal node. Reverse this order and you'll spend three months re-engineering the intake every time the CRM choice changes.

Where to start

• Sign up at n8n.io (or self-host on Hetzner with their official Docker image).
• Build the 5-node flow above against a test form. Test it with realistic payloads.
• Add the observability flow (daily "did we get any leads?" check) — this alone is worth shipping the whole system for.
• Document the flow in a Loom video for your future self.

If you want us to ship this for you — automation engineering is a standard line-item in our Build engagements, or available as a stand-alone Sprint. Drop your URL into the free audit and we'll include the recommended flow shape in the verdict.