n8n Beginner Guide: Essential Nodes, Concepts, and Workflow Patterns

When you’re new to n8n, the hardest part isn’t building workflows — it’s knowing which nodes exist and when to use them. Most beginners either get stuck searching documentation for hours, or they reach for a Code node as a catch-all and end up with fragile workflows that break when something changes.

This guide walks you through every major component you’ll encounter in n8n workflows: triggers, nodes, how data flows between them, how to handle one-to-many and many-to-one transformations, merge patterns, conditional branching, file handling, binary data, and error management. By the end, you’ll have a solid mental model for building robust n8n automations from scratch.

Triggers: How Workflows Start

Every n8n workflow begins with a trigger — a node that listens for something to happen and kicks off the rest of the flow. When you create a new workflow, n8n prompts you to start with a trigger, and you’ll see several options.

Manual trigger — The most common trigger during development. It lets you run your workflow on demand without publishing it. Use this for testing while building.

Schedule trigger — Runs your workflow automatically at a set interval: every hour, every day at 8am, every Monday, whatever you need. Essential for recurring automations like daily reports or weekly digests.

Webhook — Fires when an external application sends a signal to n8n. If a native app event doesn’t exist, a webhook is your fallback — it’s how you connect anything that can send an HTTP request.

App event trigger — A native webhook for supported apps. For example, “when a new contact is added to HubSpot” or “when an email arrives in Gmail.” n8n handles the connection; you just configure what event to listen for.

Form submission trigger — Presents a form you can share with users. Responses (including file uploads) flow directly into your workflow. Useful for both testing and real-world data collection.

Chat message trigger — Powers chatbot and AI assistant workflows. Pairs naturally with AI agent nodes.

Visually, triggers have rounded corners in the n8n canvas, which distinguishes them from regular nodes. You can also have multiple triggers in the same workflow — both feeding into the same downstream logic.

Nodes: The Building Blocks of Workflows

After a trigger fires, the workflow is built from nodes. Each node performs one action — in n8n itself, or in an external application. Click the + icon after any node to see your options, organized by category:

AI nodes — The AI agent is the most commonly used, but this category also includes specialized nodes like the Information Extractor (pull structured data from unstructured text), Summarize, and more. AI nodes typically have multiple connection points — a chat model, memory, tools, and optionally a fallback model.

Action in app — Nodes that do something in an external service. For example, “Send Message” in Gmail, or “Get Contact” in HubSpot. Most services have dozens of available actions, and HubSpot alone has 31+.

Data transformations — Nodes for reshaping, filtering, converting, splitting, and aggregating data without writing code. Edit Fields, Split Out, Summarize, Aggregate, Filter, and Convert to File all live here.

Flow nodes — Logic and routing: If, Switch, Merge, Loop Over Items, Wait, and more. These control how data moves through your workflow.

Unlike triggers, regular nodes have square corners. Some nodes have a single output; others branch into multiple directions. AI nodes have additional connection points for their sub-components. Understanding the shape and connection behavior of a node at a glance helps you read workflows much faster.

Passing Data Between Nodes

One of the first things that trips up beginners is understanding how to pass data from one node into another. In n8n, this is done by dragging fields from a previous node’s output into the current node’s input fields.

When you drag a value in, n8n automatically switches that field from Fixed mode to Expression mode. The color of the field changes to indicate this. When a field is in expression mode, it’s reading live data from the workflow — not a hardcoded value. You can hover over an expression field to see exactly what value will be passed in.

The three output views — Schema, Table, and JSON — all let you drag fields into downstream nodes. Schema shows one example item with data types. Table shows all items in a spreadsheet-like view. JSON shows the raw key-value pairs for all items. Any of these views can be the source when dragging fields.

You can also mix expressions with static text. For example, in a Gmail node’s message body, you could type “Your report for ” and then drag in a dynamic date field — the result is a string that combines static text with workflow data.

This drag-and-drop expression system is the core of n8n orchestration: data flows from one node to the next, gets transformed along the way, and ends up exactly where you need it.

Understanding Items: How n8n Processes Data

