What You Will Learn

• Differentiate automations vs agents and when to use each
• Build, test, and activate visual n8n workflows on the canvas
• Authenticate and manage credentials securely across workflows
• Use the HTTP Request node to connect unsupported APIs
• Implement three practical builds: daily weather email, lead qualification, AI assistant
• Modularize workflows, call sub-workflows, and debug using Executions and pinning

Study Guide

Master 80% of n8n in 36 Minutes

You don't need more tools. You need one system that makes other tools work for you while you sleep, focus, or build. That's what n8n delivers: a visual, node-based environment to connect apps, automate tasks, and build AI agents that think, plan, and act across your tech stack.

This course is a complete learning guide that takes you from zero to building real automations and intelligent agents. You'll learn how the interface works, how data flows, how to authenticate apps, when to choose simple automations versus AI agents, and how to design modular, resilient workflows you can trust. We'll build three practical systems together: a daily weather email, an automated lead qualification flow, and a conversational AI personal assistant that can schedule events, read emails, and call other workflows as tools.

By the end, you'll not only understand n8n,you'll own a repeatable way to think about automation in your business and your life.

Automations vs. Agents: The Only Mental Model You Need

n8n handles two categories of work. Automation is predictable and repeatable. Agents are dynamic and adaptive. Know the difference and your builds will be clean, fast, and effective.

Automations
Fixed sequences that run the same way every time. "If A happens, do B, then C." Ideal for reliable, rules-based tasks.

Agents
Dynamic flows powered by a Large Language Model (LLM). They can decide which tool to use and in what order to hit a goal. Ideal for tasks that need reasoning, planning, and context.

Example 1 (Automation):
New Stripe payment → add customer to Google Sheet → send receipt via Gmail.

Example 2 (Automation):
RSS feed update → generate summary → post to Slack channel at 9 AM.

Example 1 (Agent):
"Summarize my unread emails and schedule a 30-minute call with any VIP senders." The agent chooses Gmail to read, filters messages, drafts summaries, and uses Calendar to schedule.

Example 2 (Agent):
"Research three competitors, analyze their pricing pages, and draft a comparison table in Notion." The agent uses a browser or API tools, extracts data, and writes structured content.

Use automations for consistency. Use agents when the path to the result changes with context.

How n8n Works: The Visual Canvas and Your Workflow Architecture

Everything happens on a visual canvas. You drag nodes, connect them with lines, and watch data move from left to right. No mystery. No black box.

Key interface elements
- Canvas: Where you connect nodes.
- Node panel (+): Where you search and add nodes (triggers, actions, logic, AI).
- Node settings: Three panels,Input (left), Parameters (center), Output (right).
- Editor vs. Executions: Editor is your build space; Executions is your run history and debugger.
- Save & Activate: Save frequently; toggle Active when you want the trigger to run automatically.
- Credentials: Secure storage for API keys and OAuth tokens; reusable across workflows.

Practical tip:
Double-click any node to open its Input/Parameters/Output. Learn to read this like a story: What came in? What did I configure? What came out?

Example 1:
After a Gmail node runs, the Output shows the message ID, sender, subject, and body. This is the raw JSON you can pass to the next step.

Example 2:
After a Google Sheets node appends a row, the Output returns the range updated and row index. Use this to reference the exact row later.

Setup Options: Cloud vs. Self-Hosted

You can run n8n in a managed cloud or on your own infrastructure. Choose based on speed-to-start and control needs.

n8n Cloud (Managed)
- Fastest start. No servers to manage.
- Best for non-technical users or teams who want reliability without ops overhead.

Self-Hosting
- More control, more customization, potentially lower cost at scale.
- Two common paths:

Local Install (Docker)
- Run n8n on your machine for development and advanced configuration.
- Good for developers and tinkerers.

VPS with One-Click Templates
- Provision a hosted instance at a provider and launch n8n with minimal setup.
- Balanced approach: easier than local plus persistent availability.

Best practices
- Use environment variables for secrets (API keys, database URLs).
- Back up the database that stores executions and credentials.
- Restrict OAuth scopes to minimum required permissions.

Core Node Types: The Only Blocks You Need to Master

Everything you build comes down to a few node categories. Get comfortable here and you've got 80% in your pocket.

Triggers
Start the workflow. Common patterns:

Schedule
Runs on a defined interval (daily, hourly, cron).
Example 1:
Every morning at 6 AM → fetch weather → email report.
Example 2:
Every Friday at noon → consolidate weekly metrics → send Slack digest.

Form Submission
Activates when someone submits data via an n8n form.
Example 1:
Inbound lead form → qualify → send tailored reply → log to sheets.
Example 2:
Internal request form → create Jira ticket → notify team.

