n8n Tutorial for Beginners: Build Your First Workflow

That blank canvas is the whole problem, isn't it. You've heard n8n can automate almost anything, you signed up, and now you're staring at an empty grid with a single "add first step" button and no idea what to drag onto it.

I've watched a lot of smart people quit right there. Not because the tool is hard, but because nobody showed them the shape of a workflow first. Once you see the shape, the canvas stops being scary and starts being obvious.

So let me give you the shape, then we'll build one together. By the end of this you'll have made a real workflow that fetches data, moves it around, and shows you the result. That's the moment it clicks.

Before you start: cloud or self-hosted?

Do not let setup eat your afternoon. This is where most beginners lose the plot before they've built anything.

Fastest path: n8n Cloud. There's a free trial, you sign up, and you're inside the editor in about two minutes with nothing to install. For learning, this is what I'd pick. You want to spend your energy understanding workflows, not debugging a server.

Almost as fast: run it locally with npx. If you have Node installed, a single npx n8n command spins up the editor on your own machine at localhost:5678. Good if you'd rather keep everything on your laptop.

Later, when you're serious: self-host with Docker. Running n8n in a Docker container on a small server (or a service like Railway or a $6 droplet) is how you'd host workflows that run 24/7 for a client. It's worth learning, but it is not a day-one decision. Come back to it once you actually have a workflow worth keeping alive.

Pick whichever gets you to the editor fastest today. The interface I describe below may differ slightly from what you see, since n8n ships updates constantly, but the concepts don't move.

The three things every workflow has

Here's the shape I promised. Every single n8n workflow, from a two-node toy to a 40-node monster a client pays you for, is made of the same three ingredients.

A trigger. This is what starts the workflow. Nothing happens until something kicks it off: a schedule that fires every morning, a webhook that listens for incoming data, a new row in a spreadsheet, a form submission. Every workflow begins with exactly one trigger node, and it's always the leftmost node on the canvas.

Action nodes. These are the steps that do the work after the trigger fires. Call an API. Send an email. Filter a list. Ask an AI model to write something. You chain as many of these as you need, left to right.

The connections between them. Those little wires you drag from one node to the next are not just visual. They carry data. When a node finishes, it passes its output down the wire to the next node, which reads that data and acts on it. This is the part beginners miss, and it's the whole game.

If you remember nothing else: a workflow is a trigger, some actions, and data flowing down the wires between them. That's it.

Your first workflow, step by step

Let's build one. We'll make a workflow that runs on a schedule, fetches some data from a public API, and shows us the result. Simple, but it exercises all three ingredients.

1. Add a trigger. On the empty canvas, click to add your first step and choose a Schedule trigger (sometimes shown under "On a schedule"). Set it to run, say, every hour. This tells n8n when to wake up. For now we won't wait an hour, we'll fire it manually to test.

2. Add an action node. Click the small plus on the right side of your trigger to add the next step. Search for the HTTP Request node and add it. This node calls any URL on the internet and hands you back whatever it returns. It's the Swiss Army knife of n8n, and you'll use it constantly.

3. Point the HTTP node at an API. In the HTTP Request node's settings, set the method to GET and paste in a public test endpoint, something like https://api.github.com/users/n8n. No auth needed for a public read. This is the action that actually does something.

4. Map data from the trigger into the action. Right now our action ignores the trigger's data, which is fine for a first build. But this is where the wire matters: any field in a later node can pull values from an earlier node. We'll do that properly in the next section with expressions. For now, just know the wire from the Schedule trigger into the HTTP node is what makes that possible.

5. Test the node. Don't run the whole flow yet. Click into the HTTP Request node and hit "Execute node" (or "Test step"). n8n runs just that one node and shows you what came back.

6. Read the JSON output. Look at the output panel. You'll see a block of JSON: the GitHub user's name, follower count, bio, all of it, laid out as key-value pairs. That JSON is the data now flowing down the wire, available to every node you add after this one.

You just built a working workflow. Trigger, action, data. Sit with that for a second, because everything else is a variation on what you just did.

Understanding data and expressions

Now the concept that separates people who "tried n8n once" from people who get paid to build in it.

Everything moves as items. When a node runs, it outputs a list of items, and each item is a chunk of JSON. If your HTTP node pulled one user, that's one item. If it pulled a list of 50 customers, that's 50 items, and the nodes after it run once per item automatically. That's why you rarely write loops in n8n. The item model loops for you.

