n8n Tutorial for Beginners: Your First Workflow, Step by Step
Learn n8n from zero — how nodes and items actually work, your first real workflow, the four concepts that unblock everything else, and a 30-day path to competence.
By Ali Ilyas · · Updated August 25, 2026
Most n8n tutorials show you where to click. Then you close the tab, try something that isn't in the tutorial, and everything falls apart — because clicking was never the hard part.
The hard part is that n8n has four ideas underneath it, and every guide assumes you already hold them. Once you do, the node panel stops being a wall of 400 icons and becomes a list of things you can already reason about.
This page teaches those four ideas, builds one real workflow with them, and ends with an honest 30-day path. No prior automation experience assumed.
What's on this page
- What n8n actually is
- Idea 1: everything is an item
- Idea 2: nodes run on every item, automatically
- Idea 3: a trigger decides when, not what
- Idea 4: expressions are how nodes talk to each other
- Getting n8n running
- Your first workflow, built properly
- Reading an execution when it breaks
- The five nodes that cover most work
- A 30-day path
- Mistakes that cost beginners the most time
- Frequently asked questions
What n8n actually is
n8n is a tool for connecting things that don't know about each other. A form fills in, a row gets added, a message goes out, a file gets processed. You draw that as a diagram, and n8n runs the diagram.
Two things make it different from the alternatives. It runs on your own machine if you want it to, free and without limits — see is n8n free for exactly what "free" covers. And it doesn't stop at the point where the pre-built integrations run out: any node's output can be fed to code, and any HTTP API can be called directly.
That second property is why people who outgrow simpler tools land here, and it's also why n8n feels harder at first. It doesn't hide the data from you. So learn to read the data, and the rest follows.
Idea 1: everything is an item
This is the concept that, once it lands, makes the other three obvious.
Every node in n8n receives a list of items and outputs a list of items. An item is one JSON object — one row, one email, one record.
Click any node after running it and you'll see this list in the output panel. If a node fetched 12 rows from a spreadsheet, its output is 12 items. If it fetched one, its output is one item — still a list, just a list of one.
[
{ "name": "Ada", "email": "ada@example.com" },
{ "name": "Grace", "email": "grace@example.com" }
]
That is the entire data model. Not a table, not a spreadsheet, not a variable — a list of JSON objects moving left to right.
Idea 2: nodes run on every item, automatically
Here's the part that surprises people coming from other tools.
If a node receives 12 items, it runs 12 times — once per item. You don't build a loop. You don't add a "for each" node. The looping is the default behaviour of every node in n8n.
So a workflow that reads 50 spreadsheet rows and sends 50 emails is three nodes, not a loop construct:
Schedule Trigger → Google Sheets (Get Rows) → Gmail (Send)
The Sheets node outputs 50 items. The Gmail node therefore runs 50 times. That's it.
When you actually do need the Loop Over Items node is when you want to process items in batches rather than one at a time — usually to respect an API's rate limit, or to hold something in memory across iterations. For plain "do this to each one", you already have it for free.
This single idea resolves the most common beginner question on the forum, which is some version of "why is my node running more times than I expected?" It's running once per input item, and the fix is almost always to reduce the items, not to change the node.
Idea 3: a trigger decides when, not what
Every workflow starts with exactly one trigger node, and it answers one question: what event starts this?
There are four kinds worth knowing on day one:
| Trigger | Starts when | Use it for |
|---|---|---|
| Manual | You press Execute workflow | Building and testing |
| Schedule | A clock — every hour, every Monday 9am | Reports, syncs, digests |
| Webhook | Something sends an HTTP request to your URL | Forms, apps, other services |
| App trigger (Gmail, Notion, …) | That app reports a change | Reacting to a specific tool |
The trigger contributes almost nothing to your data. A Schedule Trigger outputs a single item containing a timestamp. Your actual data comes from the node after it.
Beginners often expect the Schedule Trigger to somehow fetch things. It doesn't. It fires, and the next node does the fetching. If you want the webhook side in depth, the webhook tutorial covers building one properly; if a trigger you've built isn't firing at all, workflows that don't trigger is the diagnostic path.
Idea 4: expressions are how nodes talk to each other
A node's fields can hold either a fixed value or an expression — a small piece of JavaScript that pulls a value out of the data flowing through.
Toggle a field from Fixed to Expression and you can write:
{{ $json.email }}
$json means "the current item". So {{ $json.email }} in a Gmail To field means "send to the email address on whichever item I'm currently processing." Because of Idea 2, that resolves to a different address on each of the 50 runs.
Three more you will use constantly:
| Expression | Means |
|---|---|
{{ $json.name }} | A field on the current item |
{{ $json.user.email }} | A nested field |
{{ $('Google Sheets').item.json.id }} | A field from a specific earlier node |
{{ $now }} | The current timestamp |
That third one matters more than it looks. Data gets reshaped as it moves — by the time you're three nodes downstream, the field you want may not be on the current item any more. $('Node Name') reaches back and gets it.
Drag, don't type. The left-hand panel in any node shows the incoming data. Drag a field from there into an input box and n8n writes the correct expression for you. Nearly every "my expression returns undefined" problem is a typed path that doesn't match the actual data shape — and the data shape is right there on screen.
Getting n8n running
Three routes, and the right one depends on why you're here.
n8n Cloud — sign up, no installation. Fastest way to be building in five minutes, and the correct choice if you're evaluating whether automation solves your problem at all. Paid after the trial.
Self-hosted with Docker — free, unlimited, runs on your own machine or a small server. This is the route most people end up on, and it's a genuinely reasonable first step if you're comfortable in a terminal. The Docker setup guide covers a working configuration, and self-hosting n8n covers putting it somewhere permanent with a real domain.
npx, locally — npx n8n runs it on your laptop with no install. Fine for a first hour of poking around. Don't build anything you care about here: it has no public address, so webhooks from the internet can't reach it, and it disappears when you close the terminal.
A note on a common early stumble: seeing "Cannot GET /" in the browser usually means you're on the wrong port or path. n8n serves its editor at the root of port 5678 by default — http://localhost:5678, not /n8n or /editor.
Your first workflow, built properly
Rather than a toy, here's a workflow with real structure — a trigger, a fetch, a decision, and an action. Four nodes, and it demonstrates all four ideas.
The goal: every morning, look at a spreadsheet of tasks, and message me about the ones that are overdue.
1. Schedule Trigger. Add it, set the interval to Days, hour 8. This fires once a day and outputs a single item.
2. Google Sheets → Get Row(s). Connect it after the trigger, pick your document and sheet. Run just this node (click it, press Execute step) and look at the output panel. You should see one item per row. Do not move on until you can see your data here. Every later step depends on the field names you're looking at right now — see the Google Sheets guide if the connection itself is the problem.
3. Filter. Add a Filter node. Set the condition to compare {{ $json.due_date }} against {{ $now }}, using the Date & Time → is before operator.
Filter drops items that don't match. So if 40 rows come in and 6 are overdue, 6 items come out — and because of Idea 2, everything downstream now runs 6 times, automatically.
4. Send a message. Add Gmail, Slack, or Telegram. In the message body, use an expression:
Overdue: {{ $json.task_name }} (due {{ $json.due_date }})
Execute the whole workflow. Six items in, six messages out.
Now make it real. Toggle Active in the top right. The Schedule Trigger only runs on its schedule when the workflow is active — an inactive workflow runs only when you press Execute. This catches nearly everyone once.
Notice what you didn't build: no loop, no counter, no array handling. You filtered a list and the platform did the rest.
Reading an execution when it breaks
It will break. The skill that separates people who get good at n8n from people who give up is reading the execution, and it takes ten minutes to learn.
Open the Executions tab (left sidebar, or the tab at the top of a workflow). Each entry is one run. Click one and you get the canvas as it was, with data at every step.
Work it in this order:
- Find the first red node. Not the last — the first. Everything after it is a consequence.
- Click the node before it and read its output. Nine times out of ten the error isn't in the failing node, it's that the data arriving is not the shape that node expected.
- Check the item count. A node receiving 0 items doesn't error — it silently does nothing, and the workflow "succeeds" while accomplishing nothing. An empty output on a node that should have found something is the most under-noticed failure in n8n.
- Read the actual message. n8n's errors are more specific than most;
Cannot read property 'x' of undefinedmeans the field you referenced isn't on the item, and step 2 tells you what is.
Getting comfortable with the executions view is worth more than learning twenty more nodes.
The five nodes that cover most work
There are hundreds. These five, plus your app integrations, do the majority of real workflows:
HTTP Request — calls any API. The escape hatch for everything without a dedicated node, and once you're comfortable with it, "n8n doesn't support X" stops being a blocker.
Edit Fields (Set) — reshapes items. Rename fields, add computed values, throw away everything you don't need. Use it liberally; carrying 60 fields you don't use makes every downstream node harder to read.
If / Switch — branch. If takes two paths, Switch takes several.
Filter — like If, but with no second branch: matching items continue, the rest are dropped.
Code — JavaScript when the visual nodes get awkward. Reach for it last, not first. A workflow that's one giant Code node is a script with extra steps, and you've given up the thing you came for.
A 30-day path
The most common question in r/n8n from newcomers is some form of "give me a roadmap" — usually followed by asking which course to buy. You don't need a course. You need four projects that each force one new concept.
Week 1 — make one thing work end to end. Build the overdue-task workflow above, or any Schedule → fetch → filter → notify chain against data you actually own. Goal: you can read the executions view without flinching.
Week 2 — make something respond. Build a webhook that receives a form post and writes it somewhere. Goal: you understand triggers vs. actions, and you've seen the difference between test and production URLs.
Week 3 — connect two apps you use. Something crossing a real boundary: Telegram, Slack, Notion, your CRM. Goal: you've handled authentication, pagination and an API that returns a shape you didn't expect.
Week 4 — add a model. Wire in OpenAI, then build a small AI agent. Goal: you know the difference between a chain and an agent, and why an agent needs tools.
After that, RAG and LangChain concepts are the natural next depth, and the templates library is worth reading as source material rather than just importing.
The single highest-leverage habit in that month: when something breaks, find out why before you fix it. The people who plateau are the ones who rebuild the node until it works.
Mistakes that cost beginners the most time
Building without looking at the data. Configure a node, run it, read its output, then configure the next one. Wiring five nodes and running them all at once means debugging five unknowns.
Testing on 5,000 items. Set a limit while building. You'll run the workflow forty times before it's right, and each run against a live API costs time and quota.
Forgetting to activate. Schedule and webhook triggers do nothing until the workflow is active. Also true in reverse: an active workflow keeps running after you've stopped thinking about it.
Treating Code as the starting point. If your instinct is to write JavaScript, the visual nodes will seem pointless — until you inherit a workflow made of Code nodes and can't see what it does.
Not naming nodes. "Google Sheets1", "Google Sheets2", "HTTP Request3". Rename them as you build; you reference them by name in expressions, and future-you will be reading them.
Ignoring error handling until production. Set a Retry On Fail on any node that calls an external service, and give real workflows an error workflow. APIs fail intermittently — that's not an exception case, it's Tuesday.
Frequently asked questions
Do I need to know how to code to use n8n?
No, and most workflows contain no code at all. What you do need is comfort reading JSON — recognising that {"user": {"email": "x"}} means email lives under user. That's an hour of learning, not a programming background. Code becomes useful later for things the visual nodes make awkward, but it's an accelerator, not a prerequisite.
Am I too late to start learning n8n? No. The tool's own AI-agent capabilities are barely a year old and are still changing every release, which means the material that made someone an expert two years ago is a fraction of what matters now. The gap between a beginner and a competent builder is measured in weeks of building, not years of tenure.
Is learning n8n still worth it if AI can build automations for me? This is the most common form of the question in 2026, and the honest answer is that AI is very good at producing a workflow that looks right and moderately bad at producing one that survives contact with real data. Someone still has to decide what should happen when the API returns 429, whether that duplicate check is actually safe, and what the workflow does at 3am when nobody is watching. Generated workflows raise the value of being able to read one, not lower it.
How long does it take to learn n8n? A first working workflow in an afternoon. Comfortable with items, expressions and debugging in two to four weeks of regular building. The plateau most people hit isn't n8n — it's the APIs they're connecting to, each of which has its own quirks.
What should my first automation actually be? Something you personally do by hand every week, with data you already own. Not a client project, not something impressive. The value of the first build is that you'll notice immediately when it produces the wrong answer, because you know what the right answer looks like.
Which n8n course should I buy? n8n's own documentation and its free official courses cover the fundamentals as well as anything paid, and the templates library gives you hundreds of real workflows to read. Spend money on a course only after you've built four or five things and can name the specific gap you're trying to close.
What's the difference between n8n Cloud and self-hosting? Cloud is managed and billed per execution; self-hosted Community is free forever and unlimited, but you maintain it. A handful of features — SSO, environments, external secrets, Git version control, log streaming — need a paid or enterprise licence either way. Is n8n free breaks down what falls on which side.
Why does my node run more times than I expected? Because it receives more than one item, and every node runs once per input item. Look at the output count on the previous node. To make it run once, reduce the input to one item — with a Limit node, a Filter, or aggregation — rather than changing the node itself.
Why is my expression returning undefined?
The path doesn't match the data. Open the node, look at the input panel on the left, and drag the field in instead of typing it. Case matters, and nesting matters: {{ $json.Email }} and {{ $json.email }} are different fields.
How do I use data from a node that isn't the previous one?
{{ $('Node Name').item.json.fieldName }}, using the node's exact display name. This is the standard fix once data has been reshaped downstream and the field you want has been dropped from the current item.
Do I need a loop node to process multiple records? No. Nodes iterate over input items on their own. Loop Over Items is for batching — processing items in groups of 10 to respect a rate limit, for example — not for basic iteration.
My workflow works when I click Execute but does nothing on its own. Why? It isn't active. Toggle Active in the top right. Schedule and webhook triggers only fire for active workflows, and webhooks additionally switch from the test URL to the production URL. Workflows that don't trigger covers the rest of the causes in order.
Can I run n8n on my laptop instead of paying for anything?
Yes — npx n8n or Docker, both free with no execution limits. The catch is that anything relying on an inbound webhook needs a public address, and your laptop doesn't have one. Local is fine for schedules and manual runs; put it on a small server when you need the internet to reach it.
What does "Cannot GET /" mean when I start n8n?
You've reached the server on a path it doesn't serve. The editor lives at the root of port 5678 — try http://localhost:5678 exactly. If you're behind a reverse proxy, it usually means the proxy isn't forwarding to the right port.
Should I learn n8n or Zapier first? If you want to understand automation as a skill, n8n — it exposes the data model that Zapier hides, and that model is the transferable part. If you need one specific integration working by Friday and never want to think about it again, Zapier is less to learn. The pricing comparison covers the cost side, which diverges sharply as volume grows.
Is there a way to see what other people have built? Yes, and it's the most underused learning resource. n8n's template library holds thousands of importable workflows; import one, open every node, and read what it does. Our templates page collects starting points too. Reading real workflows teaches structure faster than any tutorial, this one included.
Primary references: n8n's quickstart and first-workflow guide, the data structure documentation for items and JSON shape, and the expressions reference for $json, $now and node references.
Next steps: get an instance running with the Docker setup guide or self-hosting guide, then build something real — Google Sheets, Slack notifications, a Telegram bot or a Notion sync. When you're ready for the AI side, start with OpenAI and move to AI agents.