Webhook
Listens for external calls at a unique URL you can give to other apps.
Example 1:
Stripe webhook for new charge → send receipt + update CRM.
Example 2:
Shopify order created → update inventory → email fulfillment.

Chat Input
Starts a conversation with an agent inside n8n.
Example 1:
"What's on my calendar tomorrow?" → agent responds with openings.
Example 2:
"Draft a follow-up to John about the proposal" → agent composes email draft.

Actions
Do things in external apps: Google Sheets, Gmail, Notion, Slack, HubSpot, Stripe, and hundreds more.
Example 1:
Google Sheets → Append row for every new contact.
Example 2:
Gmail → Send personalized messages with dynamic fields from previous nodes.

HTTP Request
The universal adapter for any public API that isn't pre-built. Yes, it's an action node,but it's special because it can reach almost anything online.
Example 1:
GET air quality from an environmental API and combine with weather data.
Example 2:
POST a message to a custom service or your own backend endpoint.

Logic (Flow) Nodes
Control the path and shape of your data.

Switch
Branching logic based on conditions.
Example 1:
If budget < 1,000,000 → send polite decline; else → send follow-up and assign rep.
Example 2:
If email contains "urgent" → route to on-call Slack channel; else → normal queue.

Merge
Recombine branches or datasets.
Example 1:
Merge two search results (website + CRM) into one combined contact record.
Example 2:
Merge multiple RSS feed summaries into a single digest.

Set
Create, clean, or reformat fields.
Example 1:
Normalize phone numbers to E.164 before sending to a dialer.
Example 2:
Strip currency symbols and commas from "$5,000" → 5000 for numeric comparisons.

AI Agent Node
The scaffold for dynamic assistants. It ties together a brain (LLM), memory, and tools.
Brain: Your LLM,OpenAI, Claude, Gemini,handles reasoning and generation.
Memory: Keeps conversation context (e.g., last 10 turns).
Tools: Capabilities the agent can call (Calendar, Gmail, custom workflows).

Example 1:
Agent with Gmail + Calendar: "Summarize unread emails and schedule calls."
Example 2:
Agent with Google Sheets: "Find sponsors with budget over 50k and draft outreach."

Understanding Data Flow: JSON, Expressions, and Mapping

Nodes pass JSON from left to right. You map fields via drag-and-drop or expressions. Understand this and debugging becomes simple.

Reading JSON
- Current node input: {{$json.fieldName}}
- Specific previous node: {{$nodes["Node Name"].json.fieldName}}
- Expressions can transform values on the fly.

Example 1:
Round temperature: {{Math.round($json.main.temp)}}.

Example 2:
Build a full name: {{$json.firstName + " " + $json.lastName}}.

Pin data
When testing, pin input data on a node so you don't have to re-trigger from scratch. This is critical with form/webhook tests.

Editor vs. Executions
Use the Executions tab to inspect what ran, when, and why it failed. Drill down into each node's input/output to find the break point.

Best practices
- Keep field names consistent (snake_case or camelCase) using Set nodes early in the flow.
- Validate and clean external inputs before branching logic.
- Use comments in system prompts and node descriptions to document assumptions.

Credentials: Secure, Reusable Connections

Credentials store API keys and OAuth tokens in one place. You create them once and reuse across nodes and workflows.

OAuth (e.g., Google)
Follow n8n's guided OAuth setup when connecting Gmail, Sheets, Calendar, or Drive. For self-hosted, you'll create OAuth credentials in Google Cloud and paste them into n8n.

API Keys
Services like OpenWeather or OpenAI give you keys. Store them as credentials, not hard-coded strings in expressions.

Best practices
- Use least-privilege scopes (read vs. read/write).
- Rotate keys periodically.
- Tag credentials by environment (dev, staging, prod) if you run multiple instances.

Case Study 1: Build a Daily Weather Report (Simple Automation)

Goal: Every morning at 6 AM, fetch local weather and send it to your inbox. This teaches scheduling, connecting an API, and passing dynamic data into an email.

Step 1: Schedule Trigger
- Add Schedule node.
- Set to run every day at 6:00.

Step 2: OpenWeather Action
- Add OpenWeather node after Schedule.
- Configure credentials with your OpenWeather API key.
- Operation: Return Current Weather Data.
- Units: Imperial or Metric.
- Location: By ZIP/postal code or city.
- Test Step to see output JSON.

Step 3: Gmail Action
- Add Gmail node after OpenWeather.
- Configure OAuth credentials.
- To: your email.
- Subject: Daily Weather Report.
- Message: combine static text with dynamic data from OpenWeather.

Example dynamic fields:
- Temperature: {{$json.main.temp}}
- Description: {{$json.weather[0].description}}
- Wind speed: {{$json.wind.speed}}