An item in n8n is a single record of data — one row, one object, one thing to process. When a trigger fires, it might produce one item (a form response) or many items (all emails in an inbox). When a node runs, it processes all incoming items automatically — you don’t need to write a loop.

The three data views behave differently around items: Schema shows only one example item but displays the data types of each field. Table shows all items in rows and columns. JSON shows all items as an array of key-value pair objects. Schema is most useful when you want to confirm what fields exist; Table and JSON are better when you need to see actual values across multiple records.

An important and commonly misunderstood behavior: n8n processes all items at each node before moving to the next. If you have 5 items entering a node, all 5 are processed at that node, then all 5 outputs move to the next node together. It’s not item-by-item in a sequential loop — it’s batch-at-a-time through each step. This is why you rarely need the Loop Over Items node — it’s mainly useful when you’re hitting rate-limited APIs and need explicit delays between individual requests.

One to Many: Splitting Arrays with Split Out

Sometimes your workflow receives data where multiple values are bundled into a single item as an array. For example, an Edit Fields node might create one item with a field containing an array of band names: ["Queens of the Stone Age", "Tool", "Nine Inch Nails"]. That’s still just one item — but you probably want to process each band name individually.

The Split Out node solves this. It takes a field containing an array and expands it so each element becomes its own item. Three values in the array becomes three items out — each ready to flow independently through the rest of the workflow.

This is one of the most practical nodes in n8n. It’s how you turn paginated API results into individual records, how you process each row of a spreadsheet separately, and how you prepare data for per-item AI processing. For testing purposes, you can also create an array in an Edit Fields node and immediately split it to generate multiple test items without needing a real data source.

Many to One: Combining Items with Summarize and Aggregate

The reverse operation — combining multiple items back into one — is equally important, especially when you need to format data for emails, AI prompts, or documents.

Summarize (Concatenate operation) — Takes all items and joins their values into a single string, with a configurable separator. You can use commas, spaces, newlines ( ), or any custom delimiter. This is ideal when you want to pass a formatted list into an AI agent prompt or email body.

Aggregate — Another approach that collapses multiple items into one. Useful when you want to keep the data as an array structure rather than joining it into a plain string.

In practice, Summarize with Concatenate is the more flexible of the two for text-based outputs. Both have their place depending on what the next node in your workflow expects to receive.

Merge: Combining Separate Workflow Branches

As your workflows grow in complexity, you’ll frequently need to split data into parallel branches and then bring them back together. The Merge node handles this — and it’s one of the most important nodes to master.

The three merge modes you’ll use most are:

Append — Stacks items from both branches on top of each other. Branch A’s 5 items + Branch B’s 3 items = 8 items out. Simple and commonly used.

Combine by Matching Fields — Joins items from two branches where a shared field has the same value. Works like a SQL JOIN — useful when you have the same record from two different data sources and want to merge their fields together.

Combine by Position — Matches items from both branches by their order. Item 1 from Branch A merges with Item 1 from Branch B, item 2 with item 2, and so on. Use this when you’ve intentionally split a dataset and want to reassemble it after processing each branch independently.

Complex production workflows often use multiple Merge nodes. Don’t skip learning them — a surprising number of n8n issues come down to people not knowing how to bring two branches of data back together cleanly.

Branching with If and Switch

Conditional branching lets your workflow take different paths depending on the data it’s processing. n8n offers two main nodes for this.

If node — Evaluates a condition (greater than, less than, equals, contains, etc.) and routes items into a True branch or a False branch. For example, if an employee salary is greater than $90,000, send it one way; otherwise, send it another. Multiple conditions can be combined with AND/OR logic.

Switch node — An extended version of If that supports more than two output branches. Each branch has its own condition, and you can label each output for clarity. This is useful for multi-category routing — for instance, routing different sentiment analysis results (positive, neutral, negative) into separate downstream paths, or handling different product types differently in an order processing workflow.

One node can also feed into multiple downstream nodes simultaneously without branching logic — n8n simply sends the same items to all connected nodes. Branches (via If or Switch) add conditional logic on top of that basic fan-out behavior.

Filtering and Limiting Items

Two nodes help you control how many items flow through your workflow:

Filter node — Removes items that don’t meet a condition. If you’re processing 200 records but only care about entries from the last 30 days, the Filter node drops everything outside that window before it reaches the next step. Always filter early — removing records as close to the source as possible is more efficient than carrying unnecessary data through your entire workflow and filtering at the end.

Limit node — Caps the number of items passing through. Primarily useful during testing — if your data source returns 1,000 records, set a Limit of 10 to test your logic without processing everything. It also has legitimate production uses when you genuinely only want the first N results.

Saving Data to Files

n8n can convert workflow data into downloadable files using the Convert to File node, found under Data Transformations. The most common output formats are CSV and XLSX.

The workflow is straightforward: run your data transformations, then pipe the result into Convert to File, give the output a filename, and execute. The node produces a binary file output. If you execute the node in the editor and the file is a CSV or Excel file, n8n will download it when you click View. Images display inline; all other file types trigger a download.

This is useful at the end of scraper workflows (save results as a spreadsheet), data processing pipelines (export cleaned data), or anywhere you want a file artifact rather than sending data directly to another service.

End Destinations: Where Workflows Finish

Once your workflow has done its processing, it needs to put the result somewhere. Common end destinations include:

Google Drive / Dropbox — Upload a generated file directly to cloud storage. The Google Drive node has an “Upload a File” action that accepts binary data from a Convert to File node.

Google Sheets — Append a row or update existing data in a spreadsheet. A very common pattern for scraper workflows, where each run adds new rows to a master sheet.

Email (Gmail) — Send a message with or without attachments. Useful for reports, alerts, or delivering processed results to a stakeholder.

Think about the end destination before you build the workflow — it shapes decisions about what format your data needs to be in and what transformations are required along the way.

Binary Files: Working with Images, PDFs, and Spreadsheets

Binary data is any non-text file in your workflow: images, PDFs, spreadsheets, videos. When a binary file is present, n8n adds a Binary tab to the output panel alongside the usual Schema/Table/JSON views — but binary data only appears when the workflow actually produces it.

The easiest way to get a binary file into a workflow during testing is via the Form trigger. Add a file upload element to your form, submit a test file, and the binary data flows directly into your workflow. In production, you’ll more commonly pull files from Google Drive using the “Download a File” action.

Images display inline when you click View in the output panel. Other binary file types (CSVs, PDFs, Excel files) trigger a download instead of rendering in the browser. Working with binary data in n8n follows the same node chaining pattern as everything else — you receive it, process it (extract text with a PDF node, resize with an image node, etc.), and pass the result to the next step.

Error Handling: Making Workflows Resilient

Errors will happen in your workflows — usually in API or AI nodes that depend on external services. When a node errors without any error handling configured, the entire workflow stops. In a production automation that runs on a schedule, a single failure can mean hours of missed processing.

The most important setting to know is Retry on Fail, available in every node’s settings. Enable it and configure the number of retries and wait time between attempts. If an API node hits a rate limit temporarily, retrying after 1–2 seconds often resolves it without human intervention.

You also have two “continue” options for when retries are exhausted:

Continue (regular output) — The node passes its error state as if it succeeded, letting the workflow continue. Use this when a partial failure is acceptable and downstream nodes can handle missing data gracefully.

Continue (error output) — Routes the failed item through a separate error path, letting you handle failures explicitly — for example, logging them to a spreadsheet or sending an alert.

For more serious monitoring, n8n supports an Error Workflow setting at the workflow level (under the three-dot menu → Settings → Error Workflow). When any node in the workflow fails fatally, n8n triggers a separate designated workflow — where you can send a Slack message, email, or any other notification to alert your team that something needs attention.

Your Next Steps

The best way to internalize these concepts is to build something with them. Try creating an employee data pipeline: generate 10 records with a Code node (name, salary, department, start date), use Filter and If nodes to segment the data, Aggregate or Summarize by department, and save the full list as a CSV to Google Drive or Google Sheets. That single project touches most of what’s covered in this guide.

From here, the natural next topics are AI agents (how to build and prompt them effectively), the Merge node in depth, and authentication for external API integrations. All of these build directly on the foundation covered here.