🔨 LearnForge
No-Code & AI

How to Learn n8n in 30 Days: A Complete Roadmap for Beginners

Most n8n "beginner guides" tell you what topics to cover but not what to actually do on any given day. This roadmap fixes that. It's 30 days, one hour each day, structured around four deployable mini-projects — one per week — with a self-check list before you advance. By day 30 you'll be able to build a complete AI agent workflow in under 90 minutes. That's the goal, and here's the path.

📅 August 20, 2026 ⏱️ 20 min read ✍️ LearnForge Team 🏷️ n8n · Beginner · Roadmap · Learning
Learn n8n in 30 days — a complete beginner roadmap with weekly projects and daily tasks

Before you start: the honest time commitment

This roadmap is built for 1 hour per day, 30 days — 30 hours total. Half of each session should be watching or reading; the other half should be building in n8n. If you do zero building and just consume, you'll retain very little. If you miss a day, don't double up the next day — just pick up where you left off. The 30-day label is a structure, not a deadline.

You need: an n8n Cloud account (free trial, no card required) and access to one free API — we'll use OpenWeatherMap in week 2, which has a free tier at 1,000 calls/day. Everything else in weeks 1 and 2 uses native n8n nodes that don't require external accounts.

What's in this roadmap

  1. What to skip until week 3
  2. Week 1 (Days 1–7): How n8n thinks — triggers, nodes, data model
  3. Week 2 (Days 8–14): Real integrations — APIs, Slack, Notion
  4. Expression cheatsheet: the 8 patterns you'll use constantly
  5. Week 3 (Days 15–21): Data transformation, loops, error handling
  6. Week 4 (Days 22–30): AI agents, memory, production deployment
  7. 5 mistakes that slow beginners down (and how to avoid them)
  8. Where you should be on Day 30
  9. FAQ

⏸ Skip These Topics Until Week 3

  • AI Agent node and LLM integrations — the agent is a black box if you can't debug the data flowing through it. You need to understand n8n's data model first, or you'll spend hours confused about why the agent isn't behaving correctly.
  • Self-hosting n8n with Docker — adds infrastructure complexity that has nothing to do with learning workflows. Use n8n Cloud for the first 30 days; self-host after you know what you're doing.
  • Complex webhook security and HMAC validation — important in production but not in week 1. Learn to receive a webhook first.
  • n8n API (controlling n8n from external code) — this is for advanced automation. Put it aside for at least 60 days.
  • Building for a client before you've built for yourself — don't take a paid project until you've completed all four weekly projects in this roadmap. You'll make avoidable mistakes on someone else's system.
Week 1 · Days 1–7

How n8n Thinks — Triggers, Nodes, and the Data Model

By the end of this week you'll understand why data flows the way it does, write basic expressions without guessing, and trigger a workflow from your terminal via curl.

The single most important concept in week 1 is n8n's data model: every node outputs an array of items, and every expression runs against the current item in that array. Learners who skip past this conceptually spend weeks confused about why their expressions return wrong values. Understand this once and most expression errors become obvious.