Step 4: Test and Activate
- Click Test Workflow, confirm email received, then toggle Active.

Bonus example (alternative simple automation):
RSS Trigger → Function (optional summarization) → Slack Post. This mirrors the same structure: trigger, enrich, send.

Case Study 2: Automated Lead Management (Intermediate Workflow)

Goal: When someone submits a sponsorship inquiry form, send a tailored response based on budget and log the result in Google Sheets.

Step 1: Form Submission Trigger
- Add Form Submission node.
- Fields: companyName (Text), contactName (Text), email (Text), budget (Number), notes (Text Area).
- Execute node to open a test form. Submit to generate sample output.

Step 2: Pin Data
- Pin the output so you can keep testing your downstream nodes without resubmitting the form.

Step 3: Clean the Budget (defensive design)
- Add Set node before Switch to normalize the budget field.
- New field "cleanBudget": {{Number(String($json.budget).replace(/[^0-9.]/g,""))}}.
- This handles values like "$5,000" and turns them into 5000.

Step 4: Switch Logic
- Add Switch node.
- Rule 1: cleanBudget < 1000000 (low budget).
- Rule 2: cleanBudget >= 1000000 (high budget).

Step 5: Gmail Branches
- Branch 1 (low budget): Gmail node → polite decline email using contactName and email.
- Branch 2 (high budget): Gmail node → personalized follow-up expressing interest.

Step 6: Google Sheets Logging
- Prepare a Google Sheet: columns Company, Name, Email, Budget, Notes, Action, Timestamp.
- Add Google Sheets node on each branch with Append Row operation.
- Map fields from the form to columns; set Action text ("Declined" or "Follow-up Sent"); add Timestamp with {{new Date().toISOString()}}.

Step 7: Test Both Paths
- Unpin, submit low and high budget values, confirm both branches behave correctly.
- Check your email and the sheet for expected entries.

Optional enrichment (AI mini-insert):
Add an AI node before email on the high-budget branch to research the company. Use HTTP Request to fetch website content or a search, summarize with the model, then inject the summary into your follow-up email with dynamic fields.

Example alternative logic flow:
- Switch on industry type to route to different reps.
- Set node to generate a lead score ({{Math.min(100, Math.round($json.cleanBudget/20000))}}) for your CRM.

APIs and the HTTP Request Node: Your Universal Adapter

When a service isn't officially supported, you connect via HTTP. It's direct, flexible, and unlocks nearly everything on the modern web.

Core concepts
- API = contract for requests and responses.
- HTTP methods: GET (retrieve), POST (create), PUT/PATCH (update), DELETE (remove).
- Auth types: API key, OAuth token, Basic Auth, Bearer headers.

Reading API docs
- Find the endpoint URL.
- Identify required parameters (query, path, body).
- Set headers (Content-Type, Authorization).
- Understand pagination (page/per_page, cursors).
- Respect rate limits and error codes.

Example 1: GET air quality
- Add HTTP Request node.
- Method: GET.
- URL: provider's endpoint with lat/long and API key.
- Execute and you'll receive AQI values. Combine with weather for a more useful daily summary.

Example 2: POST to Slack
- HTTP Request node.
- Method: POST.
- URL: Slack API chat.postMessage.
- Headers: Authorization: Bearer YOUR_TOKEN, Content-Type: application/json.
- Body: {"channel":"#alerts","text":"Build deployed: {{$json.version}}"}.

Best practices
- Store tokens in credentials, not inside the node body.
- Use Set to pre-shape payloads, then reference them in the HTTP Request Body using {{$json}}.
- Handle errors gracefully with optional "Continue On Fail," and check the Output for error codes/message.

Building a Personal AI Assistant (Advanced Agent)

Now we move from fixed flows to a system that thinks. The agent uses a model (brain), keeps context (memory), and can call tools (Calendar, Gmail, Sheets, or even other workflows).

Step 1: Chat Trigger + AI Agent
- Start a new workflow with Chat Trigger.
- Add AI Agent node next.

Step 2: Configure the Brain
- Choose your model provider (e.g., OpenAI).
- Add credentials (API key).
- Select a model with strong reasoning and tool-use performance.

Step 3: Memory
- Choose Simple memory to remember recent turns.
- Adjust message limit (e.g., last 10 turns) to balance context and cost.

Step 4: Add Tools
- Google Calendar: check or create events.
- Gmail: read and summarize threads; draft responses.
- Google Sheets: query sponsorship tracker or any dataset.
- Configure credentials and set permissions (read-only where possible; write where necessary).

Step 5: System Prompt (the rules of the game)
Write clear instructions that define the agent's role, scope, and tool usage.

