n8n-flow

Inbound lead triage and routing with n8n + Claude

Difficulty

intermediate

Setup time

90min

For

revops · sdr-leader

RevOps

Stack

An n8n flow that catches every inbound demo request the moment it lands, scores it against your ICP rubric with Claude, enriches it with firmographic data, and routes it to a self-serve flow, an SDR queue by territory, or a Slack page to the AE on call. The bundle at apps/web/public/artifacts/inbound-lead-triage-n8n/ ships the complete export plus a _README.md covering import, credential setup, and per-branch verification.

When to use this

Use it when you have a meaningful volume of inbound demo requests — roughly 50+ per week — and SDRs are spending real time on leads that should never have hit a human, or letting genuinely high-intent leads sit in a queue while they work older ones first-in-first-out. The symptom that justifies building this is uneven response time: your best leads waiting hours behind your worst.

It’s also the right pattern when your ICP rubric is opinionated enough that two SDRs would score the same lead differently. Once the rubric lives in a single Markdown doc that Claude reads on every call, scoring becomes consistent across submissions and reviewable as a single artifact.

When NOT to use this

Skip it if you get fewer than ~10 inbound demo requests per week. At that volume the SDR routing decision is faster done by hand, and you’ll spend more time maintaining the flow than it saves. The fixed cost of credential rotation, rubric drift audits, and the inevitable 3am Slack page about a Claude timeout outweighs the per-lead win.

Also skip it if your ICP is genuinely undefined. The flow is a multiplier on your rubric — if “good lead” is whatever the SDR manager felt that morning, automating it just freezes that day’s bias into 10,000 routings. Write the rubric down first; automate it second.

Finally, don’t use this if your sales motion is strictly product-led and your “demo request” form is really an account-creation prompt in disguise. In that case the right pattern is in-product activation triggers, not a triage layer pretending the form is the entry point.

Setup

Import the bundle. Drop apps/web/public/artifacts/inbound-lead-triage-n8n/inbound-lead-triage-n8n.json into n8n via Workflows → Import from File. The flow has two entry points: a webhook for the real-time path and a daily cron for the backstop sweep.
Wire HubSpot. Create the four custom contact properties listed in _README.md (icp_score__c, icp_score_reasoning__c, icp_pain_hypothesis__c, icp_scoring_method__c). Set up a HubSpot workflow that POSTs to /webhook/inbound-lead-triage whenever a contact submits a demo-request form, passing contactId and the form context.
Configure Claude. Set the n8n workflow variable ICP_RUBRIC to your rubric Markdown (keep it under ~2k tokens — it ships in every call). The default model is claude-haiku-4-5; the prompt enforces JSON-only output and explicit fallback rules for missing data and free-mail addresses.
Set territory rules. Populate the Google Sheet referenced by PLACEHOLDER_TERRITORY_SHEET_ID with one row per country plus a * default row. Required columns: country, sdr_email, sdr_owner_id, sdr_slack_handle, ae_email, ae_owner_id, ae_slack_handle.
Verify every branch. Walk the five-step verification in _README.md (low score, mid score, high score, Claude failure, backstop). Only enable the HubSpot trigger after all five pass.

What the flow does

The webhook accepts the HubSpot form-submit payload and immediately returns 202 so the form submission is never blocked on enrichment or scoring. Normalize Payload (a Code node) flattens the HubSpot envelope into a single JSON shape, lowercases the email, extracts the domain, and flags free-mail providers from a hard-coded set so downstream nodes never have to re-derive that signal.

Apollo — Enrich Domain calls Apollo’s organization-enrich endpoint with an 8s timeout and neverError: true. Failures don’t stop the flow — they just produce a payload with enrichmentOk: false, which the scoring step is told to treat as a 1-point penalty. Merge Lead + Firmographics combines the normalized lead and the enrichment into the bundle Claude sees.

Claude — Score Lead posts to https://api.anthropic.com/v1/messages with claude-haiku-4-5, a 6s timeout, and a system prompt that enforces a single JSON object with score, reasoning, primary_pain_hypothesis, and disqualifiers. The prompt explicitly tells Claude to bias the score down by 1 when firmographics are missing and to cap free-mail addresses at 4 unless the form responses prove a real role — both rules belong in the prompt rather than the code so they’re auditable in one place.

Parse Score (with fallback) is the most important node. It tries to parse Claude’s JSON; if parsing fails or the score is missing, it computes a deterministic score from headcount + job title + free-mail status. The output always carries scoringMethod: "claude" or "rule-based" so the weekly audit can spot when fallback usage is creeping up.

HubSpot — Upsert Score writes score, reasoning, pain hypothesis, and method back to the contact so SDRs see why a lead landed in their queue, not just that it did. Route by Score is a Switch node with three explicit branches plus an unrouted fallback: score < 4 goes to self-serve nurture, 4-7 goes to the SDR queue (after a Sheets — Territory Lookup), 8+ pages the AE in #inbound-hot, and anything that falls through alerts ops in #inbound-ops-alerts.

