n8n vs Make:
Here's where I actually land after running both.

I ran Make for six months before I switched. I thought the visual canvas was clever, the pricing was fine, and the scenarios I'd built were solid enough. Then I hit a wall. The kind where you need the tool to do something the tool has decided you don't need to do. That's when you find out what a platform actually is. I switched to n8n. Here's what I learned running both for real work, not demos.

The verdict in two sentences, before we get into the details

Make's canvas is beautiful. That's also the first thing that fools people.

Make was Integromat until 2022. If you've been in this space for a while, you probably knew it as Integromat — it was the "more powerful Zapier alternative with a better visual editor" that people recommended when Zapier felt too simple. The rebrand to Make was mostly cosmetic. The underlying product is the same: a cloud-only automation platform with a scenario-based builder and operations-based pricing.

Make's visual builder is genuinely the best in class for this type of tool. The canvas feels intentional. Modules connect cleanly. The data flow from one step to the next is visible without hunting through sidebars. If you learn automation on Make, you'll probably like it. The visual logic is satisfying in a way n8n's canvas doesn't quite match at the same level.

That said, the visual experience is where a lot of the praise stops. Once you start thinking about how operations are counted, what happens when you need custom logic, and what the price looks like when your automations actually do real work, the conversation shifts.

Make's pricing looks reasonable until your automations do real work

Make's pricing model is built around operations. One operation is one module execution inside a scenario. A scenario that runs once, processes 10 records through 5 modules each, uses 50 operations. If that scenario fires 100 times a day, you're at 5,000 operations per day, 150,000 per month. The free plan gives you 1,000 operations per month. The Core plan gives you 10,000.

That math gets uncomfortable fast if your automations do real work.

Make looks cheaper than n8n Cloud at the low end, and that's genuinely true. If you're running a handful of simple scenarios with low volume, Make's $9/mo Core plan covers it. The problem is the ceiling. When operations run out, scenarios stop. If you're batch-processing leads, iterating over any list, or running anything that triggers frequently, you can burn through your monthly allotment in a day and not realize it until your automations silently stop working.

n8n Cloud charges per workflow execution, not per step inside the execution. That's a fundamentally different pricing model. A workflow that processes 200 items through 8 steps is still one execution. Make would call that 1,600 operations.

For self-hosters, this comparison looks completely different. n8n's self-hosted version is free. You pay for the server it runs on, typically $5–15/month for a small VPS. That's it. Unlimited workflows, unlimited executions, every feature available in the open-source version. Make has no self-hosted option at all. It's cloud-only, always has been, and that's not going to change.

Make is easier to start on. n8n is better to grow into. These are not the same thing.

Make wins this category and I'm not going to pretend otherwise.

The visual scenario builder in Make is the cleanest interface in this space. Modules are color-coded by type. Connections between them are visible and easy to follow. The data mapping panel is intuitive. When something breaks, the error output is presented clearly and you can usually diagnose the problem without leaving the editor. If you hand a Make scenario to someone who has never used automation tooling before, they can usually figure out roughly what it does just by looking at it.

n8n's editor has improved substantially. The current version is not the old version that looked like someone's side project. But it still has a higher ceiling to clear before you're comfortable. The data model takes a bit to internalize: items come through as JSON arrays, the node inspector shows you what each node received and returned, and expressions use a syntax that's not immediately obvious until you read the docs or play with the AI assistant. That learning curve is real.

There's also the self-hosting complexity if you go that route. Setting up n8n on a VPS, pointing a domain at it, making sure the environment variables are correct, keeping it updated. None of that is rocket science but it requires a few hours of attention and comfort with basic server stuff. Make never asks you to do any of that. You sign up and you build.

If ease of use is your primary criterion, Make is the better choice. There's no version of this comparison where that's not true. The question is whether ease of use is the constraint you're actually optimizing for, or whether you can absorb a few hours of learning friction upfront in exchange for more power later.

n8n wins on flexibility. Not by a small margin.

n8n wins this one. Not by a small margin.

The Code node

