Nobody memorizes the panel. You learn where things live.

You met the nodes panel earlier in this series: press + on an empty spot on the canvas, or click Add first step in the right-hand panel of a new workflow, and a list slides in from the right. What is inside it is frightening the first time.

• 400+ official nodes — Slack, Gmail, Notion, Airtable, HubSpot, Stripe, GitHub and the rest.
• 30+ Core nodes — IF, Switch, Merge, Edit Fields, Code, Wait, HTTP Request.
• A whole separate row of Trigger nodes — Schedule, Webhook, and a Trigger version bundled with nearly every SaaS.
• The entire AI and LangChain set — AI Agent, Chat Model, Memory, Vector Store.

You do not have to memorize those names. What you need is narrower: see a node and know within two seconds which family it belongs to and roughly what it does. That is also how you know which part of the panel to head for when you build your own.

The conclusion first, one line each. These match the four folders under the official docs.n8n.io/integrations/builtin/ tree:

Now the thing that confuses almost everybody on first reading. Trigger is a functional role. Core, App and Cluster are the docs' file categories. The two dimensions cross, which is why the pages for Schedule Trigger, Manual Trigger, Chat Trigger and Webhook live under core-nodes/: they are both Trigger by function and Core by category. This is not a mutually exclusive pick-one-of-four.