The second entry point — Nightly Backstop Cron at 02:15 — searches HubSpot for any subscriber-stage contact with a recent_conversion_date in the last 26 hours and no icp_score__c, then replays each one through the webhook with batched calls (batchSize: 5, batchInterval: 2000ms) so the catch-up doesn’t burn rate limits.

Cost reality

Per lead, with claude-haiku-4-5, a typical scoring call is roughly 1.2k input tokens (rubric + lead bundle) and 200 output tokens. At Haiku 4.5’s pricing that’s around $0.0015 per lead. Apollo’s organization-enrich at the Basic tier is roughly $0.01-$0.05 per credit depending on plan; budget $0.02 per lead as a planning number. n8n self-hosted is free; n8n Cloud Starter is $20/month and easily handles 10k executions.

For a team taking 1,000 inbound demo requests a month, total marginal cost is under $25/month for Claude + Apollo combined. The non-marginal cost is the SDR-leader hour per week to audit a sample of scored leads and tune the rubric — which is what makes this work at all, not what makes it expensive.

Success metric

The metric to watch is median time-to-first-touch on score-8+ leads. Before this flow, that number is dominated by SDR queue depth and time-of-day. After, it should drop to under 5 minutes during business hours because the AE is paged in Slack with full context the moment the form is submitted.

A secondary metric is percent of inbound that reaches a human. If the flow is honest, that number drops 30-50% (low-score leads now go to nurture instead of an SDR queue), and the SDR-converted rate on the leads that do reach a human should rise correspondingly. If you see the first move without the second, your rubric is filtering wrong.

vs alternatives

vs DIY Python script on a cron. A cron-driven script polling HubSpot every 5 minutes adds 5 minutes of latency on the worst case and 2.5 on average, which kills the whole point of paging on high-intent leads. The webhook-driven n8n flow is sub-second on the happy path. You also get the n8n execution log as a free observability layer instead of debugging a script’s stdout.

vs HubSpot Workflows + Operations Hub. HubSpot can route by static rules (country, deal size, form fields) but can’t call Claude with a rubric and parse structured JSON without a Custom Code Action — and once you’re writing custom code in HubSpot, you’ve lost the visibility and credential management you’d get from n8n. Operations Hub Professional is also $800/month before you’ve written a line of logic.

vs an off-the-shelf lead-router (Chili Piper, Distribute, RevenueHero). These are excellent at the routing-and-meeting-booking step and worth buying if booking on the first touch is your motion. They are not good at “score the lead with my rubric before deciding what to do with it” — that’s the job this flow does, and the two compose cleanly: route here, then hand high-score leads to Chili Piper for the booking experience.

Watch-outs

Webhook reliability. HubSpot’s outgoing webhooks fail silently on retry exhaustion. Guard: the Nightly Backstop Cron sweeps for any subscriber-stage contact with a recent conversion in the last 26 hours and no icp_score__c, replaying each through the same webhook. If you see backstop catches above ~2% of daily volume, escalate to HubSpot support — that’s a real reliability problem, not a tuning issue.
Claude latency or malformed JSON. Inbounds need fast routing; Claude can occasionally take 5+ seconds or return prose around the JSON. Guard: the Claude — Score Lead node has a 6s timeout and neverError: true, and Parse Score (with fallback) falls back to a deterministic rule-based score (headcount + job title + free-mail) tagged with scoringMethod: "rule-based" in HubSpot. Audit the rate weekly — if rule-based usage exceeds 5% of runs, the model or the prompt needs fixing, not the threshold.
Score gaming and rubric drift. Reps will quickly learn what triggers a high score and complain when their pet leads score low. Guard: a weekly 10-lead audit by the SDR leader, comparing Claude’s score and reasoning against the leader’s blind score. If disagreement is above 30%, rewrite the rubric — don’t tweak the threshold.
Free-mail leakage. Self-employed senior buyers do submit from gmail.com addresses, and a hard cap at 4 misses them. Guard: the cap is enforced in the prompt rather than the code, and the prompt allows Claude to override the cap if the form responses prove a real role. Re-check that override rate quarterly — if it’s near zero, your form isn’t asking the right question.
Territory sheet drift. A new country in inbound traffic with no row in the sheet causes the lookup to return empty and the Switch node’s unrouted branch to fire. Guard: the unrouted branch posts to #inbound-ops-alerts with the score and method so ops sees the gap immediately, instead of leads silently failing to route.

Stack

