n8n vs Node-RED: automation platform showdown

I’ve run both n8n and Node-RED everywhere from a scrappy VPS to a Raspberry Pi cluster in my closet. They’re both excellent visual automation tools, but they shine in different places. This is the guide I wish I had when I started wiring SaaS APIs and MQTT topics at 2 a.m.

TL;DR

If you’re gluing SaaS tools, want a friendly UI, built‑in auth handling, and easy team features, start with n8n. If you’re running IoT/edge workloads, MQTT-heavy pipelines, or want a lean runtime you can push to hundreds of devices, Node‑RED is the default.

Quick comparison

Who should use which?

• Pick n8n if you:

  • live in Google/Notion/HubSpot land and need reliable connectors
  • want built‑in credential management and easy HTTP/API ergonomics
  • plan to scale horizontally with a queue + workers
  • prefer JavaScript everywhere instead of JSONata

• Pick Node‑RED if you:

  • run at the edge: Raspberry Pi, industrial gateways, PLC adapters
  • speak MQTT/OPC‑UA/Modbus all day
  • need a tiny runtime you can duplicate to hundreds of devices
  • want a permissive OSS license without commercial catches

• Use both when it’s pragmatic: Node‑RED at the edge publishing to MQTT/Kafka; n8n in the cloud orchestrating APIs and long‑running workflows.

Core concepts, quickly

• n8n: Workflows of connected nodes. Triggers (Cron/Webhook), data flows, JavaScript expressions in fields, a Code node for custom JS, and Execute Sub‑workflow for composition. Production setups typically use Postgres + Redis (queue mode).
• Node‑RED: Flows of nodes passing msg objects. Use Function nodes for JavaScript, JSONata for inline field logic, Subflows and Link Call for reuse. MQTT is first‑class.

Developer experience

Editing & ergonomics

• n8n gives you guided node UIs with pagination, schemas, and built‑in credentials. It feels like building API recipes. Sub‑workflows make reuse clean.
• Node‑RED is a fast, minimal canvas. You drag, wire, and go. Function nodes make it easy to drop into code. Subflows and link nodes help you DRY things up.

Expressions & transforms

• n8n: Use JavaScript expressions like {{$json.email}} directly in fields. For anything non‑trivial, the Code node is just JS.
• Node‑RED: Use JSONata for field mapping and filtering inside nodes. For custom logic, a Function node runs plain JS on msg.payload.

Version control

• n8n has Git‑backed Environments (dev/stage/prod) tied to branches. Push/pull between instances.
• Node‑RED Projects integrate Git into the editor. Great for code review and CI.

Security & operations

• n8n: Credentials encrypted with an app key; enterprise SSO (OIDC/SAML) available. Execution data pruning keeps DBs tidy.
• Node‑RED: You secure the editor with adminAuth, enable HTTPS, and lock down HTTP endpoints. For fleets, FlowFuse adds RBAC, SSO options, snapshots, pipelines, and multi‑instance HA.

Scaling models

n8n

Queue mode splits concerns:

• Main instance handles UI, scheduling, enqueues jobs
• Workers pull from Redis and execute
• Optional webhook processors absorb inbound spikes
• Shared Postgres stores executions and workflow state

It scales linearly by adding workers. Concurrency limits, pruning, and external binary storage keep things stable.

Node‑RED

Node‑RED is deliberately simple. You scale by running multiple instances and routing work via a load balancer (HTTP) or broker patterns (MQTT shared subscriptions). For HA and fleets, FlowFuse adds orchestration, persistent context, snapshots, and pipelines.

Ecosystem & connectors

• n8n: Hundreds of built‑in integrations for SaaS and data tools. The HTTP Request node fills gaps when a service isn’t covered.
• Node‑RED: Massive community palette with thousands of nodes, especially for protocols, hardware, dashboards, and industrial gear.

Practical examples

1) API glue with n8n (SaaS automation)

Goal: When a Notion task is moved to “Done,” send a Slack message and append a row to Postgres.

Workflow shape: Notion Trigger → Code → Slack → Postgres

Code node (transform Notion properties):

// input: items[] with Notion page properties
return items.map(item => {
  const p = item.json.properties
  const title = p.Name?.title?.[0]?.plain_text || "Untitled"
  const assignee = p.Assignee?.people?.[0]?.name || "Unknown"
  const completedAt = new Date().toISOString()
  return {
    json: {
      title,
      assignee,
      completedAt,
      slackMsg: `✅ ${title} completed by ${assignee}`
    }
  }
})

Tips: enable execution pruning; set retries on Slack; keep Postgres operations idempotent.

2) Edge telemetry with Node‑RED

Goal: Read a sensor via Modbus, filter noise, publish to MQTT, and display a local dashboard. Mirror the same data to the cloud.

Flow shape: modbus-read → smooth → function(filter) → mqtt out plus a dashboard tab.

Function node (sanity checks):

const v = Number(msg.payload)
if (!Number.isFinite(v)) return null // drop
if (v < 0 || v > 10000) return null  // clamp absurd outliers
msg.payload = { value: v, ts: Date.now() }
return msg

Tips: use MQTT shared subscriptions on the cloud side to scale; persist context on disk if you need local buffering.

Performance notes

• n8n: Database I/O becomes the bottleneck under heavy throughput. Use Postgres, tune pruning, avoid massive binary payloads, and isolate CPU‑heavy work in dedicated workers.
• Node‑RED: The runtime is lightweight; throughput depends on the work you do in Function nodes and on the broker/database you talk to. Scale horizontally with load balancers or MQTT shared subs.

Pricing & licensing in practice

• n8n: Community Edition is free to self‑host. Cloud and Business/Enterprise introduce execution‑based pricing. If you run low‑volume automations, that’s fine; for millions of monthly runs, self‑host CE or budget carefully.
• Node‑RED: Fully open‑source under Apache‑2.0. If you want managed hosting, FlowFuse offers plans; otherwise, DIY is common for both hobby and industrial use.

Debugging playbook

• n8n

  • Switch failing nodes to manual run and inspect inputs
  • Add Error Trigger to capture failures and notify
  • Watch worker logs in queue mode; mismatched encryption keys break credentials
  • Prune execution data to keep Postgres healthy

• Node‑RED

  • Use Catch and Status nodes
  • Add debug nodes at flow edges, not everywhere
  • For MQTT, verify QoS and retained flags; consider shared subs for multi‑instance setups
  • Enable persistent context only where needed

Migration tips (both directions)

• Replace API calls with HTTP nodes on either side first; keep payloads identical
• Encapsulate logic as sub‑workflows (n8n) or subflows/link‑call (Node‑RED)
• Stand up parallel paths and mirror traffic until outputs match
• When in doubt, put a broker in the middle and decouple

Choosing checklist

• SaaS‑first stack? n8n
• Edge/industrial? Node‑RED (optionally FlowFuse for fleets)
• Need SSO and branch‑based environments? n8n Business/Enterprise
• Strict OSS requirements? Node‑RED (Apache‑2.0)
• Millions of monthly runs? n8n CE self‑host with queue workers or Node‑RED clusters
• Heavy MQTT/OPC‑UA? Node‑RED
• Prefer JS over JSONata? n8n (or just stick to Function nodes in Node‑RED)

My take

If you’re building internal automations, data ops, or AI‑assisted workflows, n8n is the quickest way to something maintainable. If you’re pushing bits around unreliable networks or shipping to devices, Node‑RED is battle‑tested and ridiculously deployable. The sweet spot for many teams is both: Node‑RED at the edge, n8n in the core.