Example system prompt:
You are a helpful, efficient personal assistant. You manage my schedule, emails, and a Google Sheet called "Sponsors." Use Calendar to check or create events. Use Gmail to summarize and draft emails. When I ask about sponsors, always check the Google Sheet. Confirm actions before making irreversible changes. If you need data you don't have, ask a clarifying question first.

Step 6: Test Natural Commands
- "What openings do I have tomorrow afternoon?"
- "Summarize unread emails from Sarah in the last two days."
- "Find sponsors with budget over 50k in the sheet and draft outreach."

Step 7: Extensibility via Tools
Attach a specialized sub-workflow as a tool:

Sub-workflow pattern:
- Create a separate workflow with trigger: "When Executed by Another Workflow."
- Build logic inside (e.g., Reddit scraper, competitor research, document search).
- In the main Agent, add "Call n8n Workflow" as a tool and select the sub-workflow.

Example 1:
Main agent asks sub-workflow "Get top posts from r/MachineLearning this week," receives structured results, and summarizes for you.
Example 2:
Calendar Manager sub-workflow handles all event creation, updates, and conflicts with more complex rules than the agent should hold in one place.

Best practices for agents
- Keep tools minimal and clearly named (less cognitive load for the model).
- Document tool capabilities in the system prompt.
- Validate sensitive actions ("I'm about to send an email to John. Confirm?").
- Log tool calls and outputs in a Sheet for traceability.

Advanced Architecture: Modularity, Sub-Workflows, and Tooling

Big assistants become unmanageable if you cram everything into one canvas. Modularize.

Pattern
- Main agent = orchestration + conversation.
- Sub-workflows = specialized tools (calendar, research, parsing, posting).
- Connect via "Call n8n Workflow."

Example 1: Calendar Manager
- Trigger: Executed by another workflow.
- Inputs: title, date, start_time, end_time, attendees.
- Nodes: Google Calendar create; conflict check; time zone normalization with Set.
- Output: event link and ID.

Example 2: Research Pipeline
- Trigger: Executed by another workflow.
- Nodes: HTTP Request to search APIs; HTML parsing; Set to clean fields; Merge results; return a concise dataset.
- Output: normalized JSON ready for LLM summarization.

Benefits
- Easier to debug in isolation.
- Reusable across agents and automations.
- Faster iteration because each tool has a single responsibility.

Debugging, Testing, and Iteration

Assume you will be wrong on the first build. Iterate in short loops: test, inspect, adjust.

Pin Data
Freeze inputs for rapid node testing without re-triggering the entire workflow.

Executions Tab
Inspect each run. Click into failed nodes to see request/response and payloads.

Continue On Fail (when appropriate)
For non-critical steps, set nodes to continue even if they error, then handle failures downstream (e.g., log to a Sheet and notify).

Validation & Cleaning
Use Set to sanitize inputs before Switch. Convert strings to numbers or dates, strip symbols, or enforce defaults.

Examples of fixes
- Budget entered as "$5,000" → {{Number(String($json.budget).replace(/[^0-9.]/g,""))}}.
- Missing subject lines → {{$json.subject || "No subject provided"}}.

Case Study 3: AI Personal Assistant in Action

Let's stitch the agent into something genuinely useful.

Build
- Chat Trigger → AI Agent.
- Agent tools: Google Calendar (read/write), Gmail (read/draft), Google Sheets (query).
- Memory: last 10 messages.
- System prompt: define role, instructions, tool list, and rules.

Interactions
- "Summarize my recent emails and flag anything from VIP clients."
- "Block off 2 to 4 PM next Tuesday for deep work."
- "What sponsorship deals did we progress this month?" (Agent checks the Sheet.)

Extensibility
- Add a sub-workflow tool for Reddit scraping and analysis.
- Add a sub-workflow tool for "Sales Research" that takes a company name and returns: HQ, headcount, recent news, and pricing highlights.

Trust and verification
- Ask the agent to confirm high-impact actions.
- Keep logs of actions taken: write to a "Agent Log" sheet with timestamp, action, and result.

Using Logic Effectively: Switch, Merge, Set (Deeper Dive)

Logic nodes make your workflows intelligent without an LLM.

Switch: Branch Decisions
- Route by thresholds, categories, or text conditions.
Example 1:
Support tickets: If priority = "high," page on-call; else assign to normal queue.
Example 2:
Language detection: If text contains Spanish keywords, route to Spanish templates.

Merge: Recombining Streams
- Join outputs from multiple branches or sources.
Example 1:
Merge CRM contact info with recent purchase data for personalized outreach.
Example 2:
Merge multi-step enrichment results (LinkedIn API + Clearbit API) into one record.