n8n — webhook ingress, enrichment orchestration, routing, and the nightly backstop cron
HubSpot — source of inbound, destination for the enriched and scored contact, and the lookup target for the backstop sweep
Claude (Haiku 4.5) — ICP scoring with reasoning, structured JSON output, deterministic prompt-side rules for missing data and free-mail caps
Apollo — firmographic enrichment by domain (industry, headcount, technologies)
Google Sheets — territory routing rules, editable by the SDR leader without touching n8n
Slack — high-intent paging in #inbound-hot and ops alerts in #inbound-ops-alerts

Edit this page on GitHub

Files in this artifact

Download all (.zip)

# Inbound lead triage and routing — n8n flow

This bundle contains a complete n8n workflow that triages every inbound demo request the moment it lands. A HubSpot form submission fires a webhook, the flow normalizes the payload, enriches the company via Apollo, asks Claude to score the lead against your ICP rubric (with a rule-based fallback if Claude is slow or returns malformed JSON), writes the score back to HubSpot, and routes the contact to one of four destinations: self-serve nurture, SDR queue by territory, AE Slack page, or an ops alert if anything looks wrong.

A second independent trigger — a nightly cron — sweeps HubSpot for any demo-submission contact created in the last 26 hours that has no `icp_score__c` property and replays it through the webhook. This is the backstop for silent webhook failures.

## What this flow does

The flow has two entry points:

- **Real-time path** — `Webhook — HubSpot Form Submit` accepts `POST /webhook/inbound-lead-triage`, immediately returns 202 to HubSpot so the form submission is never blocked, and processes the lead asynchronously.
- **Nightly backstop** — `Nightly Backstop Cron` (02:15 daily) finds any HubSpot contact in `subscriber` lifecycle stage with a `recent_conversion_date` in the last 26 hours and no `icp_score__c`, then replays each through the webhook with `batchSize: 5, batchInterval: 2000ms` so the catch-up doesn't burn through the Apollo or Anthropic rate limits.

The scoring prompt enforces a JSON-only response shape and tells Claude to bias the score down by 1 when firmographics are missing and to cap free-mail addresses at 4 unless the form responses prove a real role. If Claude times out (6s) or returns anything other than parseable JSON, the `Parse Score (with fallback)` Code node computes a deterministic score from headcount + job title + free-mail status so the flow never strands a lead.

## Import

1. In n8n, open **Workflows → Import from File** and select `inbound-lead-triage-n8n.json`.
2. Open the workflow's **Settings** and confirm `Execution Order` is `v1` and `Timezone` matches your business hours (defaults to `America/New_York`). The cron and the `recent_conversion_date` window both interpret times in this zone.
3. Set the workflow variable `ICP_RUBRIC` (Settings → Variables) to your ICP rubric Markdown. Keep it under ~2k tokens — it ships in every Claude call.
4. Set the environment variable `N8N_SELF_URL` to the public base URL of your n8n instance so the backstop can call its own webhook.
5. Activate the workflow only after the credentials below are wired and you've completed the first-run verification.

## Credentials

### `PLACEHOLDER_HUBSPOT_CRED_ID` — HubSpot OAuth

Used by `HubSpot — Upsert Score`, `HubSpot — Create SDR Task (mid)`, and `HubSpot — Find Missed Submissions`. Create a private app in HubSpot with scopes `crm.objects.contacts.read`, `crm.objects.contacts.write`, and `crm.objects.tasks.write`. In n8n, add a **HubSpot OAuth2 API** credential and complete the OAuth dance. Before activating, create the custom contact properties `icp_score__c` (number 1-10), `icp_score_reasoning__c` (single-line text), `icp_pain_hypothesis__c` (single-line text), and `icp_scoring_method__c` (single-line text, values `claude` or `rule-based`).

### `PLACEHOLDER_APOLLO_CRED_ID` — Apollo

Used by `Apollo — Enrich Domain`. In Apollo, generate an API key under **Settings → Integrations → API**. In n8n, add an **HTTP Header Auth** credential with header name `X-Api-Key` and value set to the key. Apollo's organization-enrich endpoint is rate-limited per plan; the node is configured with `neverError: true` so a 429 or timeout flows through to the rule-based fallback rather than killing the run.

### `PLACEHOLDER_ANTHROPIC_CRED_ID` — Anthropic

Used by `Claude — Score Lead`. Generate an API key at `https://console.anthropic.com`. In n8n, add an **HTTP Header Auth** credential with header name `x-api-key` and value set to the key. The node uses `claude-haiku-4-5` to keep the call under a second on the typical payload; swap to `claude-sonnet-4-6` only if you see scoring quality drop in your weekly audit.

### `PLACEHOLDER_GSHEETS_CRED_ID` — Google Sheets

Used by `Sheets — Territory Lookup`. Add a **Google Sheets OAuth2 API** credential. The sheet referenced by `PLACEHOLDER_TERRITORY_SHEET_ID` must have a tab named `Territories` with columns `country`, `sdr_email`, `sdr_owner_id`, `sdr_slack_handle`, `ae_email`, `ae_owner_id`, `ae_slack_handle`. Include a `default` row keyed on country code `*` so leads without a country still route somewhere.

