Most n8n tutorials show you how to connect Gmail to Google Sheets. That isn't production.
Production is three campaigns running at once, an API returning 429s at 2am, and a client asking why their sync stopped six hours ago. That's when you find out which nodes actually matter.
Across the pipelines we run for D2C brands (AI content delivery, Shopify to Supabase syncs, ad automation, lead routing), seven nodes show up in nearly every serious workflow.
1. HTTP Request
The node that connects you to everything: every SaaS, every API, every webhook. The trap is treating it as a simple GET or POST switch. In production you need to handle pagination, because n8n won't do it for you by default. If an API returns 300 users across 30 pages, you have to tell the node to follow the next-page URL or increment the page parameter on each request.
Authentication is the other sore point. OAuth tokens expire and header values get rotated, so keep credentials in n8n's credential store and never paste tokens inline. If SSL validation blocks a response you genuinely need, there's an option to ignore it, but that should be a deliberate decision, not a quick fix.
For large inputs, the node can batch: set how many items go in each request and a pause between batches. That's what keeps you from being rate-limited or blocked.
2. Code
The escape hatch for everything the UI can't express cleanly. We use it in JavaScript, usually set to "Run Once for All Items" when we need to work on the whole dataset as an array.
The mistake most people make: in "Run Once for All Items" mode you read every item with $input.all(), and in per-item mode you use $input.item. Mix them up and at best you get a confusing error like "No data found for item-index". At worst the node quietly works on the wrong item and passes bad data down the line.
In all-items mode you also write your own loops. The node hands you the array and leaves the iteration to you.
3. Edit Fields (Set)
The data hygiene node. Before anything hits an API, a database write or an AI prompt, we pass it through Edit Fields to keep only the fields that matter and give them names that make sense downstream.
The underrated use is defining values once that several later branches need: timestamps, formatted strings, derived IDs. Set them in one place and reference them everywhere.
Skip this and data piles up noise as it moves through the workflow. By the time it reaches your CRM or a Supabase insert, it's carrying twenty extra keys from three different APIs. Clean it early.
4. IF
Every pipeline has decision points, and IF is how you build them: send items down different branches based on a condition. Simple in theory, messy once the conditions nest.
What works in production is one decision per IF. As soon as you're stacking five conditions into one IF, split them into a sequence of IFs or use a Switch node. You'll be grateful when you're debugging under pressure.
IF also gives a loop its way out. A loop with no valid exit condition never ends: the execution hangs and slowly eats resources. IF is the gate that says stop.
5. Loop Over Items
This is the node for when n8n's default item-by-item behaviour isn't enough control. (It used to be called Split in Batches.) It lets you set the batch size and process the data step by step, which matters when an API is rate-limited or the dataset is large.
Set the batch size to 1 to handle records one at a time, or to 50 to work through a big export without overwhelming the service downstream. The node holds the full dataset, sends batches through the loop body, collects the results, and outputs everything from its Done branch at the end.
The common mistake is not connecting the end of the loop back to the Loop node. Without that connection it runs once and stops.
It's also how we handle rate limits. Sending 500 contacts to an email API that allows 100 requests a minute? Set the batch size to 100 and add a Wait node of 60 seconds inside the loop. The pipeline stays under quota without a single 429. Rate limits aren't random failures. They're predictable maths, so solve them in the structure, not in error handling.
6. Merge
Most pipelines pull data from more than one source, and Merge is where those streams meet. You can append one input under the other, combine on a matching field (a customer ID, say), or keep only the matches, like an inner join in SQL.
Combining on a field is where most mistakes happen. The values have to be identical: the same ID from both APIs. If one has a trailing space or different capitalisation, the merge quietly produces no matches. Clean your keys with Edit Fields before the Merge.
Merge also waits for both inputs to finish. If one branch makes 50 API calls and the other makes one, the fast branch waits for the slow one, so design your branches with that in mind.
7. Error Trigger
Every production workflow we build has an error workflow attached, and that error workflow starts with the Error Trigger node. When any execution fails, n8n runs it and passes in the workflow name, the node that failed, the error message and a link to the execution.
Ours does three things: posts the details to Slack, writes them to a failures table, and for anything customer-facing, alerts a person directly. You set it once per workflow in its settings, under the error workflow option. It's the cheapest way to make sure a broken flow becomes a Slack message at 2am instead of a client email on Monday. We cover the rest of the reliability picture in campaign pipelines that don't break on the third launch.
The pattern across all seven
Clean data early (Edit Fields). Control volume (Loop Over Items). Make decisions explicit (IF). Join sources carefully (Merge). Handle the odd cases in Code. Call everything through HTTP Request. And make sure that when something fails, someone hears about it (Error Trigger).
The other few hundred nodes are situational. These seven carry the weight. If you'd rather have workflows like this built and handed over than build them yourself, that's what our AI automation work does.