Set: Data Shaping
- Create new fields, rename, change types, or compute values.
Example 1:
Normalize dates to ISO format: {{new Date($json.date).toISOString()}}.
Example 2:
Compute LTV: {{($json.avgOrderValue || 0) * ($json.orderCount || 0)}}.

Practical JSON Patterns You'll Use Daily

Pulling from non-adjacent nodes
After branching, you often need data from earlier steps: {{$nodes["Form Submission"].json.email}}.

Array handling
- First item: {{$json.items[0]}}
- Map and join: {{($json.items || []).map(i => i.title).join(", ")}}

Safe defaults
- {{$json.value ?? "unknown"}} protects against null/undefined.
- {{($json.tags || []).length}} safely counts arrays.

Security and Reliability: Build Like a Pro

Credentials hygiene
- Never hardcode keys in expressions; use credentials.
- Scope tokens to the minimum required.
- Rotate keys and audit access regularly.

Error handling
- Use Sheets or a logging workflow to capture failures with input payloads.
- Send alerts to Slack for critical errors (HTTP 5xx from vendors, OAuth failures).

Idempotency
- When triggering from webhooks, store processed IDs to avoid duplicates (e.g., order ID).
- Use Merge with "Keep Key Matches" to dedupe inputs.

Implications and Applications: Where n8n Pays Off

Business Operations
- Lead nurturing, onboarding, CRM updates, reporting, sales pipeline hygiene.
Example 1:
New lead in HubSpot → enrich via HTTP → score → route to rep → log actions.
Example 2:
Monthly finance rollup → pull from Stripe + Sheets → compute MRR/ARR → email CFO.

Personal Productivity
- Calendar management, email triage, todo sync, smart home integrations.
Example 1:
Starred emails → summarize and draft responses at 8 AM.
Example 2:
Calendar gaps → propose focus blocks and auto-create if confirmed.

Marketing
- Social scheduling, content pipelines, research scraping, sentiment analysis.
Example 1:
New blog post → generate social snippets → schedule in Buffer.
Example 2:
Scrape competitor updates → summarize → send weekly brief.

Data Science
- Consolidate data from multiple sources, clean with Set, feed dashboards/databases.
Example 1:
HTTP pulls from APIs → normalize → push to BigQuery or Sheets.
Example 2:
Automated anomaly alerts when metrics cross thresholds.

Education & Training
- Teach APIs, JSON, workflow logic, and applied AI without heavy coding.
Example 1:
Students build a webhook → transform data → post to Slack.
Example 2:
Build an agent that quizzes on uploaded notes via vector search.

From Basic to Advanced: A Roadmap You Can Follow

Phase 1: Start Simple
- Build a 2-3 node automation (weather → email). Learn canvas, credentials, data mapping.

Phase 2: Add Logic
- Introduce Switch, Set, Merge. Build the lead management workflow with branching and logging.

Phase 3: Use HTTP Request
- Connect to a non-integrated API. Handle headers, auth, params, and parse JSON responses.

Phase 4: Build an Agent
- Chat Trigger + AI Agent with memory and tools. Write a tight system prompt. Test natural language commands.

Phase 5: Modularize
- Create sub-workflows as tools. Refactor the agent to call specialized workflows for calendar, research, or posting.

Actionable Recommendations to Accelerate Your Build

Start simple
Use the daily weather automation or a basic RSS-to-Slack flow to internalize the build-test-activate loop.

Use AI to assist your build
Ask a model to explain API responses, craft system prompts, or write JSON bodies for HTTP nodes. There are assistants trained on n8n docs that can help troubleshoot.

Leverage templates
Import templates from the n8n library. Reverse-engineer how nodes are configured, then tailor to your needs.

Embrace modularity
Break large assistants into smaller workflows (Calendar Manager, Research Agent). Call them as tools from the main agent for clarity and reuse.

Explore advanced concepts
Level up with RAG: connect to a vector database (e.g., Pinecone) so your agent can search your knowledge base and answer with citations. Wrap the retrieval steps inside a sub-workflow tool for clean architecture.

Two More Real-World Examples to Cement Concepts

Example: E-commerce Order Flow
- Trigger: Webhook from Shopify on new order.
- Get shipping rates via HTTP Request to your logistics API.
- Google Sheets: append order details + shipping method.
- Gmail: send customer confirmation with dynamic order summary.
- Switch: If order value > threshold → send VIP thank-you with discount code.

Example: Content Pipeline
- Trigger: Notion page "Published = true."
- Set: create social snippets from page fields (title, summary, tags).
- HTTP Request: POST to Twitter/X and LinkedIn APIs via schedulers.
- Merge: Combine results for a posting log.
- Google Sheets: append to content calendar with posted URLs.

Frequently Used Expressions and Snippets