### `PLACEHOLDER_SLACK_CRED_ID` — Slack bot token

Used by `Slack — Page AE (high)` and `Slack — Ops Alert (unrouted)`. Create a Slack app, add the `chat:write` bot scope, install it to the workspace, and invite the bot user to `#inbound-hot` and `#inbound-ops-alerts`. In n8n, add an **HTTP Header Auth** credential with header name `Authorization` and value `Bearer xoxb-...`.

### `PLACEHOLDER_SMTP_CRED_ID` — SMTP

Used by `Email — Self-serve Nurture (low)`. Any transactional SMTP provider works (Postmark, SendGrid, SES). Replace the `fromEmail: no-reply@example.com` and the four `https://example.com/...` links in the HTML body before activating.

## First-run verification

Before enabling the HubSpot trigger that fires this webhook in production, prove every branch with manual inputs:

1. **Low-score path.** Use n8n's **Execute Workflow** on the webhook node with a test payload from a free-mail address (`{ "body": { "contactId": "test-1", "contact": { "email": "test@gmail.com", "firstName": "Pat", "company": "Acme" } } }`). Expected: score capped at 4, the `Email — Self-serve Nurture (low)` branch fires, HubSpot upsert writes `icp_score__c: 4`.
2. **Mid-score path.** Send a payload with a corporate domain you know Apollo enriches (your own company is fine). Expected: score between 4 and 7, `HubSpot — Create SDR Task (mid)` creates a task on the contact.
3. **High-score path.** Manually edit the `Parse Score` node output to force `score: 9` and run from there. Expected: Slack message lands in `#inbound-hot` with the company name and pain hypothesis.
4. **Claude failure path.** Temporarily revoke the Anthropic credential and run any payload. Expected: `scoringMethod: "rule-based"` in the HubSpot record and the lead routes by the deterministic rule.
5. **Backstop path.** In HubSpot, set one test contact to lifecycle `subscriber` with a recent conversion event and no `icp_score__c`, then trigger `Nightly Backstop Cron` manually. Expected: the contact appears in the search results and gets replayed through the webhook within one batch interval.

Only after all five paths complete cleanly should you enable the HubSpot workflow that pushes form submissions to this webhook.

