Why does self-hosted n8n crash when a few workflows run at once?

Short answer: on a small VPS, the usual cause is memory, not CPU. Each running execution keeps its items (and often binary data) in the memory of the n8n process. When three heavy workflows overlap, that process grows until the Linux OOM killer stops it, and everything else on the box (editor, webhooks, Postgres) suffers with it. The fix order is: limit how many production executions run at once, shrink what each execution holds, stop saving data you never read, and only then choose between more RAM and queue mode. Queue mode on its own does not give you more memory; it adds Redis and worker processes that also need RAM.

This came up in r/n8n on 17 November 2026: someone running "n8n in Docker with Postgres on a 2 vCPU, 2GB VPS" with "about 40 active workflows" said that when "three of the heavier workflows fire together, executions hang, the editor times out and dmesg shows 'Out of memory: Killed process (node)'" (thread).

Confirm it is really memory

Before changing anything, check:

  • dmesg -T | grep -i "out of memory" or journalctl -k | grep -i oom: an entry naming node means the n8n process was killed.
  • docker stats while the heavy workflows run: watch the n8n and Postgres containers.
  • Which workflows were running at the time of the kill (execution list, start times).

If there is no OOM entry and the box is just slow, look at CPU, disk I/O and swap instead. Swap keeps the process alive but can make it so slow that webhooks time out, which looks like a hang.

Step 1: cap concurrent production executions

Recent n8n versions support a concurrency limit for production executions in regular mode. Set N8N_CONCURRENCY_PRODUCTION_LIMIT (for example to 2 on a 2GB box). Executions above the limit wait in a queue instead of all starting at once. Check the concurrency control page in the n8n docs for your version; manual and test executions are not counted the same way.

This alone often stops the "three heavy jobs at once" crash, at the cost of some jobs starting later.

Step 2: make each execution hold less

Habit Why it eats memory Change
Pulling a whole table or API result in one call Every item sits in memory until the run ends Paginate, and process in batches (Loop Over Items)
Binary files kept in memory Large files multiply per item Set binary data mode to filesystem (N8N_DEFAULT_BINARY_DATA_MODE=filesystem), check docs for your version
Scraping full HTML and passing it along Big strings copied through every node Extract the fields you need early, drop the rest with a Set/Edit Fields node
One giant workflow doing everything All data lives in one execution Split into sub-workflows that each return only a small result

Step 3: stop saving what you never read

Saved execution data lives in Postgres and is loaded when you open executions. On a small box, keep it lean:

  • EXECUTIONS_DATA_PRUNE=true with a short EXECUTIONS_DATA_MAX_AGE (hours).
  • Do not save successful runs of high-volume webhooks (EXECUTIONS_DATA_SAVE_ON_SUCCESS=none), keep errors.
  • Give Postgres its own memory budget so it is not fighting n8n for the same 2GB.

Step 4: more RAM or queue mode?

Option What it fixes What it costs
Bigger VPS (e.g. 4GB) Headroom for spikes, simplest change Monthly cost, same single point of failure
Queue mode (Redis + workers) Separates editor/webhooks from heavy execution, lets you add workers More moving parts, Redis and each worker need memory; on the same 2GB box it can make things worse
Move heavy scraping elsewhere Keeps n8n for orchestration only Another service to run

A reasonable rule: if steps 1 to 3 keep you stable, stay on one box. If you still hit the limit with concurrency capped, add RAM first. Move to queue mode when you need workers on separate machines or need the editor and webhooks to stay responsive while heavy jobs run.

Checklist

  • [ ] OOM kill confirmed in kernel logs, not guessed
  • [ ] Production concurrency limit set
  • [ ] Heavy workflows paginate and batch
  • [ ] Binary data not held in memory
  • [ ] Execution data pruned; successful high-volume runs not saved
  • [ ] Postgres has its own memory budget
  • [ ] Decision on RAM vs queue mode made after the above

Does the same problem exist in Make?

Make is hosted, so you do not manage server memory, but you still pay per operation and hit scenario limits if you pull everything at once. The same habits (paginate, filter early, avoid passing large payloads) apply. If you would rather not run a server at all, you can try Make here.

Sources: r/n8n thread collected 18 November 2026 (Asia/Saigon). Environment variable names and defaults change between n8n versions; check the official n8n docs for your version before applying.

Want to build this visually? You can try Make here.

Disclosure: Some links are affiliate links — I may earn a commission at no extra cost to you.