Date math
- Add 1 day: {{new Date(Date.now() + 24*60*60*1000).toISOString()}}
- Format to local-friendly: {{new Date($json.start).toLocaleString()}}

String helpers
- Title case: {{$json.name.replace(/\w\S*/g, (t)=>t[0].toUpperCase()+t.slice(1).toLowerCase())}}
- Slugify: {{$json.title.toLowerCase().replace(/[^a-z0-9]+/g,'-').replace(/(^-|-$)/g,'')}}

Safety defaults
- Optional chaining pattern: {{($json.user && $json.user.email) ? $json.user.email : "no-email@domain"}}

Troubleshooting Checklist

Node fails unexpectedly?
- Check Input vs. Output; the issue is usually a missing or misnamed field.
- Validate credentials; expired tokens are common.
- Inspect HTTP status codes; 401/403 = auth, 429 = rate limited, 5xx = vendor outage.

Switch sends everything down the wrong branch?
- Ensure numeric fields are numbers. Use Set to coerce types.
- Log your condition with a temporary Set node to print values and confirm assumptions.

Agent behaves inconsistently?
- Simplify the system prompt; remove vague language.
- Reduce tools; name them clearly and document capabilities.
- Add explicit rules ("Ask before sending emails").

Covering the Essentials: Verify Your Mastery

You now understand:
- The difference between automations (fixed) and agents (dynamic).
- The core node types: Triggers, Actions, HTTP Request, Logic (Switch, Merge, Set), AI Agent.
- How to read JSON, use expressions, and map data across nodes.
- How to configure credentials securely.
- How to build three real systems: daily weather, lead management with branching logic, and a modular AI assistant.
- How to debug using executions, pin data, and iterate quickly.
- How to integrate non-supported services via HTTP Request.
- How to scale your assistants with sub-workflows as tools.
- Where to apply n8n across business operations, personal productivity, marketing, data work, and education.

Conclusion: Ship Small, Iterate Fast, Automate Everything You Repeat

The value of n8n isn't just in "connecting apps." It's in designing a system that reclaims your time. Automations handle the repetitive work with precision. Agents handle the messy, human-language requests with flexibility. Together, they turn errands into processes and ideas into results.

Start with one small build. Get the weather. Send the email. Feel the loop. Then add logic. Then attach an API. Then give it a brain. Soon, you'll have a modular stack of workflows and tools that run your day with zero friction.

Next step:
Open n8n, build the weather report, and activate it. Use that momentum to ship the lead manager, then your assistant. Keep refining. Your work compounds with every node you add.

Automation is leverage. n8n is the handle. Use it.

Frequently Asked Questions

This FAQ cuts through the noise and answers what people actually ask about "Master 80% of n8n in 36 Minutes." It moves from basics to advanced patterns, with practical guidance for business use, common pitfalls, and real examples you can copy. Use it to plan, build, and ship reliable automations and AI agents,fast.

Fundamentals and Core Concepts

What is n8n?

Short answer:
n8n is a visual automation platform where you connect "nodes" on a canvas to create workflows that run on triggers and actions. It handles both simple automations and AI-driven agents without heavy coding.

Why it matters:
You can connect apps (Gmail, Google Sheets, CRMs), call APIs, apply logic, and make decisions in one place. The editor shows input/output data so you can test quickly and fix issues before they hit production.

Example:
A lead form submits → Switch node routes leads by budget → Gmail sends a tailored reply → Google Sheets logs the submission. Or, an AI agent reads your unread emails, summarizes key threads, and schedules follow-ups using Calendar.

What are some practical use cases for n8n?

Short answer:
Personal productivity, marketing ops, e-commerce, reporting, and AI assistants that act on your data and tools.

Examples:
- Personal: Send a daily weather email, organize receipts from inbox to Drive, summarize calendar conflicts.
- Marketing/Sales: Enrich new leads, route by ICP, add to CRM, trigger a sequence, post to social.
- E-commerce: Sync inventory, notify customers, flag VIP orders, auto-issue partial refunds based on policy.
- Reporting: Pull metrics from multiple APIs, clean with Set, merge streams, and email dashboards.
- AI: Use GPT-style models to summarize support tickets, propose replies, and create tasks,then log results in your systems.

Business impact:
Less manual work, faster response times, and fewer data gaps across tools.

What is the difference between an "automation" and an "agent" in n8n?

Short answer:
Automations follow predefined steps. Agents reason, choose tools, and adapt based on context.

Automation:
Predictable paths with Switch/IF logic. Example: On form submit, email + log to Sheet. Great for repeatable business rules.

Agent:
Backed by an LLM with memory and tools. It can decide "what to do next" to achieve a goal, like "Summarize unread emails and schedule a meeting if needed," selecting Gmail and Calendar tools on its own.