{
  "name": "Inbound lead triage and routing",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "inbound-lead-triage",
        "responseMode": "responseNode",
        "options": {
          "rawBody": false
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000001",
      "name": "Webhook — HubSpot Form Submit",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [200, 300],
      "webhookId": "inbound-lead-triage-webhook",
      "notesInFlow": true,
      "notes": "Triggered by a HubSpot workflow on demo-form submission. Payload includes contactId, email, company, form_responses."
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={ \"received\": true, \"contactId\": \"{{ $json.body.contactId }}\" }",
        "options": {
          "responseCode": 202
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000002",
      "name": "Respond 202 Accepted",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [200, 480],
      "notesInFlow": true,
      "notes": "Acknowledge HubSpot immediately so the form submission isn't blocked on the rest of the flow."
    },
    {
      "parameters": {
        "jsCode": "// Normalize the HubSpot webhook payload into the shape the rest of the flow expects.\nconst body = $json.body || $json;\nconst contact = body.contact || body;\n\nconst email = (contact.email || contact.properties?.email || '').toLowerCase().trim();\nconst domain = email.split('@')[1] || '';\n\nconst freeMailDomains = new Set([\n  'gmail.com', 'yahoo.com', 'outlook.com', 'hotmail.com',\n  'icloud.com', 'aol.com', 'proton.me', 'protonmail.com'\n]);\n\nreturn [{\n  json: {\n    contactId: String(contact.id || contact.contactId || body.contactId || ''),\n    email,\n    domain,\n    isFreeMail: freeMailDomains.has(domain),\n    firstName: contact.properties?.firstname || contact.firstName || '',\n    lastName: contact.properties?.lastname || contact.lastName || '',\n    companyHint: contact.properties?.company || contact.company || '',\n    jobTitle: contact.properties?.jobtitle || contact.jobTitle || '',\n    formId: body.formId || body.form?.id || '',\n    formResponses: body.form_responses || body.formResponses || contact.properties?.message || '',\n    submittedAt: body.submittedAt || new Date().toISOString(),\n  }\n}];"
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000003",
      "name": "Normalize Payload",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [420, 300]
    },
    {
      "parameters": {
        "method": "GET",
        "url": "=https://api.apollo.io/v1/organizations/enrich?domain={{ $json.domain }}",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            { "name": "Cache-Control", "value": "no-cache" },
            { "name": "Content-Type", "value": "application/json" }
          ]
        },
        "options": {
          "timeout": 8000,
          "response": {
            "response": {
              "fullResponse": false,
              "neverError": true
            }
          }
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000004",
      "name": "Apollo — Enrich Domain",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [640, 300],
      "credentials": {
        "httpHeaderAuth": {
          "id": "PLACEHOLDER_APOLLO_CRED_ID",
          "name": "Apollo — X-Api-Key"
        }
      },
      "notesInFlow": true,
      "notes": "8s timeout. neverError so a failed enrichment doesn't kill the flow — score-by-rule fallback handles it downstream."
    },
    {
      "parameters": {
        "jsCode": "// Combine normalized payload + enrichment into a single bundle for Claude.\nconst lead = $('Normalize Payload').item.json;\nconst enrich = $json?.organization || {};\n\nreturn [{\n  json: {\n    ...lead,\n    company: enrich.name || lead.companyHint || lead.domain,\n    industry: enrich.industry || '',\n    employeeCount: enrich.estimated_num_employees || enrich.employee_count || null,\n    annualRevenue: enrich.annual_revenue || null,\n    country: enrich.country || '',\n    state: enrich.state || '',\n    technologies: Array.isArray(enrich.technologies) ? enrich.technologies.slice(0, 12) : [],\n    enrichmentOk: !!enrich.name,\n  }\n}];"
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000005",
      "name": "Merge Lead + Firmographics",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [860, 300]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.anthropic.com/v1/messages",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            { "name": "anthropic-version", "value": "2023-06-01" },
            { "name": "content-type", "value": "application/json" }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={\n  \"model\": \"claude-haiku-4-5\",\n  \"max_tokens\": 400,\n  \"system\": \"You score inbound demo requests against the ICP rubric supplied by the user. Always reply with a single JSON object: {\\\"score\\\": integer 1-10, \\\"reasoning\\\": one sentence under 200 chars, \\\"primary_pain_hypothesis\\\": one sentence under 200 chars, \\\"disqualifiers\\\": array of strings}. Never wrap the JSON in prose or code fences. If firmographic data is missing, say so in reasoning and bias score down by 1. Free-mail addresses (gmail/yahoo/etc.) cap score at 4 unless the form responses prove a real role.\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"ICP RUBRIC:\\n{{ $vars.ICP_RUBRIC }}\\n\\nLEAD:\\n{{ JSON.stringify($json) }}\"\n    }\n  ]\n}",
        "options": {
          "timeout": 6000,
          "response": {
            "response": {
              "fullResponse": false,
              "neverError": true
            }
          }
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000006",
      "name": "Claude — Score Lead",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [1080, 300],
      "credentials": {
        "httpHeaderAuth": {
          "id": "PLACEHOLDER_ANTHROPIC_CRED_ID",
          "name": "Anthropic — x-api-key"
        }
      },
      "notesInFlow": true,
      "notes": "6s timeout. neverError → empty response triggers the rule-based fallback in Parse Score."
    },
    {
      "parameters": {
        "jsCode": "// Parse Claude's JSON. If anything fails (timeout, malformed, free-mail cap), fall back to a rule-based score.\nconst lead = $('Merge Lead + Firmographics').item.json;\nconst raw = $json?.content?.[0]?.text || '';\n\nlet parsed = null;\ntry {\n  parsed = JSON.parse(raw);\n} catch (e) {\n  parsed = null;\n}\n\nfunction ruleBasedScore(l) {\n  let s = 5;\n  if (l.isFreeMail) s -= 2;\n  if (!l.enrichmentOk) s -= 1;\n  const ec = l.employeeCount || 0;\n  if (ec >= 200 && ec <= 5000) s += 2;\n  else if (ec >= 50 && ec < 200) s += 1;\n  else if (ec >= 5000) s += 1;\n  if ((l.jobTitle || '').match(/director|vp|head|chief|cro|cmo|ceo/i)) s += 1;\n  return Math.max(1, Math.min(10, s));\n}\n\nconst usedFallback = !parsed || typeof parsed.score !== 'number';\nconst score = usedFallback ? ruleBasedScore(lead) : Math.max(1, Math.min(10, parsed.score));\nconst capped = lead.isFreeMail && score > 4 ? 4 : score;\n\nreturn [{\n  json: {\n    ...lead,\n    score: capped,\n    reasoning: parsed?.reasoning || (usedFallback ? 'Rule-based fallback (Claude unavailable or malformed).' : ''),\n    primary_pain_hypothesis: parsed?.primary_pain_hypothesis || '',\n    disqualifiers: parsed?.disqualifiers || (lead.isFreeMail ? ['free-mail-domain'] : []),\n    scoringMethod: usedFallback ? 'rule-based' : 'claude',\n  }\n}];"
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000007",
      "name": "Parse Score (with fallback)",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [1300, 300]
    },
    {
      "parameters": {
        "operation": "upsert",
        "resource": "contact",
        "email": "={{ $json.email }}",
        "additionalFields": {
          "icp_score__c": "={{ $json.score }}",
          "icp_score_reasoning__c": "={{ $json.reasoning }}",
          "icp_pain_hypothesis__c": "={{ $json.primary_pain_hypothesis }}",
          "icp_scoring_method__c": "={{ $json.scoringMethod }}",
          "lifecyclestage": "lead"
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000008",
      "name": "HubSpot — Upsert Score",
      "type": "n8n-nodes-base.hubspot",
      "typeVersion": 2.1,
      "position": [1520, 300],
      "credentials": {
        "hubspotOAuth2Api": {
          "id": "PLACEHOLDER_HUBSPOT_CRED_ID",
          "name": "HubSpot — OAuth"
        }
      }
    },
    {
      "parameters": {
        "rules": {
          "values": [
            {
              "conditions": {
                "options": { "caseSensitive": true, "typeValidation": "strict" },
                "conditions": [
                  {
                    "id": "low-score",
                    "leftValue": "={{ $json.score }}",
                    "rightValue": 4,
                    "operator": { "type": "number", "operation": "smaller" }
                  }
                ],
                "combinator": "and"
              },
              "outputKey": "low"
            },
            {
              "conditions": {
                "options": { "caseSensitive": true, "typeValidation": "strict" },
                "conditions": [
                  {
                    "id": "mid-score",
                    "leftValue": "={{ $json.score }}",
                    "rightValue": 7,
                    "operator": { "type": "number", "operation": "smallerEqual" }
                  }
                ],
                "combinator": "and"
              },
              "outputKey": "mid"
            },
            {
              "conditions": {
                "options": { "caseSensitive": true, "typeValidation": "strict" },
                "conditions": [
                  {
                    "id": "high-score",
                    "leftValue": "={{ $json.score }}",
                    "rightValue": 8,
                    "operator": { "type": "number", "operation": "largerEqual" }
                  }
                ],
                "combinator": "and"
              },
              "outputKey": "high"
            }
          ]
        },
        "options": {
          "fallbackOutput": "extra",
          "renameFallbackOutput": "unrouted"
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000009",
      "name": "Route by Score",
      "type": "n8n-nodes-base.switch",
      "typeVersion": 3.2,
      "position": [1740, 300]
    },
    {
      "parameters": {
        "operation": "lookup",
        "documentId": {
          "__rl": true,
          "value": "PLACEHOLDER_TERRITORY_SHEET_ID",
          "mode": "id"
        },
        "sheetName": {
          "__rl": true,
          "value": "Territories",
          "mode": "name"
        },
        "lookupColumn": "country",
        "lookupValue": "={{ $json.country || 'US' }}",
        "options": {
          "returnAllMatches": false
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000a",
      "name": "Sheets — Territory Lookup",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.5,
      "position": [1960, 300],
      "credentials": {
        "googleSheetsOAuth2Api": {
          "id": "PLACEHOLDER_GSHEETS_CRED_ID",
          "name": "Google Sheets — Territory rules"
        }
      },
      "notesInFlow": true,
      "notes": "Sheet columns: country, sdr_email, sdr_slack_handle, ae_email, ae_slack_handle. Falls back to a 'default' row if no match."
    },
    {
      "parameters": {
        "operation": "create",
        "resource": "task",
        "associations": {
          "associationsUi": {
            "associationsValues": [
              {
                "associationCategory": "HUBSPOT_DEFINED",
                "associationTypeId": 10,
                "toObjectId": "={{ $('Parse Score (with fallback)').item.json.contactId }}"
              }
            ]
          }
        },
        "additionalFields": {
          "ownerId": "={{ $json.sdr_owner_id }}",
          "subject": "=Inbound demo request — {{ $('Parse Score (with fallback)').item.json.company }} (score {{ $('Parse Score (with fallback)').item.json.score }})",
          "body": "=Pain hypothesis: {{ $('Parse Score (with fallback)').item.json.primary_pain_hypothesis }}\n\nReasoning: {{ $('Parse Score (with fallback)').item.json.reasoning }}\n\nForm responses: {{ $('Parse Score (with fallback)').item.json.formResponses }}",
          "priority": "MEDIUM",
          "taskType": "TODO"
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000b",
      "name": "HubSpot — Create SDR Task (mid)",
      "type": "n8n-nodes-base.hubspot",
      "typeVersion": 2.1,
      "position": [2180, 300],
      "credentials": {
        "hubspotOAuth2Api": {
          "id": "PLACEHOLDER_HUBSPOT_CRED_ID",
          "name": "HubSpot — OAuth"
        }
      }
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://slack.com/api/chat.postMessage",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            { "name": "content-type", "value": "application/json" }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={\n  \"channel\": \"#inbound-hot\",\n  \"text\": \":fire: High-intent inbound — {{ $('Parse Score (with fallback)').item.json.company }} (score {{ $('Parse Score (with fallback)').item.json.score }}/10)\",\n  \"blocks\": [\n    { \"type\": \"section\", \"text\": { \"type\": \"mrkdwn\", \"text\": \":fire: *High-intent inbound — {{ $('Parse Score (with fallback)').item.json.company }}* (score *{{ $('Parse Score (with fallback)').item.json.score }}/10*)\\nOwner: <@{{ $json.ae_slack_handle }}>\" } },\n    { \"type\": \"section\", \"text\": { \"type\": \"mrkdwn\", \"text\": \"*Contact:* {{ $('Parse Score (with fallback)').item.json.firstName }} {{ $('Parse Score (with fallback)').item.json.lastName }} ({{ $('Parse Score (with fallback)').item.json.jobTitle }})\\n*Email:* {{ $('Parse Score (with fallback)').item.json.email }}\\n*Industry:* {{ $('Parse Score (with fallback)').item.json.industry }} · *Headcount:* {{ $('Parse Score (with fallback)').item.json.employeeCount }}\\n*Pain hypothesis:* {{ $('Parse Score (with fallback)').item.json.primary_pain_hypothesis }}\\n*Reasoning:* {{ $('Parse Score (with fallback)').item.json.reasoning }}\" } },\n    { \"type\": \"section\", \"text\": { \"type\": \"mrkdwn\", \"text\": \"*Suggested opener:* {{ $('Parse Score (with fallback)').item.json.primary_pain_hypothesis }}\" } }\n  ]\n}",
        "options": {}
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000c",
      "name": "Slack — Page AE (high)",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [2180, 140],
      "credentials": {
        "httpHeaderAuth": {
          "id": "PLACEHOLDER_SLACK_CRED_ID",
          "name": "Slack — bot token"
        }
      }
    },
    {
      "parameters": {
        "fromEmail": "no-reply@example.com",
        "toEmail": "={{ $('Parse Score (with fallback)').item.json.email }}",
        "subject": "Thanks for the demo request — a few resources while we review",
        "emailFormat": "html",
        "html": "=<p>Hi {{ $('Parse Score (with fallback)').item.json.firstName || 'there' }},</p><p>Thanks for getting in touch. While our team reviews your request, here are the resources most teams find useful before a first call:</p><ul><li><a href=\"https://example.com/product-tour\">Self-serve product tour (8 min)</a></li><li><a href=\"https://example.com/pricing\">Pricing and editions</a></li><li><a href=\"https://example.com/case-studies\">Case studies by industry</a></li></ul><p>If you'd like to skip ahead, you can <a href=\"https://example.com/start-trial\">start a free trial</a> in under two minutes.</p><p>— The team</p>",
        "options": {}
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000d",
      "name": "Email — Self-serve Nurture (low)",
      "type": "n8n-nodes-base.emailSend",
      "typeVersion": 2.1,
      "position": [2180, 460],
      "credentials": {
        "smtp": {
          "id": "PLACEHOLDER_SMTP_CRED_ID",
          "name": "SMTP — transactional"
        }
      },
      "notesInFlow": true,
      "notes": "Low-score leads get an automated nurture, not a dead end. Subsequent product activation re-triggers the flow."
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://slack.com/api/chat.postMessage",
        "authentication": "predefinedCredentialType",
        "nodeCredentialType": "httpHeaderAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            { "name": "content-type", "value": "application/json" }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={\n  \"channel\": \"#inbound-ops-alerts\",\n  \"text\": \":warning: Unrouted inbound (score {{ $('Parse Score (with fallback)').item.json.score }}, method {{ $('Parse Score (with fallback)').item.json.scoringMethod }}). Contact {{ $('Parse Score (with fallback)').item.json.email }} — manual review needed.\"\n}",
        "options": {}
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000e",
      "name": "Slack — Ops Alert (unrouted)",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [2180, 620],
      "credentials": {
        "httpHeaderAuth": {
          "id": "PLACEHOLDER_SLACK_CRED_ID",
          "name": "Slack — bot token"
        }
      }
    },
    {
      "parameters": {
        "rule": {
          "interval": [
            { "field": "cronExpression", "expression": "15 2 * * *" }
          ]
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-00000000000f",
      "name": "Nightly Backstop Cron",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [200, 820],
      "notesInFlow": true,
      "notes": "Catches any contact whose webhook silently failed in the last 24h. Set timezone in workflow Settings."
    },
    {
      "parameters": {
        "operation": "search",
        "resource": "contact",
        "additionalFields": {
          "filterGroups": [
            {
              "filters": [
                { "propertyName": "lifecyclestage", "operator": "EQ", "value": "subscriber" },
                { "propertyName": "recent_conversion_event_name", "operator": "HAS_PROPERTY" },
                { "propertyName": "recent_conversion_date", "operator": "GTE", "value": "={{ $now.minus({hours: 26}).toMillis() }}" },
                { "propertyName": "icp_score__c", "operator": "NOT_HAS_PROPERTY" }
              ]
            }
          ],
          "properties": ["email", "firstname", "lastname", "company", "jobtitle", "recent_conversion_event_name"]
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000010",
      "name": "HubSpot — Find Missed Submissions",
      "type": "n8n-nodes-base.hubspot",
      "typeVersion": 2.1,
      "position": [420, 820],
      "credentials": {
        "hubspotOAuth2Api": {
          "id": "PLACEHOLDER_HUBSPOT_CRED_ID",
          "name": "HubSpot — OAuth"
        }
      },
      "notesInFlow": true,
      "notes": "Looks for any subscriber-stage contact with a recent_conversion in last 26h that has no icp_score__c. These are leads the webhook missed."
    },
    {
      "parameters": {
        "method": "POST",
        "url": "={{ $env.N8N_SELF_URL }}/webhook/inbound-lead-triage",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={\n  \"body\": {\n    \"contactId\": \"{{ $json.id }}\",\n    \"contact\": {\n      \"id\": \"{{ $json.id }}\",\n      \"email\": \"{{ $json.properties.email }}\",\n      \"firstName\": \"{{ $json.properties.firstname }}\",\n      \"lastName\": \"{{ $json.properties.lastname }}\",\n      \"company\": \"{{ $json.properties.company }}\",\n      \"jobTitle\": \"{{ $json.properties.jobtitle }}\"\n    },\n    \"formResponses\": \"backstop replay — {{ $json.properties.recent_conversion_event_name }}\",\n    \"submittedAt\": \"{{ $now.toISO() }}\"\n  }\n}",
        "options": {
          "batching": {
            "batch": {
              "batchSize": 5,
              "batchInterval": 2000
            }
          }
        }
      },
      "id": "2d2d2d2d-0002-0000-0000-000000000011",
      "name": "Replay via Webhook",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [640, 820]
    }
  ],
  "connections": {
    "Webhook — HubSpot Form Submit": {
      "main": [
        [
          { "node": "Respond 202 Accepted", "type": "main", "index": 0 },
          { "node": "Normalize Payload", "type": "main", "index": 0 }
        ]
      ]
    },
    "Normalize Payload": {
      "main": [
        [{ "node": "Apollo — Enrich Domain", "type": "main", "index": 0 }]
      ]
    },
    "Apollo — Enrich Domain": {
      "main": [
        [{ "node": "Merge Lead + Firmographics", "type": "main", "index": 0 }]
      ]
    },
    "Merge Lead + Firmographics": {
      "main": [
        [{ "node": "Claude — Score Lead", "type": "main", "index": 0 }]
      ]
    },
    "Claude — Score Lead": {
      "main": [
        [{ "node": "Parse Score (with fallback)", "type": "main", "index": 0 }]
      ]
    },
    "Parse Score (with fallback)": {
      "main": [
        [
          { "node": "HubSpot — Upsert Score", "type": "main", "index": 0 },
          { "node": "Route by Score", "type": "main", "index": 0 }
        ]
      ]
    },
    "Route by Score": {
      "main": [
        [{ "node": "Email — Self-serve Nurture (low)", "type": "main", "index": 0 }],
        [{ "node": "Sheets — Territory Lookup", "type": "main", "index": 0 }],
        [{ "node": "Sheets — Territory Lookup", "type": "main", "index": 0 }],
        [{ "node": "Slack — Ops Alert (unrouted)", "type": "main", "index": 0 }]
      ]
    },
    "Sheets — Territory Lookup": {
      "main": [
        [
          { "node": "HubSpot — Create SDR Task (mid)", "type": "main", "index": 0 },
          { "node": "Slack — Page AE (high)", "type": "main", "index": 0 }
        ]
      ]
    },
    "Nightly Backstop Cron": {
      "main": [
        [{ "node": "HubSpot — Find Missed Submissions", "type": "main", "index": 0 }]
      ]
    },
    "HubSpot — Find Missed Submissions": {
      "main": [
        [{ "node": "Replay via Webhook", "type": "main", "index": 0 }]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1",
    "timezone": "America/New_York",
    "saveExecutionProgress": true,
    "saveManualExecutions": true,
    "saveDataErrorExecution": "all",
    "saveDataSuccessExecution": "all"
  },
  "staticData": null,
  "pinData": {},
  "versionId": "2d2d2d2d-0002-0000-0000-0000000000ff",
  "meta": {
    "templateCreatedBy": "ooligo",
    "instanceId": "ooligo-pilot"
  },
  "id": "inbound-lead-triage-n8n",
  "tags": [
    { "name": "revops" },
    { "name": "inbound" }
  ]
}