How to Automate 80% of Your Work: Advanced No-Code Workflows (n8n & Make) Beyond Zapier: webhooks, conditional routing, LLM qualification, and self-hosted architectures that scale

The fundamental issue with tools like Zapier at scale isn’t capability — it’s architecture and pricing. Zapier charges per task execution. Run a five-step Zap 10,000 times a month and you’re consuming 50,000 tasks. That number climbs fast in any real B2B operation. More importantly, Zapier’s linear, trigger-action model becomes a constraint when your actual business logic requires branching: “if the lead’s company size is over 50, route to enterprise sales; if it’s under 10, send to the self-serve sequence; otherwise, flag for manual review.”

Both n8n and Make.com solve these problems differently. Make operates on a scenario-based model with visual branching, built-in iterators, and a module library that covers nearly every SaaS API. Its HTTP Request module handles raw API calls with full JSON body mapping — no integration required if the endpoint exists. n8n goes further: it’s open-source, can run entirely on your own infrastructure, and supports JavaScript expressions at the node level, which gives you programmatic control inside a visual canvas.

Every robust automation shares the same three-layer structure, regardless of platform. Understanding these layers is what separates a workflow that holds up under real conditions from one that breaks the moment data doesn’t arrive in the exact shape you expected.

The workflow we’re building captures an inbound lead from a website form, runs it through an LLM to generate a qualification score and summary, then routes the enriched record to the appropriate CRM pipeline stage based on that score. This is a pattern that applies equally to sales qualification, support ticket triage, and contract review intake. We’ll build it in n8n, with notes on equivalent Make modules where the implementation differs.

3.1

The Webhook Payload

In n8n, add a Webhook node as your trigger. Set the HTTP method to POST and note the generated URL — this is what your form submission endpoint (e.g., a Typeform webhook or a custom form) will target. Set the node to respond immediately with a 200 OK so the sender isn’t blocked waiting for your workflow to complete.

The incoming JSON payload from a typical B2B form submission will look something like this:

// Incoming webhook payload — raw JSON from form submission { “first_name”: “Sarah”, “last_name”: “Chen”, “email”: “[email protected]”, “company”: “TechVentures”, “company_size”: “85”, “role”: “Head of Operations”, “use_case”: “We want to automate our client onboarding process including contract generation and CRM updates.”, “source”: “organic_search” }

After the Webhook node, add a Set node to normalize field names and cast types — company_size arrives as a string, so parse it to integer here. This keeps your downstream logic clean and avoids silent type-comparison failures in your Switch node.

3.2

The LLM Processing Node

Add an HTTP Request node and configure it to call the OpenAI Chat Completions endpoint (or whichever LLM API you’re using). This is where Make and n8n converge — both use their HTTP Request module/node for raw API calls. In the request body, construct a JSON payload that passes the normalized lead data into a structured prompt:

// HTTP Request node — POST to https://api.openai.com/v1/chat/completions // Headers: Authorization: Bearer {{$env.OPENAI_API_KEY}}, Content-Type: application/json { “model”: “gpt-4o-mini”, “max_tokens”: 200, “messages”: [ { “role”: “system”, “content”: “You are a B2B sales qualification assistant. Return ONLY valid JSON.” }, { “role”: “user”, “content”: “Qualify this lead. Company: {{$json.company}}, Size: {{$json.company_size}}, Role: {{$json.role}}, Use case: {{$json.use_case}}. Return: {\”score\”: 1-10, \”tier\”: \”enterprise|mid-market|smb\”, \”summary\”: \”one sentence\”, \”next_action\”: \”string\”}” } ] }

After the HTTP Request node returns, the LLM response is nested inside choices[0].message.content as a string. Add a second Set node that parses this string as JSON using n8n’s expression: {{JSON.parse($json.choices[0].message.content)}}. This extracts the structured qualification object and makes its fields addressable by downstream nodes.

💡 Pro Tip — API Cost Reduction

Use gpt-4o-mini instead of the full GPT-4o for qualification scoring — it’s roughly 25x cheaper per token and handles structured JSON extraction reliably. Add a max_tokens cap (200 is sufficient for a score, tier, and summary) so a runaway generation event doesn’t spike your API bill. Gate LLM calls behind a company_size threshold in a Switch node — leads under 5 employees rarely convert to enterprise contracts and don’t need scoring.

3.3

The CRM Output

Now add a Switch node that reads the tier field from the LLM response and creates three output branches: enterprise, mid-market, and smb. Each branch routes to a different CRM action — typically a different pipeline stage, deal owner, or lead status in HubSpot, Pipedrive, or whichever system you’re using.

For each branch, add an HTTP Request node calling your CRM’s contact creation or deal creation API. Map the fields from both the original webhook payload and the LLM output: the lead’s email and company from the webhook, the score, tier, and summary from the LLM JSON. Store the LLM summary in a custom CRM field so sales reps see it instantly when they open the record.

⚠️ Error Handling — Non-Negotiable

On each CRM output branch, add an Error Trigger node. Route failures to a separate HTTP Request that POSTs the raw lead payload plus the error message to a dedicated Slack channel or a fallback Google Sheet. This ensures zero lead loss even when your CRM API is temporarily unavailable. In n8n, enable “Continue on Fail” at the workflow level and use the IF node to check for error states explicitly.

When automation workflows handle customer data — PII, contract terms, financial information — where that data is processed and stored is not a secondary concern. Both Make and n8n cloud process workflow data on their servers, which means customer data passes through a third-party system. For many B2B contexts, particularly in legal, financial, or healthcare-adjacent verticals, this is a dealbreaker.

Self-hosted n8n eliminates this vector entirely. Your workflow execution data never leaves your infrastructure. Credentials are stored encrypted in your own database. Execution logs are only accessible to your team. The setup requires Docker or a Node.js environment, a reverse proxy (nginx is standard), and SSL termination — technically approachable for any team with a developer or systems administrator.