When to use which:
Use automations for compliance, consistency, and scale. Use agents when tasks require reasoning, language, or multi-step planning with uncertainty.

Setup and Getting Started

What are the main options for setting up n8n?

Short answer:
Two paths: n8n Cloud (managed) or self-host (your infra).

n8n Cloud:
Fastest start, no servers to manage, automatic updates, and built-in reliability. Ideal for teams focused on outcomes over ops.

Self-host:
More control and flexibility. Common paths: VPS with one-click templates, or local/server via Docker. Great for custom domains, advanced security, or cost optimization.

Tip:
Start on Cloud to build and validate value. Migrate to self-host later if you need deeper control or specific compliance.

What are the components of an n8n workflow?

Short answer:
Canvas, nodes, connections, and executions.

Canvas:
The visual workspace where you add and connect nodes. Keep it organized with names and tidy tools.

Nodes:
Trigger, Action, Logic, HTTP Request, and AI Agent. Each node transforms or routes data.

Connections:
Show data flow and execution order. After branches, Merge nodes bring streams back together.

Executions:
A complete run log with inputs/outputs/errors. This is your best friend for debugging and auditing.

How are credentials for services like Google or OpenAI managed in n8n?

Short answer:
Create credentials once per service inside n8n, then reuse across workflows.

How it works:
Open a node (e.g., Gmail or OpenAI) → add credentials → complete OAuth or paste API key. Credentials are stored securely and referenced by nodes as needed.

Self-host tip:
Google OAuth often requires creating a project, enabling APIs (Gmail, Sheets), and setting redirect URIs. Follow the node's inline guide to avoid pitfalls.

Best practice:
Use least-privilege scopes, rotate keys, and separate prod vs. test credentials.

What is the purpose of "pinning" data in a node?

Short answer:
Pinning freezes a node's output so you can test downstream nodes without re-triggering upstream steps.

Why it's useful:
Speeds up iteration. For example, pin a sample form submission so you can refine Switch rules, Set transformations, and emails without resubmitting the form each time.

Pro tip:
Unpin before final end-to-end tests to ensure the workflow behaves correctly with live inputs.

Understanding n8n Nodes

What are the main categories of nodes?

Short answer:
Triggers, Actions, HTTP Request, Logic, and AI Agent.

Why it matters:
Knowing these categories speeds up build time and shapes your mental model. If a pre-built Action doesn't exist, HTTP Request is your universal adapter. Logic nodes (Switch, Merge, Set, Split In Batches) control the data and flow. AI Agent handles reasoning with tools.

What is a Trigger node and what are some common examples?

Short answer:
Triggers start workflows based on events or schedules.

Common triggers:
- Schedule (e.g., daily at 6 AM)
- Form Submission (collect and process inputs)
- Webhook (receive external HTTP calls)
- Chat Input (start chat-based agents)
- When Executed by Another Workflow (modular, reusable subflows)

Use case:
Schedule → OpenWeather → Gmail for a daily weather report.

What is a Switch node and how is it used?

Short answer:
Switch routes data into different branches based on rules you define.

Example:
If budget < 1,000,000 → send a polite decline. Else → send a follow-up and assign an owner. Each rule becomes a separate output path.

Tip:
Name outputs clearly (e.g., "Under Threshold," "Qualified") to keep the canvas readable for teammates.

What is a Merge node used for?

Short answer:
Merge combines parallel data streams back into one.

Use cases:
- Scrape multiple sources in parallel, then merge results for analysis
- Run two enrichment APIs, then combine outputs before deduping

Modes:
Pass-through, Merge by Key, or Combine. Choose based on whether you're aligning by an identifier or simply rejoining flows.

What is a Set node and why is it useful?

Short answer:
Set creates or transforms fields to clean, normalize, or reshape data.

Example:
Convert "$5,000" → 5000 by stripping symbols and commas, then casting to number so your Switch rules won't fail. You can also format dates, split names, or build composite fields (e.g., fullName).

Outcome:
Cleaner data → fewer errors → more reliable automations.

Data Handling and JSON

What is JSON and why is it important in n8n?

Short answer:
JSON is the data format n8n passes between nodes. It's just key-value pairs, often nested.

Why care:
Reading JSON structure helps you map fields correctly, troubleshoot issues, and write expressions. Even if you prefer drag-and-drop, understanding basics makes debugging much faster.

Tip:
Inspect Input/Output panels to see exactly what each node receives and produces.

How do I work with data and expressions in n8n?

Short answer:
Drag fields from the Input panel into node parameters, or write expressions like {{$json.fieldName}}.

