Who am I ?
My name is Walid Nouh. I’am an open source enthousiast for more than 20 years. I have a background in open source software development & project management. My current position is Product Builder.
I started automation with n8n in 2020, and I now use Make & Zapier for my daily work (disclamer : this analysis is not part of my work, even if it’s related).
A big thank you to:
- The french Nocode community
- Benjamin Potet (Senior Solutions Engineer at Make)
- Lilian Sevoumian (Official Make Partner)
- David Roberts (Head or product n8n)
- Kevin Janiky (Founder & CTO at ncScale)
- Jon (Community Engineer at n8n)
Goal of the analysis
The goal of this comparison is not to declare a winner, but to explore the pros and cons of each solution. I use both of them and wanted to have a deeper understanding of how they work.
I couldn’t find a in depth analysis of Make and n8n, so I decided to write my own.
My goal is, at the end, to be able to set a policy on when to use Make and n8n.
Terminology
Make:
- Scenario: a scenario comprises of a series of modules that indicate how data should be transfered and transformed between apps/services.
- App: an App is the name Make gives to their Connectors. It allows you to call a third-party API using wizards and easy configuration fields
- Module: A module is part of an App. It’s the actual service you call in an API. When you want to call a specific service in a third-party application, you use a Module.
n8n:
A Workflow is a connection of nodes connected together to automate a process.
Nodes are the building blocks of workflows in n8n. They’re an entry point for retrieving data, a function to process data, or an exit for sending data. The data process includes filtering, recomposing, and changing data. There can be one or several nodes for your API, service or app. You can connect multiple nodes, which allow you to create both simple and complex workflows.
Scenario in Make = workflow in n8n.
Module in Make = node in n8n.
Business model
| Topic | Make | n8n |
|---|---|---|
| Dev model | Company | Company backed + community |
| Company name | Celonis | n8n GmbH |
| Company founded/based in | Czech Republic | Germany |
| Independant company ? | Aquired by Celonis (Germany/USA) in 2020 | Yes |
| Project launch | 2016 | 2019 |
| Licensing model | Saas, proprietary | n8n Cloud : https://github.com/n8n-io/n8n/blob/master/LICENSE_EE.md, proprietary |
| n8n : https://docs.n8n.io/choose-n8n/faircode-license/, proprietary | ||
| White labelling | Yes – Private Instance | Yes – https://docs.n8n.io/embed/white-labelling/ |
| Embed in a commercial product | No | Yes, https://n8n.io/embed/ |
| Partnership program | Yes | Yes |
| Affiliate program | Yes | Yes – https://n8n.io/affiliates/ |
| Merch | No | Yes – https://merch.n8n.io/ |
| Certification program | Yes, https://academy.make.com/ | No, only https://n8n.io/experts/ + https://docs.n8n.io/courses/ |
Comments n8n’s business model :
- the code is available on github but it’s NOT FLOSS (Fair code license + license branch restriction)
- follows open source development methods : user contributions, custom integration apps, feature requests, etc.
- fast release cycle
- you can run your own instance for free if you have the skills to do so
Development cycle
| Topic | Make | n8n |
|---|---|---|
| Release frequency | https://www.make.com/en/help/about-make/release-notes | https://docs.n8n.io/reference/release-notes/ |
| Release note page | https://www.make.com/en/help/about-make/release-notes | https://docs.n8n.io/reference/release-notes/ |
| Number of apps/nodes | Official : 1363 | Official : 382 |
| Overall Documentation | Yes | Yes |
| App/Node Documentation | Yes | Yes |
| App/Node lifecycle management | https://www.make.com/en/help/modules/app-lifecycle | No |
| Feature requests | https://www.make.com/en/platform-ideas/ | https://community.n8n.io/c/feature-requests/5 |
| Public roadmap | No | No |
| Sources available | No | Yes on https://github.com/n8n-io/n8n |
| Public API | https://www.make.com/en/api-documentation | https://docs.n8n.io/api/ |
Hosting / Offer
| Topic | Make | n8n |
|---|---|---|
| SaaS platform | Yes | Yes |
| Servers location | Amazon AWS (EU/North America) | Microsft Azure (Frankfurt, Germany) |
| Cloud status page | https://status.make.com/ | https://status.n8n.cloud/ |
| Self Hosted | Yes, contact sales | Yes (n8n) / https://docs.n8n.io/choose-n8n/desktop-app/ |
| 2 Factor Authentication | https://www.make.com/en/help/access-management/two-factor-authentication | No, https://github.com/n8n-io/n8n/pull/4767 |
| Single Sign On | https://www.make.com/en/help/access-management/single-sign-on | https://community.n8n.io/t/user-and-privilege-management-got-created/208/9 |
| LDAP Authentication | https://www.make.com/en/help/access-management/single-sign-on#example–setting-up-single-sign-on-with-ms-azure-active-directory, https://www.make.com/en/help/access-management/single-sign-on | Yes (Self Hosted Entreprise plan only) |
Pricing
| Topic | Make | n8n Cloud | n8n (paid, Self Hosted Plan) |
|---|---|---|---|
| Pricing | https://www.make.com/en/pricing | Cloud: https://n8n.io/pricing/?cloud=true | https://subscription.n8n.io/ |
| Custom plans | Yes | Yes | Yes |
| Explaination of an execution | Every time a module in a scenario performs an action, it counts as an operation | An execution is when n8n completes one cycle of the workflow that you’ve built. Regardless of the amount of data that is processed and how many nodes are used | An execution is when n8n completes one cycle of the workflow that you’ve built. Regardless of the amount of data that is processed and how many nodes are used |
| Plans pricing involve (as of january 2023) ⇒ technical limitations | Number of operations | workflow execution | number of worfklows |
| Maximum file size | number of active workflows | workflow state (only active counts) | |
| Minimum interval between scheduled scenarios | https://docs.n8n.io/hosting/installation/server-setups/aws/#pod-resources | ||
| Maximum number of webhook queue |
- Comments Running workflows on n8n is currently cheaper than on Make. Choosing a Make plans involve more technical parameters.
Apps / Nodes development
| Topic | Make | n8n |
|---|---|---|
| Custom private apps/nodes | Yes (Custom Apps) | Yes, OnPrem version |
| Skills to develop an app/node | Understanding of JSON & APIs | |
| (https://www.notion.so/90163363c746497887ace8d3d6176bc1) | Git/ Writing JS code + understanding of APIs | |
| IDE extension | Yes (MS VisualCode) | No |
| Who can write apps/nodes ? | Everyone | n8n team or user contribution (Github’s contributions) |
| Who can publish apps/nodes ? | Everyone | users in the community nodes repo (npm packages) |
| App/node publication | Yes | |
| Yes | ||
| Ownership transfer | Ownership is transfered to Make in case of app publishing in the catalog | |
| If app is not published, access via an invitation link | Github Pull Request (PR) : ownership is transfered to n8n | |
| Community node : no ownership transfer | ||
| Who maintains an app/node ? | Mainly Make | |
| Users/editors can push the app updates | Code nodes : n8n team (or community members contribution) | |
| Community node : the node’s owner or team |
- Comments Apps/nodes update is my hot topic:
- who wrote the app/node ?
- what are its capabilities ?
- is it maintained ? who’s maintaining it ?
- what’s the workflow that triggers an app/node update in n8n or Make ?
- Apps are updated by Make, using review/QA
- Users can submit updates to their apps
- App updates policy:
- non disruptive: the app gets updated
- disruptive: the old app gets deprecated. Make keeps the app for compatiblity reasons
- App/node capabilities differences One my work example: everyday I export a list all of our Typeform forms to Notion for documentation purposes. In Make it’s easy, I just have to use the “List forms” functionnality. In n8n, I have to use an HTTP node instead (and read the API reference…).
In n8n you can only trigger action on a typeform submission 
In Make you can control most of Typeform’s configuration
Community
| Topic | Make | n8n |
|---|---|---|
| Forum / Q&A | Yes | Yes |
| Discord server | No | https://discord.gg/vWwMVThRta |
| Public feature request | Yes | Yes |
| Official french community | https://community.make.com/ (international) | n8n fr community : https://fr.community.n8n.io/ |
| n8n discord french channel | ||
| Other french community | http://redirection.nocode-france.fr/slack | http://redirection.nocode-france.fr/slack |
- Comments There’s no community chat server for Make 😑 Hopefully the Make channel on the french Slack community is really usefull and active👍 There’s an discord server for n8n: it’s the right place to get in touch with users and n8n employees!
Documentation
| Topic | Make | n8n |
|---|---|---|
| Rename a module/node | Yes | Yes |
| Comment a module/node | Yes (Notes) | Yes (Notes) |
| Comment some part of the scenario/workflow | No | Yes, Sticky Notes |
| Scenario/workflow blueprint | Yes | Yes |
| Scenario/workflow versionning | No | No |
| Scenario/workflow history | Yes | No |
| Scenario/workflow restore a previous version | https://www.make.com/en/help/scenarios/how-to-restore-a-previous-scenario-version |
- Examples
Sticking notes in n8n: easy way to document parts of your workflow 
In Make: right panel to add notes to your modules 
In n8n you can also add note in the Node configuration and display the note in the flow - Comments n8n’s combination of notes & sticky notes makes it easy to document your workflow. Make’s note display is hard to read IMHO. Workflow versionning is a big miss for both products
General scenario/workflow features
| Topic | Make | n8n |
|---|---|---|
| Scenario/Workflow templates | Yes | Yes |
| Use of Scenario/workflow templates | Yes | Yes |
| Create scenario/workflow templates | Yes, Team plan an above (https://www.make.com/en/help/scenarios/scenario-templates#template-types, https://www.make.com/en/api-documentation/templates-post) | No |
| Scenario/workflow Timeout | Yes, 40 minutes | Yes |
| Scenario/workflow export | Yes (file, API) | Yes (file, URL, API) |
| Scenario/workflow import | Yes (file, API) | Yes (file or URL, API) |
| Enable/disable a node | No | Yes |
| Enable/disable a route/branch | Yes | No, disable all its nodes |
| Conditional branches | Yes | Yes |
| Condition on apps/nodes relations | Yes | No |
| Manage dates | https://www.make.com/en/help/functions/date—time-functions#addyears–date–years- | https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.datetime/?utm_source=n8n_app&utm_medium=node_settings_modal-credential_link&utm_campaign=n8n-nodes-base.dateTime |
| Environments | No | No, coming |
- Comments Make: managing router execution branches order is not intuitive… n8n: understanding in which order the system process the nodes can sometimes be really tricky. You also have to understand when to use the splitInBatch module to avoid have timeouts or rate limits errors In n8n I’d love to be able to create my own workflow templates, where I include, by default, a general sticky note and set an error workflow 😇
- Example 2 approaches to manage dates. Each one has pros and cons:
In n8n managing date is a dedicated node 
Make provides functions to manage dates, not a module (source)
Core nodes
| Topic | Make | n8n |
|---|---|---|
| IF module/Node | Via router & filters | Yes |
| Switch module/node | Via router / Built-in app | Yes |
| Array functions | Yes | Yes |
| Converger option (branching and merging) | No (no converger option) | Yes |
| Array merge | Yes, functions | Yes, node |
| Store data / variables | Yes | Yes |
| Call an scenario/workflow from inside another one | Yes | Yes |
| Webhook | Yes | Yes |
| Execute custom code | No, soon | https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.code/ |
- Comments I find really annoying that Make doesn’t have a converger feature (https://www.make.com/en/help/modules/converger). Most popular feature request : https://www.make.com/en/platform-ideas/p/flow-control-converger-merge Make: no array merge feature and in general working with arrays seems hard for me coming from n8n
Two of n8n’ most powerfull features: you can create branches being executed in parallel and converging at some point. Second is the Merge node !
Errors management
| Topic | Make | n8n |
|---|---|---|
| Error module/node | Yes | Yes |
| Define an error scenario/workflow for a workflow | No | Yes |
| Retry on failed module/node | Yes | Yes (number of times, time between 2 tries) |
| Continue on failed module/node | Yes | Yes |
| Deactivate scenario/workflow after a number of failed execution | Yes | No |
| Operation rollback | Yes (depending on the app) | No |
| Incomplete executions management | https://www.make.com/en/help/scenarios/incomplete-executions | No |
- Comments Make has some cool features such as disabling a scenario that failed more than X times or scenario rollback. n8n is verry powerful as you can setup an error workflow in your own workflow settings. It allows catching all erros, even you do not specify error node for each possible errors cases. My personal best practice:
- one account per team
- one error workflow per account, logging messages on each team’s dedicated slack channel
- add the error workflow when adding new workflow
Workflow settings in n8n: you can define an error workflow
Logging
| Topic | Make | n8n |
|---|---|---|
| Log executions | Yes | Yes |
| Log manual executions | Yes (automatic) | Yes (setting) |
| Log successful executions | Yes (automatic) | Yes (setting) |
| Log unsucessful executions | Yes (automatic) | Yes (setting) |
| Send events to an remote log service | No | Yes, entreperise self-hosted or custom cloud (see https://docs.n8n.io/log-streaming/) |
Workflow development
| Topic | Make | n8n |
|---|---|---|
| Display input/output of a module/node | Yes | Yes |
| Pin output data of a module/node | No | Yes |
| Test only one module/node | Yes : app parameters values prompt | No: need for previous node execution output |
| Webhook test URL | No | Yes (different url than production one) |
- Comments n8n: Pinning the output data of a node is a real plus. It avoid executing the whole workflow just to test a node or a part of the workflow. Make: Being able to test a node by inputing it’s parameters is really useful.
Collaboration
| Topic | Make | n8n |
|---|---|---|
| Single user | Yes | Yes |
| Multi-users | Yes | OnPrem : Yes |
| Cloud : depend on your plan | ||
| Private scenario/workflow per user | Yes | Yes |
| Private credential | Yes | Yes |
| Share scenario/workflow | Yes | Yes (cloud only) |
| Share credentials | Yes | Yes (cloud only) (tbc) |
Products origins
n8n founder’s on YCombinator :
Jan Oberhauser:
I created it initially because I realized that every time I wrote a script to automate a small task it took me a very long time. Depending on the task it normally involved: reading documentation, writing code, committing to Github, deploying on a server, error reporting, SSL, make sure it restarts on a crash, and so on. So even very small tasks took at least half a day or day till everything was up and running properly. Existing Open Source solutions were not up to the task and also commercial ones like Zapier did not work for various reasons. Some being that they do not work well with in-house tools or complicated tasks and it gets expensive quite fast, …
So hope n8n is as helpful for other people as it is for me. Also, all help with further improving the project and create more integrations is very welcome!
⇒ n8n started as a technical project, by someone with technical skills
Make origins:
Here’s how: Prior to starting the development of Make circa 2012, Make’s cofounders had been orchestrating complex integrations for large enterprises. Like any Systems Integrator at the time, the team dealt with complex systems and legacy tools. They were already very good at what they did but also pondered that there had to be a better and more efficient way to execute.
This gave birth to the idea of a cloud-based tool with all the possible ingredients to take the pain away from making complex tools work with each other. As you know, history repeats itself and once again was an idea born to scratch one’s own itch.
Make’s cofounders (let’s refer to them as the I-team) believed that this tool will set them on a path to becoming the number one Systems Integrator in the Czech Republic; thus, Make was born in the beautiful city of Prague.
Soon after they began developing this internal tool, the I-team came across a SaaS tool that was built on the same principle of removing friction from integrating various apps. While this tool was in its early stages of development and was running a closed beta, SaaS Megastars like Dropbox, Stripe, and several others were changing the rules of the B2B software industry, forever altering the way software is bought and sold. This was the Aha moment. But it was also the Uh-oh moment.
⇒ Make started as tool to help integrators improve their job
Workflow optimization
I started automation by using a Self Hosted n8n: I had, at the time, no incentive to optimizing my workflows (but I would have to in case of dealing with a great amount of data).
By using Make, I always have to pay attention to executions. At the beginning it seems annoying, but then you realize that you get better at your job and you also save computing power (which is always good). In fact it’s one of the most interesting part of the job (as when you’re a developer and you always try to improve your code).
Workflow KPIs
Neither Make nor n8n can deal with KPIs: when you create a workflow, you set KPIs to check if your workflow meets your standards. Depending on the workflow, it might be a number of executions, PDF file generation, uploads to GDrive, etc.
In my case I simply send KPIs data in a Google Sheet for further analysis.
I hope that, in the future, Make and n8n could implement QA features!
Products audience
n8n ⇒ users with some technical background
Make ⇒ users with a functional background
As a technical person, depending on my user case, I would rather use Make or n8n. No need for choosing only one !
Conclusion
For me, one of n8n’s real added value is the On Premise feature, which allow you to host your own n8n instance and :
- access your internal tools : not public, behind a VPN, etc (this is the main reason why I started to use n8n)
- keep your data as much as possible in your hands (especially GDPR compliance)
If you plan to build a product and use n8n Self Hosted, be sure to read carefully n8n’s license and this thread
Make is much more user oriented and apps functionnalities are often richer that n8n nodes ones. I enjoy using it everday at work, but it lacks the user code execution feature, which can save time, executions (and, thus, cost) and some small features for scenario development that makes n8n so cool to use. From a developer perspective, n8n’s logic is natural (arrays, merge, if, switch, etc.).
I can only talk about the french Nocode community, but Make is the default choice if you want to perform good automation. It appears that people are more reluctant to try n8n because it seems much more technical. My guess is that n8n nodes provide less capabilities than Make apps: you often need to use HTTP nodes or JS code (having to find your way through an API documentation is a nogo for most people).
To conclude, I would say that my good practice is to think about Nocode as Code: what I create today is a technical debt for tomorrow 👍
Personal thoughts
By helping my colleagues to improve their workflows, what strikes me the most is app/node capabilities. If you’re autonomous on Zapier but not on Make or n8n, then they’re going to think “this tool is too complicated for me” and drop it.
Using one of these tools is not only about price but also:
- understanding which features are included or not, meaning that you’re going to waste time, executions and money reinventing the wheel
- what are my colleagues skills in automation: can they handle the product easily ? What kind of training do they need ?
- how are we going to collaborate ? what goal do we want to achieve ? who’s responsible for the overall consistency of the system ?
Using Make or n8n is one thing, but the most important thing is how do you share the knowledge, version and document your workflows and processes based on it (in my case I use ncScale for versionning).
And here, the Nocode communities have a lot to learn from software development.
This document is under Creative Commons Attribution CC BY
Le blog du wawa 