n8n has a node where you write JavaScript or Python directly, it executes, and whatever you return flows to the next node in the workflow. That's it. That's the thing. It sounds simple and it is, and it means there's practically no ceiling on what you can do inside an n8n workflow.

Parse a weird nested JSON payload from an API that doesn't have a native integration. Score incoming leads with your own weighted logic. Build a custom aggregation that groups items by three different fields. Call an external library. All of that fits inside a Code node, and you can put Code nodes anywhere in a workflow, chain them, run them conditionally, loop them over individual items or the full batch. The workflow can do whatever JavaScript or Python can do, which is essentially everything.

Make has a built-in function library. It's decent. You can do text manipulations, date formatting, math, conditional logic, array operations. But it's a curated set of functions exposed through a GUI, not actual code execution. If what you need isn't in the function library, you need a workaround or a different approach. With n8n's Code node, you just write the thing you need.

About 35-40% of my workflows have a Code node somewhere. Not because I prefer writing code to clicking through a visual builder, but because some logic just doesn't map cleanly to visual nodes and the Code node is always the right answer when that happens.

Loops and iteration

Make's iterator module is fine for basic iteration, but if you want to nest loops or do anything complex with how items are processed, you'll hit friction. n8n passes arrays natively through the entire workflow. Every node can either process all items at once or iterate over them individually, and switching between those modes is straightforward. Complex branching and merging logic is easier to manage in n8n once you understand how items work.

If you want to go deeper on how n8n handles data flow, my expressions guide breaks down how the item model actually works and how to write expressions that don't break when your data is unexpected.

Self-hosting and infrastructure control

If you're doing anything that involves sensitive data, you may not want your workflow runs stored on a third-party cloud. n8n self-hosted keeps everything on your own infrastructure. Your credentials, your execution logs, your workflow configs. None of it touches n8n's servers. For certain industries and use cases, that's not a nice-to-have, it's a requirement.

Make gives you no path here. Everything runs through Make's infrastructure. You can control what data enters your scenarios, but the execution environment is theirs.

AI and LLM integrations

n8n has built solid native support for AI agent workflows. There's a dedicated AI Agent node, built-in support for OpenAI, Anthropic, Ollama, and a number of other providers, plus memory and tool nodes designed to work with the agent flow. You can build multi-step LLM chains, have agents call other tools, and chain multiple models together without custom code.

Make has integrations for OpenAI and a few others through standard modules. It works. But the native n8n AI agent architecture is built for this in a way Make's module-based approach isn't quite. If AI agent workflows are where you're headed, n8n has a meaningful head start.

Make's integration depth is the one real counterargument, and it's worth taking seriously

This is Make's strongest counterargument and it's a real one.

Make has over 1,500 app integrations. n8n has around 400 native integrations, though the gap is shrinking and you can always fill holes with the HTTP Request node or custom credentials. But if you need a specific integration with some niche SaaS tool your company uses, there's a real chance Make has it and n8n doesn't.

That's not abstract. If the app you need isn't in n8n, you're building a custom HTTP request integration or you're using Make instead. Most common apps are covered on both sides. But as you get into more specialized B2B software, project management tools, regional payment systems, and other niche categories, the coverage gap shows up.

For my own workflows, I haven't hit this wall often. The apps I use regularly (OpenAI, Anthropic, Airtable, Notion, Gmail, Slack, Stripe, Beehiiv, GoatCounter, Reddit) are all in n8n. But I've seen people in automation communities specifically cite Make's integration depth as the deciding factor for their stack, and that's a legitimate reason.

A few things worth knowing about n8n's integration situation:

• The HTTP Request node covers any REST API without a native integration. You still have to set up authentication and build the requests manually, but it works.
• n8n's integration library is growing fast. Many apps that weren't there a year ago now have native nodes.
• The community contributes nodes. Quality varies, but there's often a community node for apps not yet in the official library.

Pick Make for today's problem. Pick n8n for next year's stack.

Pick Make when:

• You want a free tier that actually works. Make's free plan gives you 1,000 operations per month and lets you run real scenarios, not just toy demos. n8n's cloud has no real free tier. If budget is a hard constraint and self-hosting is off the table, Make's free plan is genuinely useful for simple workflows.
• Visual clarity matters for your team. If multiple people need to understand and maintain workflows without deep technical knowledge, Make's scenario builder is easier to read at a glance. n8n workflows can get hard to follow once they have a lot of nodes.
• You specifically need an integration n8n doesn't have. Check both app libraries before committing. If the app you need is in Make and not n8n, and you're not ready to build a custom HTTP integration, Make is the practical answer.
• You're building simple linear workflows at low volume. If your automations are "trigger happens, do A, do B, done" with nothing fancy inside them and they don't fire often, Make is fine. The operations model isn't painful until you're doing real volume or complex iteration.

Pick n8n when:

• You're processing any real volume. Batch jobs, frequent triggers, workflows that loop over lists of items. The execution-based pricing model doesn't punish you for doing real work inside a workflow run.
• You want to self-host. No monthly bill beyond your server costs. Full control over your data and execution environment. This is the obvious choice if you're comfortable with basic infrastructure.
• You need custom logic. If your workflow needs to do something a visual module library can't express, the Code node makes it a non-issue. Write the logic, connect it to the next node, done.
• You're building AI agent workflows. n8n's native AI agent support is purpose-built. The node types, the memory handling, the tool integration model, all of it works better together than Make's OpenAI module approach.
• You're already past the frustration point with another tool. If you're here because Zapier or Make started costing too much or limiting what you could do, n8n is where that frustration gets resolved. It's not beginner-friendly but it's the right long-term tool for serious automation work.

My verdict: n8n. Not close. Here's the honest version of why.

I'm on n8n. That's not balanced analysis dressed up as a conclusion. I picked n8n over Make the way you pick a tool that won't limit you six months from now over a tool that's easier to start with today.

Make is a well-built product. The scenario editor is genuinely polished. The integration library is real depth. The free tier is useful in a way n8n Cloud's trial isn't. If you're a non-technical person who needs simple automations and doesn't want to think about servers, Make is a reasonable choice and I'd rather you use Make than not automate at all.

But the operations model is a slow tax on everything you build. Every iteration, every module call, every time your scenario does actual work, that's operations ticking down. Once you internalize that your automations cost more when they do more, you start building differently. Not in a good way. You start wondering whether that extra step is worth the ops cost. You simplify things not because simple is better but because simple is cheaper. That's a broken incentive structure for automation tooling.

The Code node is the other thing. Once you've used it, going back to a function library feels like coding in a calculator. Write actual logic inside the workflow, call any function, transform data however you need. Your automations match the problem instead of working around the tool's limits. That changes what you build and what you're willing to try building.

If you're comparing n8n and Make because you're evaluating automation tools for the first time: start with n8n's self-hosted version on a cheap VPS. Setup takes a few hours. After that you have an automation platform with no monthly bill and no operations ceiling. Learn it properly and you won't be back here in six months wondering if you should migrate. The tools you build on Matter. Pick the one that grows with the work.

If you've looked at n8n and Zapier and want to see how that comparison stacks up, the n8n vs Zapier post covers that from the same angle. Spoiler: same verdict, different tradeoffs.

If you're going with n8n

The part that actually takes time isn't installing n8n. It's knowing what to build first, how to structure workflows that don't break in confusing ways, and what real production automations look like when they're doing useful work.

The n8n Starter Pack I put together covers that. It's 14 workflows pulled from my actual running stack: a webhook-based lead capture flow, an email triage automation that routes by urgency, a content publishing pipeline, a Stripe event tracker, and a Reddit monitor that catches relevant threads as they post. Every node has a note explaining the decision behind it. You can copy the JSON, import it into n8n, and reverse-engineer a real example instead of staring at blank canvas.

It's not a course. No videos. Just 14 annotated .json files and documentation for people who'd rather look at something real than read another tutorial about how workflow automation works in theory. It works on n8n Cloud and self-hosted both.