n8n Tutorial (2026): Build Your First Workflow, Step by Step

What you'll build

To make this concrete, we'll build a genuinely useful first workflow: when a new row is added to a spreadsheet (a lead), send a Slack message to your team and add the lead to a second sheet as a clean record. It uses a trigger, two actions, a little data mapping and a test cycle. That is the same shape as almost everything you'll build later.

Step 0 — choose how to run n8n

n8n runs two ways, and either costs nothing to start:

• Self-hosted Community Edition (free): n8n's docs offer a one-line setup (Docker on Linux, macOS or WSL) or a Docker Compose guide; the plain Docker page is marked outdated, and npm installs end with n8n 3.0^[1]. The Community Edition has no execution quota and keeps your data on your server, but it lacks projects, workflow sharing, SSO, Git and environments, and n8n recommends self-hosting only for expert users; the paid self-hosted Business licence counts executions (40,000 a month). See our n8n review. For anything beyond a trial, use a Postgres database rather than the default SQLite.
• n8n Cloud (14-day free trial, no card): nothing to install. Sign up and you're in the editor. The trial runs Pro features with 1,000 executions and no API access, and there is no free Cloud plan afterwards. Best if you'd rather not run infrastructure while you learn.

For this tutorial either works; the editor is the same (the one difference you'd hit here is the Code node's library limits on Cloud, covered below). If you're evaluating, the Cloud trial is the quickest way to follow along.

The interface, in 60 seconds

Three things make up the n8n editor:

• The canvas: the center, where your workflow lives as connected nodes. Each node is a step; arrows show data flowing left to right.
• The nodes panel: click the + to search 500+ native integrations plus core nodes (HTTP, Code, IF, Switch, Set).
• The execution view: after you run a workflow (or a single node), each node shows the data it produced. This panel is where you'll spend most of your debugging time. Get comfortable opening a node and reading its output.

Connect your accounts — credentials

Before a node can touch Slack or Google Sheets, you authorize the account once as a credential, and every workflow reuses it. When you add a node, click to create a new credential and follow the connect flow (usually OAuth, a login popup, or an API key you paste). Two things are worth knowing as a beginner. Credentials are stored encrypted and separately from workflows, so you can share or export a workflow without leaking secrets. And if you're self-hosting, the encryption key that protects them is generated on first run. Back it up on day one, because restoring without it makes every saved credential unreadable^[2]. Set a credential up once, and it's available to every node that uses that app.

Build your first workflow, node by node