flowchart LR
  subgraph F["Three file categories in the docs"]
    direction LR
    C1["core-nodes/
built-in flow, data
and utility tools"]
    C2["app-nodes/
one node per
outside service"]
    C3["cluster-nodes/
an AI root node
plus its sub-nodes"]
  end
  T["Trigger
a functional role:
it decides when a workflow runs"] -.->|"Schedule Trigger, Manual Trigger,
Chat Trigger and Webhook are filed here"| C1

The node that decides when a workflow runs

Every workflow needs a starting point, and that starting point is a Trigger node. The first groups you see when the nodes panel opens are usually On app event, On a schedule and When called by another workflow. All of them are Triggers.

Trigger nodes have one visual giveaway: there is no input dot on the left. It is the starting point, so there is nothing upstream to connect it to. On the right there is one output dot that sends data downstream.

They are easy to find, too. The panel's first page defaults to Triggers, and starting a new workflow steers you straight to picking one. Without a Trigger there is no starting point, and the workflow cannot run at all.

One node per outside service, with every operation folded inside it

App nodes are the largest of the four families. The docs keep them under integrations/builtin/app-nodes/ and the panel labels them Actions in apps. What they share: each node maps to one outside service — a SaaS, a database, a cloud provider — and the node wraps every operation that service's API offers.

If you have used Zapier the idea is identical: there each app maps to an action, and in n8n each SaaS maps to one App node. “App node” is the docs' file name and “Action” is the panel's UI label — the same thing, so do not worry when this guide uses both.

One Action node usually holds many sub-operations. Take Slack:

You do not have to memorize those. Once the Slack node is on the canvas, the Operation dropdown on the right lists every option.

The docs group Action nodes into roughly these categories, each with its place in the panel:

The visual giveaway for App nodes: a dot on each side — the left one takes data from upstream, the right one sends it downstream — and an icon that is usually the service's own logo. Slack's purple hash, Gmail's red envelope, Notion's black-and-white page.

The fittings that join everything else together

Core nodes are n8n's own built-in set, filed under core-nodes/. There are fewer of them than App nodes, but every one matters. Their job is managing the data flow and control flow inside a workflow, plus general-purpose tools that are tied to no SaaS.

One warning about naming first. The category names in the panel have changed a few times: they used to be Core Nodes, then split into Flow, Data Transformation, Files and Helpers. The exact wording varies a little with your n8n version, so recognize the grouping rather than the word, and search rather than browse when you cannot tell them apart.

The visual giveaway for Core nodes: a dot on each side, and an icon that is abstract geometry rather than a brand mark — a forking arrow for IF, converging arrows for Merge, a pen or field icon for Edit Fields, angle brackets </> for Code. IF and Switch branch, so they carry several output dots on the right. A node with no SaaS logo is almost certainly Core.

One root node with a stack of sub-nodes underneath

The docs file Cluster nodes under integrations/builtin/cluster-nodes/ as the fourth family, and they are the biggest architectural change in the n8n ecosystem since 2024. A cluster is not one node but a group of nodes. Every cluster has one root node — the main node, for example AI Agent — with several sub-nodes attached below it to supply capabilities.

flowchart TD
  IN["Data in
from upstream"] --> A["AI Agent
the cluster root"]
  subgraph S["Sub-nodes"]
    direction LR
    CM["OpenAI
Chat Model"]
    MEM["Simple
Memory"]
    TL["Wikipedia
Tool"]
    VS["Simple
Vector Store"]
  end
  A -->|"ai_languageModel"| CM
  A -->|"ai_memory"| MEM
  A -->|"ai_tool"| TL
  A -->|"matching ai_* dot"| VS
  A --> OUT["Data out
to the next node"]
  VS ~~~ OUT

Cluster nodes are easy to spot. The root node grows a row of square, downward-facing connector dots along its underside — not the left-and-right round dots of Trigger, App and Core — each labeled Chat Model, Memory, Tool or Vector Store. Attach the matching sub-node from below and n8n treats the cluster as complete and ready to run.

Part 16 takes apart the full arrangement and the ai_* connector dots. For now: downward dots on the underside means a Cluster root, and whatever snaps up under them is a sub-node.

Four things to look at, in this order

With the four families in hand, the skill that pays off is classifying a node at a glance. Check these four features and you have the answer in about a second.

1. Look underneath for ai_* dots. Square downward dots labeled Chat Model, Memory, Tool or Vector Store mean a Cluster root. The other way round: only one upward dot on top, waiting to be picked up by a root, means a sub-node.
2. Look on the left for an input dot. No dot on the left, only a line leaving on the right, means it is definitely a Trigger. A node sitting alone at the far left of the canvas with nothing wired in front of it is a Trigger. The name usually carries “Trigger” or “On…” — Slack Trigger, Schedule Trigger, Webhook, On form submission.
3. Look at the icon. A dot on each side plus a service logo is almost certainly an App node. A dot on each side plus abstract geometry — a fork, a confluence, a gear, angle brackets — is almost certainly a Core node.
4. Look at the panel's own categories. The panel is already sorted for you: Triggers, Actions in apps grouped by service, Core with its Flow / Data Transformation / Files / Helpers sub-areas, and AI or Advanced AI for Cluster nodes. When you cannot tell, go back and see which label it sits under.

flowchart TD
  A["A node you do not recognize"] --> B{"Square dots along its underside,
labeled Chat Model, Memory or Tool?"}
  B -->|"yes"| C["Cluster root"]
  B -->|"no"| D{"One dot on top only,
waiting to be picked up?"}
  D -->|"yes"| E["Cluster sub-node"]
  D -->|"no"| F{"Is there a dot
on the left?"}
  F -->|"no dot on the left"| G["Trigger"]
  F -->|"a dot on each side"| H{"What is the icon?"}
  H -->|"a service logo"| I["App node"]
  H -->|"abstract geometry"| J["Core node"]

The shapes real workflows come in

How do the four families combine in practice? From shortest to most complex there are roughly four rhythms, and almost everything you will be shown is one of them.

The common rhythm in full: “Every morning, fetch the support tickets, keep only the urgent ones, write them into Notion and tell the sales manager.”

flowchart LR
  A["Schedule Trigger
every morning"] --> B["HTTP Request
read the ticket API"]
  B --> C["IF
priority == urgent"]
  C --> D["Notion
create a page"]
  D --> E["Slack
notify"]

The same pattern shows through all four. Usually one Trigger, sometimes several. App nodes doing the heavy lifting, over 60% of the node count. Core nodes as the pipe fittings that join them up — IF decides which way to go, Edit Fields reshapes the data, Merge brings the lines back together. And Cluster as the AI-only shape of one node with several tendrils.

Type the keyword, and know the ways it comes up empty

Knowing the categories is what lets you read a workflow. To find one, though, you will never scroll: typing a keyword beats everything else. Four things to try, in this order.

And these are the situations people hit most often when they first work with the panel.

The questions people ask after their first hour

Where to go from here