Examples:
- Personalize an email: "Hi {{$json.contactName}}"
- Reference another node: {{$nodes["OpenWeather"].json.main.temp}}
- Transform values: {{Math.round($json.main.temp)}} for whole numbers

Outcome:
Dynamic messages, clean data, and fewer hard-coded values.

AI Agents and Advanced Workflows

What are the three core components of an AI Agent?

Short answer:
Brain (LLM), Memory, and Tools.

Brain:
The model that reasons and generates responses (e.g., GPT-4o, Claude).

Memory:
Maintains context across messages, enabling coherent conversations.

Tools:
Capabilities the agent can use: Gmail, Calendar, Google Sheets, or even other n8n workflows. The agent chooses which tool to call based on your goal.

What is a system prompt and why is it important for an AI agent?

Short answer:
The system prompt sets behavior, boundaries, and tool usage rules for the agent.

Include:
Role, instructions, tool list, business context, and restrictions. Be specific about what to use and what to avoid.

Example:
"You help manage my schedule and sponsors. Use Calendar for events, Gmail for email, and always check the Google Sheet for sponsor status before replying."

What is an HTTP Request node and when should it be used?

Short answer:
It's your universal connector for any API that lacks a native node.

Use it when:
You need GET/POST/PUT/DELETE calls, custom headers, auth, pagination, or to reach niche tools. Native nodes are convenient; HTTP Request gives full flexibility.

Example:
Call an Air Quality API, parse results, and add the AQI to your daily weather email.

Can one n8n workflow trigger another? How is this useful?

Short answer:
Yes,use "When executed by another workflow" and "Call n8n Workflow" to build modular systems.

Why it matters:
Keeps your main agent lean and maintainable. You can version and test subflows independently and reuse them across teams.

Example:
A Personal Assistant agent calls a "Calendar Agent" subflow to create/update events with clear inputs/outputs.

Tips and Best Practices

What should I do if I encounter errors in my workflow?

Short answer:
Test step-by-step, inspect data, and read the Executions log.

Process:
- Use Test Step per node
- Check Input/Output for format mismatches
- Pin data to stabilize tests
- Add validation/Set nodes to sanitize inputs

Bonus:
Paste error JSON into an AI assistant (or a specialized helper) for step-by-step fixes.

How can I keep my workflow canvas organized?

Short answer:
Name nodes clearly, use the Tidy button, and zoom strategically.

Tips:
- Rename nodes to business language ("Email - Decline," "Append to CRM")
- Label Switch outputs
- Group related nodes spatially and keep flows left-to-right
- Use modular subflows to reduce canvas sprawl

Additional FAQs (Beginner to Advanced)

How does the n8n editor interface work (Input, Parameters, Output)?

Short answer:
Each node shows three panes: Input (left), Parameters (center), Output (right).

How to use:
- Input: Inspect incoming JSON to know what fields exist
- Parameters: Configure the node; drag fields from Input to map dynamically
- Output: Verify the result before moving on

Why it helps:
You see exactly what's happening at each step, which makes debugging and iteration faster.

Why isn't my workflow running after I build it?

Short answer:
You must save and set the workflow to Active, and confirm the trigger is configured correctly.

Checklist:
- Is the workflow Active?
- Is the trigger set (Schedule, Webhook, Form, etc.)?
- For Schedule, is the time zone correct?
- For Webhooks, are you calling the correct URL and method?

Tip:
Use Test Workflow to run manually and verify downstream nodes.

Should I use n8n Cloud or self-host?

Short answer:
Cloud for speed and simplicity. Self-host for control and customization.

Choose Cloud if:
You want zero ops, reliable uptime, and quick collaboration.

Choose self-host if:
You need custom domains, network rules, advanced secrets management, or specific compliance. Many teams prototype on Cloud and migrate later.

How do I schedule workflows reliably (time zones and cron)?

Short answer:
Use Schedule trigger with clear time zone settings; for advanced needs, use cron expressions.

Tips:
- Align the editor's time zone with your team's operating zone
- For quarterly/odd schedules, cron gives more control
- Add a Set node to stamp run time for auditing

Example:
Run a reconciliation every weekday at 7:30 → set cron accordingly and log the run.

How do I keep credentials secure in n8n?

Short answer:
Use built-in credential storage, least-privilege scopes, and rotate keys.

Best practices:
- Separate prod/test credentials
- Lock down OAuth scopes (read vs. write)
- Store secrets as environment variables for self-host
- Limit who can edit credentials

Audit tip:
Document which workflows use which credentials to simplify reviews.

How do I version-control workflows?

Short answer:
Export workflows as JSON and track them in Git. Use branches for change management.

Workflow:
- Export before big edits
- Commit with clear messages (what/why)
- Use a test environment before deploying to prod

Benefit:
You can roll back quickly and review changes like code.