Expressions are how you reach into that data. When you want a field in one node to use a value from an earlier node, you switch that field to an expression and wrap it in double curly braces: {{ }}. Inside the braces you write the path to the value you want. Something like {{ $json.name }} grabs the name field from the current item. You'll see a little preview of the resolved value right under the field, which is how you know you got the path right.

This is why JSON matters. The whole n8n experience is reading JSON in the output panel, then writing an expression to pull the exact field you need into the next node. Get comfortable staring at that JSON and tracing a value from where it appears to where you want to use it. Do that a few times and expressions stop being scary. They're just addresses.

Add an AI step

This is where n8n gets genuinely fun in 2026. You can drop an AI model into the middle of a workflow like any other node.

Say your trigger brings in a batch of incoming support emails. Add an AI/LLM node in the chain, feed it the email body through an expression like {{ $json.body }}, and give it a prompt: "Classify this message as billing, technical, or sales, and reply with one word." The model reads each item, returns a category, and that category flows down the wire to whatever comes next, maybe a filter that routes billing emails to one place and technical ones to another.

Or use it to draft. Feed the AI a customer question and have it write a first-draft reply.

One rule I will die on: keep a human in the loop before anything sends. Have the AI draft the email, then route it to you for approval, not straight to the customer's inbox. Automation should draft and route for you, never speak for you unsupervised. An AI that classifies is low risk. An AI that hits send on your behalf is how you email a customer something embarrassing at 3am. Build the pause in on purpose.

Common beginner mistakes

I've made all of these, and I've watched students make them on repeat. Save yourself the pain.

Not testing each node as you go. People build eight nodes, run the whole thing, it breaks, and they have no idea which node failed. Execute each node right after you add it. Confirm the data looks right before you move on. Small steps, always.

Forgetting error handling. Real workflows hit dead APIs, rate limits, and empty responses. A flow with no error handling just dies silently and you find out days later when the client asks why nothing ran. Learn the error workflow settings early so a failure notifies you instead of vanishing.

Running an untested flow on real data. Never point a brand-new workflow at your production database, your real customer list, or a live "send email" step until you've tested it on fake or sample data first. Test with dummy inputs. Then test again. Then let it touch the real thing.

Where to go next

You've got the shape and you've built one. The fastest way to get fluent now is to build small workflows on repeat until the moves are muscle memory.

For ideas to practice on, I put together a list of n8n workflow examples you can rebuild step by step. If you're still deciding whether n8n is even the right tool for you, what is n8n covers the big picture, and n8n vs Zapier breaks down when to reach for each.

And if a light went on while you read this, if you're thinking this could be more than a hobby, that's the real signal. A tutorial gets you your first workflow. A career gets you paid to build them. That's exactly what our AI automation career path is built for: it takes you from the first workflow you just made all the way to job-ready and freelance-ready, with real projects and a community of people building alongside you. I wrote a whole guide on how to become an AI automation specialist if you want to see the road.

FAQ

Is n8n free? The self-hosted version is open and free to run yourself, so if you host it with Docker you pay only for the server. n8n Cloud is a paid hosted plan with a free trial, which is the easiest way to start learning without touching a server.

Do I need to know how to code to use n8n? No. You can build most workflows entirely by dragging nodes and writing simple expressions. Knowing a little JavaScript unlocks more advanced steps, but you can go a long way without writing any code at all.

What's the difference between a trigger and an action node? A trigger starts the workflow (a schedule, a webhook, a new form entry), and there's one per workflow. Action nodes are every step after that: fetching, filtering, sending, or transforming data. The trigger decides when, the actions decide what.

Why does my expression show nothing or an error? Almost always the path is wrong. Open the previous node's output, look at the actual JSON, and match your {{ $json.something }} path to a field that really exists there. The live preview under the field tells you the moment it resolves correctly.

Should I self-host n8n or use the cloud version? Start on the cloud so you can learn without setup friction. Move to self-hosting with Docker once you have workflows that need to run reliably around the clock, especially for clients where you want full control and lower long-term cost.

You just went from a scary blank canvas to a workflow that actually runs. That's the hard part, and you're already past it. Build a few more small ones this week and it'll feel like second nature fast.

If you want a guided path from here, CodingPhase has an AI automation track that walks you from your first workflow to getting paid for them, plus an 80,000-plus member community to build alongside. Diamond is $49/month or $250/year with a 7-day money-back guarantee, and the Tech Accelerator is a $1,500 one-time lifetime option if you want everything for good. Either way, keep building. You've clearly got the hard part handled.