Basecamp 3: Introduction to n8n — I

On the surface, make.com and n8n do the same job: connect apps and let data flow between them. The differences are structural. make.com is closed-source, prices per operation credit, and confines you to its prebuilt modules. n8n is open source — the trainer proved it live by opening the GitHub repo: auditable codebase, community-raised issues, and the punchline that you can run the whole product on your own machine for free, no subscription for the engine.

The capability gap matters as much as the ownership gap. n8n handles branching logic, decision trees, stateful workflows and AI agents — the complex shapes real automations grow into — and its 10,000+ free community templates mean you rarely start from a blank canvas (~300 under marketing alone, importable in a click).

A node does exactly one job: execute its code. What varies is the configuration around that job. Parameters are the settings and rules — which model, which spreadsheet, what text. Credentials are how the node acts on your behalf: an API key or an OAuth connect to services like OpenAI or Outlook. Input data is the JSON handed over by the previous node (or the trigger's output); output data is the JSON it hands onward. That chain of JSON passing between single-purpose boxes IS the workflow.

The companion habit is the Executions tab. The editor shows the workflow as designed; executions show each run as it actually happened — which nodes ran, what each received and returned, where it failed, with error logs. Once your canvas is more than two nodes, that tab is where debugging lives.

Trigger nodes start a workflow, and n8n gives you six main ways in: a manual click, an app event, a schedule (cron), an incoming webhook, a form submission, or a chat message. You can spot them on the canvas — curved left edge, no input side. Action nodes are the workers: crawl a site, send an email, create a doc. Core nodes carry the logic and computation between actions — ifs, transforms, spreadsheet operations.

The taxonomy is a teaching device more than an engine rule: action-vs-core is a mental model, and the only strict law is trigger-first — nothing runs until something starts it. The webhook deserves special attention: it's a URL that any app, site or form on the internet can call to start your workflow, which makes it the universal connector to everything that has no native n8n node.

Instructions are the system message — the trainer called it the agent's soul: its role, rules, tone, and what it must never do. The chat model is the pluggable brain — any LLM, swappable (OpenRouter later turns this into a dropdown). Tools give the agent hands: search, API access, knowledge bases, MCP servers. Memory lets it carry context across turns, and human handoff routes to a person when the agent shouldn't decide alone. Max-iterations caps how many thinking passes it takes — more passes, more tokens, more cost.

The judgment around the node matters as much as its anatomy: use an agent only where you want thinking. Routing an incoming WhatsApp message to the right workflow requires judgment — agent. Converting a PDF bank statement to markdown is deterministic — no AI node, and cheaper and more reliable without one.

The instructions field is the agent's soul, and writing an expert soul from scratch is hard. skills.sh short-circuits that: it's a marketplace of published skills — packaged expertise with behavior rules, code and resources — and any of them can become an n8n system prompt. Copy the skill, hand it to Claude with one conversion instruction, paste the output into the agent node. The generic agent now behaves like a specialist.

The selection craft is light but real: pick by use case and usage count, have Claude explain any skill whose contents you can't read, and edit out boilerplate before adopting it. The trainer framed the whole move with a hiring metaphor — a skill is a consultant who walks in with their expertise, and the conversion step is the onboarding.

An agent node takes exactly one chat model, and normally each provider means its own account, key and credential setup. OpenRouter collapses that: one API key routes to 400+ models — the western frontier names and the Chinese open-source wave (DeepSeek, Kimi K2, Qwen) alike — so switching a workflow's brain is a selection, not a migration.

Its second gift is evidence. The rankings page shows weekly token usage by model — what the world is actually running, not what benchmarks claim — and the compare view puts any two models side by side on benchmarks, context window and price. The session's example: a Tencent model ('HY3' as heard) out-consuming Claude Opus 4.7 by more than 4x that week.

Cloud models — Claude, GPT, Gemini, Grok — run in their providers' data centers. You get frontier intelligence, and you pay per token in and out; the session's pricing snapshot put Claude Opus 4.7 at roughly $10/M input (with caching) and $25/M output, with Haiku cheapest and Sonnet in between. Your data makes the round trip to their servers.

Local models — Llama, Qwen, Gemma, DeepSeek, Kimi (some ship as both cloud and downloadable weights) — run on your own hardware via Ollama, free once downloaded. The trade is capability for three things enterprises increasingly demand: cost that doesn't scale with usage, privacy (data never leaves the machine), and no vendor training on your content. The open-source frontier has closed much of the quality gap — the session's claim: Qwen 3.6 'almost on par with Opus 4.6' for agentic coding.

Open-source models ship in sizes — 3B, 8B, 14B, 30B parameters — and the trainer's rule collapses the whole selection problem: 'the larger the parameters, the better the model.' Quality scales with size; your RAM sets the ceiling. Pick variants whose parameter count (in billions) sits below your RAM (in GB) with about a 20% buffer, because the machine still needs headroom to actually run.

The worked case: an M3 Pro MacBook with 18GB comfortably runs models up to ~14B; a 30B model would crash it. And if the arithmetic feels uncertain, outsource it — paste your laptop's specs into Perplexity and ask which variant of the model you want will fit.

Ollama packages the messy business of running open-source models into an app-store experience: install once, then `ollama run <model>` pulls the weights and starts a local chat. Wiring it into n8n is deliberately anticlimactic — the Ollama chat-model node's credential is a local URL on the standard port, no API key, because the 'provider' is your own machine.

The library includes a category hosted providers can't offer: search 'uncensored' and you get guardrail-free variants like Dolphin, which answer what cloud models refuse. That capability cuts both ways — the trainer used it for deep web scraping and, in his stunt demo, had a $100 dummy phone pen-test his own Wi-Fi, built as a non-coder — and he flagged the territory honestly as a legal gray area. Local means nobody's terms of service sit between you and the model; it also means nobody's safety layer does.

The secret the whole method rests on: every node, and every workflow, IS a JSON blob — copy a node and you've copied JSON; paste JSON and nodes appear wired on the canvas. So instead of assembling workflows by hand, you have a model write the JSON. Brainstorm the flow as a mind map in Claude while it's still cheap to change your mind, then ask for the complete n8n JSON and paste it in.

Two refinements make it reliable. First, model knowledge varies: in the live comparison, Codex knew n8n's native Firecrawl nodes while Claude Sonnet produced generic ones — and pasting a real node's JSON into the prompt teaches any model the format. Second, the debug loop is built in: errors go to n8n's AI assistant (which can @-tag the failing node) or back to the generating model for a corrected JSON. The trainer's blessing on the whole approach: 'using AI is cheating, guys — so use AI to build your AI workflows.'

The demo assembles the day's vocabulary into a working pipeline: a manual trigger starts it, Firecrawl's native nodes scrape Hacker News, a formatting step shapes the result, and Google Docs nodes create a document and append the scraped data. Both credential styles get wired live — Firecrawl's connect flow and a Google account OAuth — and when one node fails, the debugging happens through the executions view and the AI assistant rather than off-camera.

The demo is also deliberately a seed, not a finale: the JSON was dropped in chat for learners to import with their own credentials, and Part 4's cliffhanger is adding an AI agent node to draft a newsletter from the scrape. The trainer's production version of exactly this pipeline runs agentmag.dev — a self-writing newsletter with generated images pushed to his front end.

Running: local n8n is light — about 4GB RAM and 16GB storage — so self-hosting skips the cloud version's 14-day trial and its bill entirely. The machine matters more for the models than the engine: Intel laptops aren't recommended for local LLMs, and the escape hatch is renting — a ~$10/month RunPod VM or Hostinger box runs n8n and Ollama for you. Practical adjacents: scrape LinkedIn through Apify rather than raw (it handles the anti-bot arms race), and n8n can feed agent platforms like OpenClaw/Hermes through exposed nodes — the example: competitor-pricing change alerts flowing into an agent.

Selling: two models. Sell the workflow outright as a deliverable, or — the recurring-revenue version — host it on your server and charge a retainer for keeping it alive. That second model explains a quiet market fact: workflows are IP, most builders never publish theirs, so the public template gallery is the visible fraction of what exists.