n8n tutorial: Build Your First Workflow in 20 Minutes

This n8n tutorial starts with the bug I’m most embarrassed about. A single Webhook node setting made Stripe charge one customer four times for one product. The webhook was set to reply only after the whole workflow finished. That workflow included a 25-second Claude API call. Stripe gave up waiting, assumed the delivery had failed, and sent the same event again. And again. I run my whole content and ops pipeline on n8n, and the first thing it taught me was that every setting on a trigger is a decision about time. So this tutorial starts with the trigger and goes slowly there. The rest is quicker to learn.

By the end you’ll have a workflow that receives data over HTTP, cleans it, routes it based on a field, and is ready for real credentials. You’ll also have the JSON file, so you can paste it in and take it apart if you’d rather skip the building.

What this n8n tutorial covers (and what n8n actually is)

n8n is a workflow automation tool. You place boxes on a canvas, wire them together, and data flows left to right through them. Each box is a node. The first node, which starts everything, is a trigger. That covers most of the mental model.

In my fleet it’s the plumbing. It takes a finished video and gets it to YouTube, sends a still image to Buffer, and writes state back to git. I picked it over Zapier because I can see and edit what every node does, and because self-hosting meant the cost didn’t grow with every step. The longer argument is in my n8n review, and the money side is in n8n pricing explained.

This n8n tutorial covers five concepts, in the order you’ll hit them:

1. Triggers: what starts the workflow
2. Items: the shape data takes as it moves between nodes
3. Expressions: how one node reads what an earlier node produced
4. Branching: sending data down different paths
5. Credentials: how n8n logs into other apps without putting your password in the workflow

Step 1: Get n8n running (minutes 0-4)

You have two options. n8n Cloud is the hosted version: sign up, and you get an editor in your browser. Self-hosted means you run it yourself. The fastest way to do that on a laptop is one Docker command:

docker volume create n8n_data

docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Open http://localhost:5678, create the owner account, and you’re on an empty canvas. The volume matters. Without it, your workflows and credentials disappear when the container stops. Ask me how I know.

Which option to use long-term is a separate decision. I wrote up the tradeoffs in n8n cloud vs self-hosted. For learning, either is fine, and everything below works the same in both.

Step 2: Add a trigger, and understand the two URLs (minutes 4-9)

Click Add first step and search for Webhook. A webhook is a URL that waits for another system to push data to it. If the term is new, read what is a webhook first. It explains the idea better than I can in one paragraph.

Set three things on the Webhook node:

• HTTP Method: POST
• Path: first-workflow
• Respond: Immediately

That last one is the Stripe lesson. “Immediately” means n8n replies to the caller with a 200 the moment the data arrives, then does its work. Any service that retries on timeout (Stripe, GitHub, most payment and form tools) needs this setting. Use “When Last Node Finishes” only when the caller actually needs the workflow’s output in the response.

Every n8n webhook has two URLs, and confusing them causes most first-day bugs. The test URL contains /webhook-test/ and only listens while you’ve clicked Listen for test event in the editor. The production URL contains /webhook/ and only works once the workflow is toggled Active. If you call the test URL at 2am with nobody watching the editor, you get a 404. If you call the production URL on an inactive workflow, you also get a 404.

Click Listen for test event, then post something to it from a terminal:

curl -X POST http://localhost:5678/webhook-test/first-workflow \
  -H 'Content-Type: application/json' \
  -d '{"name":"Dana","message":"the label printer is eating labels again","priority":"high"}'

The node turns green and shows the data. You’ve built a trigger.

Step 3: Items and expressions, the part that actually clicks (minutes 9-14)

Look at the Webhook node’s output. n8n wraps everything as items. An item is one JSON object, and a node can output many. Your POST body is under body, next to headers and query. The rule to remember is that most nodes run once per item. If a node gets 50 items, it does its job 50 times. That’s how n8n handles lists without making you write loops.

Add an Edit Fields (Set) node after the webhook. This is where you turn messy input into the shape you want. Add three fields and use expressions for their values. Expressions are the bits wrapped in {{ }}:

• name → {{ $json.body.name }}
• message → {{ $json.body.message.trim() }}
• priority → {{ ($json.body.priority || 'normal').toLowerCase() }}

$json means “the current item coming into this node.” The text inside the braces is plain JavaScript, so .trim() and the || fallback do what you’d expect. This is why n8n suits builders. When the visual tools can’t do something, you write the one line of code you need and keep going.

Run the node. The output is flat and clean: three fields, priority lowercased, and a default of normal if the sender left it out. Every node after this one can read $json.priority without caring how messy the original request was.

Step 4: Branch with an IF node (minutes 14-17)

Add an IF node after Edit Fields. Condition: {{ $json.priority }} is equal to high. The IF node has two outputs, true and false, and each item goes down exactly one of them.