1. Add the trigger. Click +, search your spreadsheet app (e.g. Google Sheets), and pick its new-row trigger. Connect your account (a one-time credential you'll reuse), choose the sheet, and pull in a real sample row so you have real data to work with. Always build against real data, never guesswork.
2. Add the Slack action. Click the + to the right of the trigger, search Slack, choose its send-message action, connect Slack, and pick a channel.
3. Map the data. In the message field, instead of typing a static string, pull in values from the trigger. This is the core skill, covered next.
4. Add the second action. Add another Google Sheets node set to append a row, and map the lead's fields into the clean record sheet.

You now have trigger → Slack → Sheets. Three nodes, a real automation.

Working with data — expressions and the data-mapping model

This is the concept that separates people who get n8n from those who bounce off it. So slow down here. Every node outputs data items (usually JSON), and the next node can reference any field from any earlier node using an expression. In practice you drag a field from the input panel into a parameter, and n8n writes the expression for you: something like {{ $json.name }}, meaning the name field from the incoming item. You can reference earlier nodes by name, transform values inline (upper-case, format a date, do math), and combine fields.

The mental model to hold: data flows as items, and expressions read fields off those items. Once that clicks, the whole tool opens up. A few examples you'll use constantly:

• {{ $json.email }}: the email field from the incoming item.
• {{ $json.first_name }} {{ $json.last_name }}: combine two fields into one string.
• {{ $json.name.toUpperCase() }}: transform a value inline (JavaScript methods work).
• {{ $('Google Sheets').item.json.total }}: pull a field from a specific earlier node by name, not just the immediate one.
• {{ new Date().toISOString() }}: insert a timestamp.

When you're unsure what a field is called, open the previous node's output in the execution view and look. Don't guess. And if you need to reshape data (rename fields, add computed values) before an action, the Edit Fields (Set) node is the clean place to do it.

Don't start from scratch — templates and core nodes

Two shortcuts every beginner should know. First, templates: n8n has a large library of pre-built workflows for common tasks. Search it before building, import the closest match, and adapt it. Learning by editing a working template is far faster than starting on a blank canvas. Second, a handful of core nodes solve most problems regardless of app:

• HTTP Request: call any API, even one without a dedicated node. This is how you reach almost anything that isn't among the 500+ native integrations.
• Edit Fields (Set): build or reshape the data items passed downstream.
• IF / Switch / Filter: the logic nodes (below).
• Code: JavaScript or Python when you need it (on Cloud, Python can't import libraries and JavaScript can't import npm modules beyond crypto and moment; self-hosted can)^[3].
• Merge: combine data from two branches back into one.

Knowing these five means you're rarely stuck just because an app lacks a dedicated node.

Test as you build — the execution view is your friend

Don't build the whole workflow and hope. After each node, run that node (or the whole workflow) from the editor and read the output. Manual runs from the editor don't count as executions. n8n shows exactly what each node received and produced, so when something's wrong you can see where. The single most common beginner confusion is a node showing empty output. It almost always means the data shape from the previous node isn't what you assumed; open that previous node and check the field names. Testing node-by-node turns debugging from guesswork into reading.

Add logic — filters, IF and Switch

Real workflows branch. Two core nodes:

• IF / Filter: only continue when a condition is met (e.g. lead value over a threshold, or a field isn't empty). A Filter simply stops items that don't match; an IF sends true/false down two paths.
• Switch: route items down several paths by a value (e.g. region or category), each with its own downstream actions.

Add a Filter before your Slack node to skip test or junk rows. You've just made the workflow production-sensible.

Publish and schedule

Since n8n 2.0 (December 2025) there is no Active toggle: your edits autosave as a draft, Publish pushes a version live, production runs the published version, and Unpublish stops its triggers^[4]. Trigger-based workflows (like our new-row trigger) then fire on their event. For time-based automations, use the Schedule trigger and set the interval to real need. A Schedule Trigger firing every minute counts ≈43,200 executions in a 30-day month (our arithmetic). That is far above Cloud Starter's 2,500 or Pro's 10,000 a month, and over-limit runs fail rather than queue. A polling trigger counts only when it finds new data. There's no quota on the free Community Edition, but self-hosted Business counts executions too (40,000 a month). Until you publish, you're in build-and-test mode, which is exactly where you want to be while learning.

A quick second example: a scheduled digest. To feel the difference between event- and time-based triggers, build a second tiny workflow: a Schedule trigger set to every weekday at 9am, then a Google Sheets node that reads yesterday's new leads, then a Slack node that posts the count to your team. No external event starts it. The clock does. Publish it, and every morning your team gets an automatic summary. That's the other half of automation: not just reacting to events, but running work on a rhythm. Between on event and on schedule, you can express the large majority of real business automations.

Handle errors before they bite

Production workflows fail sometimes. An API is down, a field is missing. Two safety nets:

• Retries: on a node's settings, enable Retry On Fail for flaky external calls, so a transient error doesn't kill the run.
• An error workflow: build a separate workflow started by the Error Trigger node that alerts you (a Slack message, an email), then attach it in each workflow's Workflow Settings. Error workflows don't need to be published, and their runs don't count toward the execution quota (on Cloud since n8n 2.38; on self-hosted Business and Enterprise since 2.28). This is the difference between it broke and nobody noticed for a week and we knew in a minute.

Add your first AI step

Once the basics click, AI is a natural next node. Drop an AI node into the flow (for example, before appending the lead, have it classify intent or clean up the message text) and connect your own model (OpenAI, Anthropic, or a self-hosted one) or, on Cloud Starter and Pro, use Gateway credits to run models without an API key. Either way AI costs two meters: the run still counts as an n8n execution, on top of your provider's bill or the Gateway credits. For agents, RAG and the deeper patterns, see our dedicated n8n AI playbook. For now, know that adding AI is just adding another node.

Beginner pitfalls to avoid

Building without real data. Always fetch a real trigger sample first and map from it, or you'll map fields that don't exist. Guessing field names. Open the previous node's output and read them. Skipping tests. Execute node-by-node; don't build ten nodes then wonder why the end is empty. Over-frequent schedules. Match the interval to need, especially on Cloud. Forgetting to publish. Since n8n 2.0 (December 2025) edits autosave as a draft; production runs only the version you Publish, and Unpublish stops its triggers. (Self-hosting) not saving the encryption key. n8n encrypts credentials with a key generated on first run. Back it up day one, or a rebuild loses every credential.

Where to go next

You now have the shape of every n8n workflow: trigger, data, logic, actions, tested as you go. From here, add a second automation, introduce an AI node, and, if you're self-hosting for real, set up backups and (at higher volume) queue mode. To weigh whether n8n is right for you, read our n8n review; to plan cost, see the pricing guide; to build serious AI, the AI playbook picks up where this leaves off.