Day 1 Sign up for n8n Cloud. Spend the full hour exploring the editor: create a new workflow, drag in a Manual Trigger node and a Debug node, connect them, click Execute. Look at what the Debug node shows — this is the item structure every downstream node will receive.
Day 2 Build your first real workflow. Manual Trigger → HTTP Request (GET https://api.ipify.org?format=json) → Debug. Run it and look at the response. This is the simplest possible API call — it returns your IP address as JSON. Understand how the HTTP Request node maps to the concept of "make a request, get a response."
Day 3 The data model in depth. Add a Set node between HTTP Request and Debug. Use it to create a new field: Name = my_ip, Value = {{ $json.ip }}. Run it and see how the Set node transforms the item. Try writing a wrong expression on purpose — read the error message. This is how you learn to debug.
Day 4 Expressions practice. Open the expression editor (click the ƒ icon in any field). Practice writing the 8 expressions from the cheatsheet below against the data you already have. Don't memorize — just get comfortable with the editor and autocomplete. The goal is to stop being afraid of the curly brace syntax.
Day 5 Webhook Trigger. Replace Manual Trigger with a Webhook Trigger node. Copy the test URL. Open your terminal and run: curl -X POST [your-webhook-url] -H "Content-Type: application/json" -d '{"name":"Alice","score":85}'. Watch the data arrive in n8n. Add an IF node: if {{ $json.score }} ≥ 70, one branch; otherwise another. Run it with two different payloads.
Day 6 Schedule Trigger. Create a separate workflow with a Schedule Trigger (every minute for testing). Add an HTTP Request node that fetches something simple, then a Debug node. Activate the workflow and watch it run automatically. This is the moment n8n becomes real — it runs without you doing anything. Deactivate it when you're done; you don't need to burn API calls.
Day 7 Week 1 project — build and deploy it. See project box below.

Week 1 Project — Form → Google Sheets Logger

Build a workflow: Webhook Trigger → Set node (normalize the fields from your form: name, email, message, submitted_at using {{ $now.toFormat('yyyy-MM-dd HH:mm') }}) → Google Sheets (append a row). Send 3 test payloads via curl with different data. Verify all 3 rows appear in the sheet. Activate the workflow so it stays live.

✓ Week 1 Self-Check — Can you do all of these?

  • Trigger a webhook from curl and see the exact JSON payload arrive in n8n
  • Write an expression that accesses a nested JSON field without error
  • Add an IF node that routes to different branches based on a numeric value
  • Use the Set node to rename fields and add a timestamp
  • Your Week 1 project is activated and logging rows to Google Sheets
Week 2 · Days 8–14

Real Integrations — APIs, Slack, Notion

By the end of this week you'll authenticate against real APIs, send formatted Slack messages, and read/write Notion records from a workflow.

Week 2 is where you stop playing with toy data and connect n8n to real services. The critical skill here is the HTTP Request node — specifically understanding auth types and how to map a real API's documentation to the node's fields. Spend extra time on days 8 and 9; every week from here on uses what you learn there.

Day 8 HTTP Request deep dive. Sign up for OpenWeatherMap (free, instant API key). Build a workflow: HTTP Request → GET https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_KEY&units=metric. Look at the full JSON response in Debug. Notice how deeply nested the temperature is: $json.main.temp. Practice extracting 5 different fields from the response with expressions.
Day 9 API authentication. In the HTTP Request node, explore all credential types: Header Auth (most APIs), Bearer Token (GitHub, OpenAI), Basic Auth (some legacy APIs). Add your OpenWeatherMap key as a Header Auth credential. Then set up a second HTTP Request that POSTs to a free test endpoint (httpbin.org/post) with a JSON body. Understand the difference between query params and request body.
Day 10 Error behavior. Deliberately break your HTTP Request — use a wrong API key. What does the error look like in the execution log? Enable "Continue On Fail" on the node and re-run. Notice that the workflow doesn't stop — but the error data is in the item. This is how you learn to handle partial failures without redesigning the whole workflow.
Day 11 Slack integration. Create a Slack app, generate a Bot Token (OAuth), add it as an n8n credential. Use the Slack node to send a message to a channel. Then format the message properly using Slack's block kit format inside the node's text field — at minimum: bold the temperature value and add an emoji. Slack formatting in n8n is simpler than it looks once you see one example.
Day 12 Notion integration. Create a simple Notion database with 3 columns: Name (Title), Status (Select), Created (Date). Connect n8n to Notion via API token. Use the Notion node to create one record, then use it again to query records. Understand the Notion node's filter syntax — it's different from a normal HTTP Request, which is why n8n has a dedicated node for it.
Day 13 Combining nodes. Take what you built on days 11 and 12 and chain them: fetch weather → extract fields with Set → create a Notion record with those fields → send a Slack confirmation. This is 4 nodes working together. Run it, watch the execution, fix the first thing that breaks. Debugging a chain is the real skill.
Day 14 Week 2 project — build and deploy it. See project box below.

Week 2 Project — Daily Weather Slack Digest

Schedule Trigger (every morning at 8:00) → HTTP Request (OpenWeatherMap for your city) → Set node (extract city, temp, condition, feels_like, high/low) → Slack (formatted message: "☀️ Morning weather for London: 18°C, feels like 16°C. High 22°C / Low 14°C. Condition: Partly cloudy"). Activate it. The next morning, verify it runs and the message appears in Slack.

✓ Week 2 Self-Check — Can you do all of these?

  • Set up Bearer Token auth for an HTTP Request from a real API's docs
  • Extract a deeply nested field (3+ levels) from an API response using an expression
  • Send a formatted Slack message (bold text, emoji) from n8n
  • Create and query a Notion database record from a workflow
  • Your Week 2 project is activated and ran at least once automatically

Expression Cheatsheet: The 8 Patterns You'll Use 90% of the Time

Expressions are the most common source of confusion for n8n beginners. They always use double curly braces: {{ expression }}. Standard JavaScript methods work inside them. Here are the 8 patterns that cover almost everything you'll need in weeks 1–3:

Expression What it does
{{ $json.fieldName }} Access a top-level field from the current item
{{ $json.main.temp }} Access a nested field (dot notation, any depth)
{{ $json.name || 'Unknown' }} Use a fallback value when the field might be empty or undefined
{{ $json.email.toLowerCase() }} Apply any JavaScript string method to a field value
{{ $json.email.split('@')[0] }} Split a string and take a specific part (here: username before the @)
{{ $now.toFormat('yyyy-MM-dd') }} Format the current date/time using Luxon date formatting
{{ JSON.stringify($json) }} Convert the entire current item to a JSON string — essential for AI prompts
{{ $node['Set'].json.city }} Reference a specific field from a named earlier node (not just the previous one)

The #1 expression error: "Cannot read properties of undefined (reading 'fieldName')." This means the field you're referencing doesn't exist on the current item. Fix: add a Debug node before the problematic expression, run the workflow, and look at exactly what fields the item contains. The field name is almost always slightly different from what you assumed.

Week 3 · Days 15–21

Data Transformation, Loops, and Error Handling

By the end of this week you'll process lists of items in batches, write basic Code node JavaScript, merge data from two API calls, and have a working error alert for production failures.

This is the hardest week. The Code node (JavaScript) and the Merge node are where most beginners hit a wall. The good news: you don't need to write Code node logic from scratch — you need to understand what it's doing and be able to modify specific values. Spend extra time on day 15 even if it feels slow.

Day 15 Code node — your first JavaScript. Add a Code node to any workflow. In the code editor, write: return items.map(item => ({ json: { ...item.json, processed: true, score: item.json.value * 2 } })); Run it. Understand: items is the array, each item.json is one record, you return a new items array. That's the entire pattern for 90% of Code nodes.
Day 16 SplitInBatches node. Create a workflow that manually sets 20 items (use a Code node to generate them: return Array.from({length:20}, (_, i) => ({json:{id:i+1}}))). Add SplitInBatches (batch size: 5). See how the workflow loops through 4 batches of 5. This is how you process large lists without n8n timing out on a single execution.
Day 17 Merge node. Build a workflow with two HTTP Request nodes running in parallel (branch 1: weather API; branch 2: ipify API for your IP). Connect both to a Merge node in "Combine" mode. Look at the merged item — it has fields from both responses. This is how you enrich data from multiple sources before writing it to a database.
Day 18 Error Workflow — production safety net. Create a separate workflow called "Error Handler." It starts with an Error Trigger node, then sends a Slack message: ⚠️ Workflow failed: {{ $json.workflow.name }} | Error: {{ $json.execution.error.message }}. In Settings of every other workflow, set this as the Error Workflow. From now on, every production workflow failure pages you on Slack.
Day 19 Credential management and naming. Review all credentials you've created. Rename each with an environment prefix: [DEV] Slack, [DEV] Notion. When you eventually move to production, you'll add [PROD] versions. This 5-minute convention saves serious pain later when you have 20+ credentials and can't tell which is which.
Day 20 Workflow organization. Tag all your workflows. Use the folder structure if your n8n version supports it. Name every node descriptively: "Fetch Weather (OpenWeatherMap)" not "HTTP Request1." Open your Week 1 project and rename its nodes. You should be able to understand what a workflow does by reading the node names without opening any of them.
Day 21 Week 3 project — build and deploy it. See project box below.

Week 3 Project — Webhook → Enrich → Notion CRM

Webhook Trigger (receives: name, email, company) → Set node (normalize fields + add received_at) → HTTP Request (Clearbit Reveal: https://company.clearbit.com/v2/companies/find?domain={{ $json.email.split('@')[1] }}) → Merge (combine contact + enrichment data) → IF (is company data found?) → Notion create record. Error Workflow connected. Send 3 test payloads — 2 with real company emails, 1 with a Gmail address to test the IF branch.

✓ Week 3 Self-Check — Can you do all of these?

  • Write a Code node that adds a calculated field to every item in the array
  • Process a list of 20 items through SplitInBatches without the workflow failing
  • Merge data from two parallel HTTP Requests into one item using the Merge node
  • Your Error Workflow is connected to at least 2 of your active workflows
  • All your credentials have the [DEV] prefix and all nodes have descriptive names

Want to Go Deeper into AI Workflows with n8n?

The LearnForge AI Apps course picks up where week 4 of this roadmap leaves off — Claude API, AI Agent tool definitions, Postgres memory, and real deployable AI projects. Try the first lesson free.

Try the First Lesson Free →
Week 4 · Days 22–30

AI Agents, Memory, and Production Deployment

By the end of this week you'll have a working AI agent with persistent memory and at least one tool — and you'll know how to activate and monitor it in production.

Week 4 is why weeks 1–3 mattered. Now that you understand the data model, expressions, API auth, and error handling, the AI Agent node is no longer a mystery — it's just another node that makes HTTP calls and returns structured JSON. The difference is that Claude or OpenAI decides which calls to make based on the conversation.

Day 22 AI Agent node basics. Create a new workflow: Webhook Trigger → AI Agent node. Set the model to claude-haiku-4-5 (or gpt-4o-mini if you prefer OpenAI). Add your API key credential. In the system prompt, write: "You are a helpful assistant. Always respond in 2–3 sentences." Send a test webhook with a message field. See what comes back. Look at the execution — you can see the model's reasoning steps in the debug output.
Day 23 Adding a tool to the agent. Wire an HTTP Request node to the AI Agent's "Tools" input. Configure it to fetch the current weather for a city the user mentions. In the Tool Description field, write clearly what this tool does and what parameter it expects — the model reads this description to decide when to call the tool. Test with: "What's the weather like in Paris right now?" Watch the agent call the tool and incorporate the result.
Day 24 Postgres Chat Memory. Add a Postgres Chat Memory node to your AI Agent. Set Session ID to {{ $json.user_id }} and Window Size to 10. Send two sequential webhooks with the same user_id. On the second message, reference something from the first ("what did I ask you earlier?"). The agent should remember. This is the moment conversation history clicks.
Day 25 Structured output from the agent. Update your system prompt to end with: "Always respond with a JSON object: { answer: string, confidence: number }". Add a Code node after the AI Agent to parse this JSON. Wire an IF node: if $json.confidence < 0.7, send a Slack escalation alert; otherwise, return the answer. This is the confidence-gated routing pattern used in real support bots.
Day 26 Production activation checklist. Before activating any workflow permanently: (1) Check every credential is the right environment. (2) Test with realistic bad data (empty fields, wrong types). (3) Verify the Error Workflow is connected. (4) Check that the webhook URL is stored somewhere safe — it disappears from the UI when you change modes. (5) Set a max execution timeout in Settings. Activate it. Check the execution log after the first real run.
Days 27–28 Week 4 project — build and deploy it. See project box below. Give yourself two sessions for this one.
Days 29–30 Audit your 4 projects. Go back to weeks 1–3 projects. Add the Error Workflow connection to any that are missing it. Rename nodes that are still called "HTTP Request2." Add a timestamp to any records that are missing one. Verify all 4 workflows are active and running. This is what separates a learner from a practitioner — you don't just build, you maintain.

Week 4 Project — AI Support Bot with Memory and Tool

Webhook Trigger (receives: user_id, message) → AI Agent (claude-haiku-4-5, system prompt defines scope and JSON output format) → Postgres Chat Memory (session_id = user_id, window 10) → 1 Tool: HTTP Request to your own knowledge base or a public FAQ endpoint → Code node (parse confidence from JSON response) → IF (confidence ≥ 0.7) → TRUE: Respond to Webhook / FALSE: Slack escalation with conversation context. Test with 5 different messages — 2 that should escalate (off-topic or ambiguous) and 3 that the bot should handle.

✓ Week 4 Self-Check — Can you do all of these?

  • Configure an AI Agent node with a system prompt and a tool wired to it
  • Explain what the Postgres Chat Memory Session ID does and why it matters
  • Parse structured JSON from an AI response in a Code node without error
  • All 4 weekly projects are activated, named clearly, and have the Error Workflow connected
  • You can describe exactly what your Week 4 project does to someone who has never seen n8n

5 Mistakes That Slow Beginners Down

These aren't hypothetical — they're the patterns that consistently appear in beginner workflows submitted to the n8n community for help. Knowing them in advance saves several hours of debugging.

Mistake 1 — Starting with AI agents before understanding the data model

The AI Agent node is a black box if you can't read what's flowing through n8n. When it fails, the error is in the data — a mismatched field name, a wrong expression, a response format the Code node can't parse. If you can't debug a plain HTTP Request workflow, you can't debug an agent. Week 1's data model work exists specifically to prevent this.

Fix: Complete weeks 1 and 2 before touching the AI Agent node. The 14-day wait costs nothing — the confusion of skipping it costs days.

Mistake 2 — Testing only with perfect data

You build a workflow, test it with one well-formatted payload, it works, you activate it. Two days later it fails silently because a real user submitted a form with an empty "company" field and the expression {{ $json.company.toLowerCase() }} throws on undefined. Every workflow needs at least one test with missing fields before it goes live.

Fix: Always test with 3 payloads: one perfect, one with missing optional fields, one with an unexpected value type. Run each and check the execution log.

Mistake 3 — Hardcoding values that should be expressions

You type "Alice" directly into a Slack message instead of {{ $json.name }}. You hardcode a Notion database ID in 5 different nodes instead of setting it once in a Set node at the top of the workflow. Three weeks later you need to change it in every node individually, and you miss one. Use expressions for anything that comes from data; use a single Set node for workflow-level constants.

Fix: If you find yourself typing the same value into multiple nodes, it should be a variable set once at the top of the workflow and referenced with an expression everywhere else.

Mistake 4 — Naming nodes "HTTP Request2" and "IF1"

n8n's default node names are functional but meaningless. When you come back to a workflow in 3 weeks, "HTTP Request3" could be fetching weather, looking up an order, or posting to an API — you have to open it to find out. Multiply by 8 nodes and you can't understand your own workflow without opening every single one.

Fix: Rename every node immediately after adding it. Format: "Action (Service)" — "Fetch Weather (OpenWeatherMap)", "Create Lead (Notion)", "Alert on Failure (Slack)". Takes 5 seconds per node, saves 5 minutes per debugging session.

Mistake 5 — Skipping error workflows until something breaks in production

n8n workflows fail silently by default — unless something is configured to notify you. A Schedule Trigger workflow can fail every night for a week and you'll never know unless you check the execution log manually. Most beginners only add error handling after they discover a week of missed data.

Fix: Set up your Error Workflow in day 18 of this roadmap (it takes 20 minutes once) and connect it to every workflow before you activate it. This is not optional for anything that runs automatically.

Where You Should Be on Day 30

  • Build a complete webhook-triggered workflow — auth, branching, data transformation, Notion/Sheets write — in under 60 minutes without looking anything up
  • Set up a working AI agent with persistent memory and one tool in under 90 minutes
  • Debug any failing workflow by reading the execution log and the Debug node output — without asking for help on the forum
  • Explain to someone else what n8n's data model is and why expressions sometimes fail with "undefined"
  • 4 real workflows activated and running: a form logger, a daily digest, an enrichment pipeline, and an AI support bot

If you hit day 30 and you're not there yet, the answer isn't to read more — it's to build more. Go back to one of the weekly projects, extend it with a new branch or a new integration, and deploy the extension. The gap between "I followed tutorials" and "I can build things" closes through shipping, not studying.

FAQ

How long does it take to learn n8n? +

At 1 hour per day: first real working automation in 7 days, confident API integrations in 14 days, full AI agent workflow in 30 days. Total: ~30 hours of focused practice. The biggest variable is whether you build something real each week — learners who only watch tutorials take 3–5x longer to reach the same level as those who deploy one project per week.

Do I need coding experience to learn n8n? +

No, for the first two weeks. The visual editor handles triggers, branching, and most data mapping without code. You encounter JavaScript in week 3 with the Code node — but you don't need to write it from scratch. Budget an extra 3–4 hours in week 3 to get comfortable with the Code node if you have zero programming background. The pattern you'll use 90% of the time is a one-liner: map over items and return a new array.

Should I learn n8n Cloud or self-hosted first? +

Start with n8n Cloud. The free trial gives you a fully working environment in 2 minutes with no server setup. Self-hosting via Docker is worth learning eventually (production control, data privacy, no monthly fee), but it adds infrastructure complexity that distracts from learning the workflow builder. Learn the tool for 30 days on Cloud, then evaluate self-hosting based on whether your use case actually requires it.

What should I build first in n8n? +

Build something that solves a real small problem you have — not a tutorial demo. Good first builds: a form that saves submissions to Google Sheets automatically; a daily Slack message with weather or a news headline; a webhook that logs every time a specific event happens in an app you use. These are simple enough to complete in 2 hours but real enough that you'll learn from debugging them when something goes wrong.

What is the n8n expression syntax? +

n8n expressions use double curly braces: {{ expression }}. The most common: {{ $json.fieldName }} to access a field; {{ $json.field || 'default' }} for a fallback; {{ $now.toFormat('yyyy-MM-dd') }} for date formatting; {{ JSON.stringify($json) }} to pass data to an AI prompt. All standard JavaScript string and array methods work inside expressions.

What is the hardest part of learning n8n? +

The hardest part is n8n's data model — every node outputs an array of items and expressions run against the current item. Beginners expect data to flow like a spreadsheet row, but n8n processes items one at a time through each node. The second hardest is expression errors: "Cannot read property of undefined" means you're referencing a field that doesn't exist on the current item, usually because the field name is slightly different from what you assumed. Use the Debug node constantly in weeks 1–2 to see exactly what each node outputs before you write expressions against it.

Finished the 30 Days? Here's What's Next.

The LearnForge AI Apps course builds on exactly where this roadmap ends — Claude API, AI agent tool definitions with real data sources, Postgres memory, confidence-gated escalation, and production deployment patterns. Everything in the course assumes the week 1–4 foundations.

Start the AI Apps Course →