For now, put a No Operation node on each branch and name them Urgent path and Normal path. They do nothing. They’re placeholders that show where the real actions will go. Send the curl again with "priority":"high", then with "priority":"low", and watch the item take a different branch each time.

You now have trigger → transform → decide. Almost every automation I run is that shape plus side effects at the end.

Step 5: Credentials, connecting a real app (minutes 17-20)

The placeholders become useful once they talk to something real: a Slack message on the urgent path, a Google Sheets row on the normal path. Doing that needs credentials.

Replace Urgent path with a Slack node (or Gmail, Telegram, whatever you actually check). In the node’s Credential dropdown, choose Create new credential. n8n walks you through it: usually an OAuth sign-in popup, sometimes a field for an API key. You do this once. After that, any workflow on the instance can use the saved credential by name.

Three things about credentials that matter later:

1. Secrets never live in the workflow. They’re encrypted in n8n’s database. Exported workflow JSON only holds a reference, so sharing a workflow file doesn’t leak your keys.
2. OAuth tokens expire. When a token dies, every workflow using that credential fails the same way. Re-authorising OAuth is one of the few jobs that still needs the operator, because no API will reauthorise itself.
3. Separate credentials per purpose. If one bot token is reused across ten workflows and gets revoked, you lose all ten at once.

Then toggle the workflow Active, switch your curl to /webhook/first-workflow, and it’s running in production.

The starter workflow JSON (paste this in)

Copy the block below, open a blank workflow in n8n, click the canvas, and paste (Cmd/Ctrl+V). The nodes appear already wired. It uses no credentials, so it runs straight away. Swap the No Operation nodes for real apps when you’re ready.

{
  "name": "First Workflow - Webhook Router",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "first-workflow",
        "responseMode": "onReceived",
        "options": {}
      },
      "id": "a1f0c6d2-0001-4a8e-9b1a-000000000001",
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [0, 0],
      "webhookId": "b7c1e2f3-0001-4d5e-8f9a-000000000001"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            { "id": "f1", "name": "name", "value": "={{ $json.body.name }}", "type": "string" },
            { "id": "f2", "name": "message", "value": "={{ ($json.body.message || '').trim() }}", "type": "string" },
            { "id": "f3", "name": "priority", "value": "={{ ($json.body.priority || 'normal').toLowerCase() }}", "type": "string" }
          ]
        },
        "options": {}
      },
      "id": "a1f0c6d2-0002-4a8e-9b1a-000000000002",
      "name": "Clean Fields",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [240, 0]
    },
    {
      "parameters": {
        "conditions": {
          "options": { "caseSensitive": true, "leftValue": "", "typeValidation": "strict" },
          "conditions": [
            {
              "id": "c1",
              "leftValue": "={{ $json.priority }}",
              "rightValue": "high",
              "operator": { "type": "string", "operation": "equals" }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "id": "a1f0c6d2-0003-4a8e-9b1a-000000000003",
      "name": "Is Urgent?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [480, 0]
    },
    {
      "parameters": {},
      "id": "a1f0c6d2-0004-4a8e-9b1a-000000000004",
      "name": "Urgent path",
      "type": "n8n-nodes-base.noOp",
      "typeVersion": 1,
      "position": [720, -100]
    },
    {
      "parameters": {},
      "id": "a1f0c6d2-0005-4a8e-9b1a-000000000005",
      "name": "Normal path",
      "type": "n8n-nodes-base.noOp",
      "typeVersion": 1,
      "position": [720, 100]
    }
  ],
  "connections": {
    "Webhook": { "main": [[{ "node": "Clean Fields", "type": "main", "index": 0 }]] },
    "Clean Fields": { "main": [[{ "node": "Is Urgent?", "type": "main", "index": 0 }]] },
    "Is Urgent?": {
      "main": [
        [{ "node": "Urgent path", "type": "main", "index": 0 }],
        [{ "node": "Normal path", "type": "main", "index": 0 }]
      ]
    }
  },
  "settings": { "executionOrder": "v1" }
}

If the paste fails, your n8n version is probably older than the node versions in the file. Update n8n, or rebuild the three nodes by hand using the steps above. That takes about four minutes.

What to build after this n8n tutorial

The workflow you just built is a skeleton. What separates a demo from something you trust overnight is the boring part: what happens when a node fails. In production I attach an Error Trigger workflow to everything, so a failed run sends an alert instead of failing silently. My setup is in how I handle n8n error alerts for failed workflows. Set that up before you have twenty workflows, not after.

Then build one real thing you’d otherwise do by hand every week. For me that started as social posting. The full version is in automate social media posts with n8n. Pick something small and repetitive, and give it a trigger.

If you want to see what this looks like at scale, the actual prompts and configs my fleet runs on are in the fleet files. They’re not tidied up for a tutorial. They’re what runs every day, including the parts I’m not proud of.

And if what you want automated is bigger than a weekend project, we can build it with you. That’s the day job.