Our sister brand KI-Radar has compared n8n and Make on features and usability, and that comparison holds. What it leaves open is the question a company asks in its second year on either platform: the scenario count has grown from three to thirty, the volume has crossed a tier, one scenario broke last Thursday and nobody noticed until Monday, and the person who built it asks whether the whole thing should just be a script.
Disclosure first: Grünberg.Digital runs roughly forty Make scenarios, and we also write our own PHP endpoints on our own hosting — the lead intake of our CRM is one of them. We described one of the Make chains, leads from a form through Claude into the CRM, in an earlier piece. So we sit in two of the three columns below, and we say where our own code loses.
1. Make: the credit is the unit
Make's pricing page lists five plans (checked 22 September 2026): Free at $0 with up to 1,000 credits a month, two active scenarios and a 15-minute minimum interval; Core at $12, Pro at $21 and Teams at $38 a month, each for 10,000 credits, with unlimited active scenarios and a one-minute minimum interval; and Enterprise at custom pricing. The page offers annual billing with the note "save 15% or more"; the annual amount itself was not legible to us, so the figures here are the ones the page displays, and an annual contract should come out at least 15% lower — on Core, $10.20 a month or less.
A credit is spent every time a module in a scenario runs; most actions cost one credit, some AI features more. Higher volumes are chosen on a slider — 20,000, 40,000, 80,000 credits and on up to eight million — whose prices the page does not show in the table. Credits you buy on top of your plan cost 25% more than the ones included in it (Make Help Center, "Adjustments to plans and pricing", updated 19 January 2026). When credits run out, scenarios stop.
That makes Make priced by what runs, not by what exists. The catch: a scenario that polls the CRM every fifteen minutes for new leads runs 96 times a day, 2,880 times in a thirty-day month — for one scenario that mostly finds nothing. The fix, a webhook instead of polling, is well known, and it costs nothing.
Make's real strengths are a visual builder a non-developer can read and a connector library that absorbs other vendors' API changes, which for third-party platforms is worth more than the subscription.
2. n8n: the workflow run is the unit — or the server is
n8n counts differently. On its cloud plans an execution is, in n8n's words, "a single run of your entire workflow. It doesn't matter how many steps are in the workflow or how much data it processes." A twelve-step chain that costs twelve credits on Make counts once on n8n.
The tiers, from n8n's pricing page (checked 22 September 2026), all in euros and billed annually:
- Starter: €20 a month, 2,500 workflow executions a month, five concurrent executions, one shared project, unlimited users.
- Pro: €50 a month, 10,000 executions, 20 concurrent executions, three shared projects, plus workflow history and execution search.
- Business: €667 a month, 40,000 executions, 30 concurrent executions, six shared projects, SSO, environments and Git version control. The page lists Business as self-hosted.
- Enterprise: price on request, custom execution volume, hosted or self-hosted, with an SLA.
Annual billing is marked "save 17%"; monthly prices were not shown to us and are not quoted.
The option that changes the category: the Community edition of n8n is free and self-hosted, published on GitHub under a source-available licence. The execution count becomes irrelevant; the cost is the server plus whoever keeps it running.
The trade-off: n8n is built for people comfortable with a JSON expression and a webhook URL, and self-hosting means updates, backups and the 2 a.m. call are yours.
3. Your own code: the script is the unit
The third column is a script on your own hosting: a PHP or Python file that receives a webhook, does the thing, and writes a line to a log. No credits, no tier. The cost is the developer's time to write it and to notice when it stops.
Working in both worlds has given us a rule precise enough to state:
- Code is a candidate for what talks only to your own systems. Form to CRM, CRM to newsletter sender, sender to task board. When both ends are yours, the platform translates between two APIs you wrote, and a short script does the same without a vendor's field renames.
- The platform keeps what talks to a third party. Posting to LinkedIn, reading an ad account, taking a payment: the connector absorbs their changes.
- The platform keeps what a non-developer has to edit. If the marketing manager changes the newsletter routing once a quarter, a visual scenario she can read beats a script she cannot.
Of our roughly forty scenarios, we estimate that about a third talk only to our own systems. Those are the candidates. The rest stay on Make.
4. The bill for a company of eight
A company of eight, 24 scenarios, 1,500 scenario runs a month in total, six modules per run on average. Eight of the 24 scenarios connect only the company's own systems and account for 600 of the runs. Prices as cited above, taxes left out; Make at the displayed price, n8n billed annually. The code column carries one developer's time at an assumed 800 euros a day, which you should replace with your own figure. Currencies are not converted.
Today. 1,500 runs × 6 modules = 9,000 credits a month. That fits Make Core: $12 a month, $144 a year. On n8n it is 1,500 executions, within Starter: €240 a year. With runs this short, Make is the cheaper platform; execution pricing pays off when chains get long.
The next building block. Someone adds a poller that checks the CRM every fifteen minutes. That is 2,880 more runs a month. On Make, 11,880 credits: over the 10,000 of Core, into extra credits at a 25% surcharge or the 20,000-credit tier. On n8n, 4,380 executions: over Starter's 2,500, into Pro at €600 a year, €360 more than before.
The code option. Move the eight internal scenarios and the poller to scripts on your own hosting. Writing eight small endpoints and a watcher that checks them each morning is about three developer days, 2,400 euros, then one to two days of maintenance a year, 800 to 1,600 euros. What remains on the platform is 900 runs, 5,400 credits: Make Core at $144 a year, or n8n Starter at €240.
Over three years:
- Stay on the platform and take the next block — n8n: Starter in year one, Pro in years two and three, €1,440. Make: the 20,000-credit tier or extra credits; the page does not show that price in readable form, so check it in your account before deciding.
- Stay on the platform and replace the poller with a webhook — n8n Starter throughout, €720. Make Core throughout, $432. No developer day needed beyond the change itself.
- Move the internal eight to code — build plus two or three maintenance years, 4,000 to 7,200 euros, on top of the platform's remaining $432 or €720.
Read across, and the result is plain: at a company of eight, the next building block is almost always cheaper than code. The step from n8n Starter to Pro is €360 a year; a single maintenance day is 800 euros. The step from Make Core to Pro is $108 a year, from Pro to Teams another $204. No scenario count makes twenty lines of code cheaper than that on the invoice, because the code's cost is not per scenario — it is per year of somebody looking after it.
Code becomes cheaper on the invoice in two places. The first is the large step: n8n Business at €667 a month is €8,004 a year, €7,404 more than Pro, and one of the main reasons to take it — Git version control and separate environments — is what a codebase has anyway. The second is volume: an agency running the same chain for twenty clients hits execution and credit counts where the tiers climb steeply, and a self-hosted n8n or its own code costs the same at a thousand runs as at a million.
5. Where our own code loses
We write our own endpoints and we still run forty Make scenarios. The reasons do not show up in the bill above:
- Maintenance does not stop. A PHP version upgrade, an expired certificate, a changed field in our own CRM — every one of them lands on the person who wrote the code. On Make, the connector for a third party is maintained by somebody else.
- The bus factor. One person knows why the script does what it does. The scenario has a diagram anyone can open; the script has a comment block.
- Silent failure. A Make scenario that errors shows red in a dashboard and can email you. A script that errors writes to a log nobody reads. The most important piece of our own code is therefore the watcher that checks every morning whether each endpoint ran and produced anything. Without it, the code column is cheaper and worse.
- No builder. A change is a code change, with a test and a deploy, and the marketing manager cannot make it herself.
What we get in return: the internal joins spend no credits, do not break on a vendor's release, and our form data reaches our CRM without passing through a third party. For us that is worth the maintenance days; for a company without a developer, it is not.
6. Verdict: the threshold is the next block, not the scenario count
There is no scenario count at which to switch, because the platform's price grows with runs, modules and features, not scenarios. The useful question is: what does the next building block cost per year, and is that more than a developer day or two of maintenance?
- Companies without a developer should stay on a platform, replace polling with webhooks before anything else, and compare Make's credits against n8n's executions once the chains get long. Our twelve-tools budget for small companies puts the automation line in the context of the rest of the bill.
- Companies with a developer and a handful of own systems should split: code for the internal joins, where ownership and reliability matter more than the invoice; platform for the third-party edges; and a watcher for the code. That is where we are, and we do it for control, not to save money.
- Companies facing a large step — n8n Business, Make Enterprise, or automation as the product for many clients — should price the code option seriously, because there the step costs more than the maintenance.
Whichever column you land in, build the watcher first. An automation that fails silently is worse than the manual step it replaced, because the manual step at least had somebody standing next to it.
Would you like to know which of your scenarios are translating your own language? Book a free initial consultation — export the scenario list, and the split takes half an hour.
7. FAQ: automation costs for small companies
What does Make cost for a small company?
Make's pricing page lists Free with up to 1,000 credits a month, and Core at $12, Pro at $21 and Teams at $38 a month for 10,000 credits each; Enterprise is priced individually. Annual billing is advertised as saving 15% or more. A credit is spent per module run, so the cost depends on how often scenarios run, not how many exist. Checked 22 September 2026.
What does n8n cost?
Billed annually, n8n Starter costs €20 a month for 2,500 workflow executions, Pro €50 for 10,000, and Business, listed as self-hosted, €667 for 40,000; Enterprise is priced on request. The self-hosted Community edition is free; you pay for the server and the upkeep. Prices from n8n's pricing page, checked 22 September 2026.
Is n8n cheaper than Make?
Not always. For short scenarios at low volume Make Core is cheaper: 9,000 credits fit into $12, while the same 1,500 runs need n8n Starter at €20. n8n wins with long chains, because a twelve-step workflow counts once, and when self-hosted.
When is our own code cheaper than the next plan?
When the next plan costs more per year than the maintenance of the code — roughly one to two developer days. For a company of eight that is rarely the case: the steps from Make Core to Pro ($108 a year) or n8n Starter to Pro (€360 a year) are smaller than a single maintenance day. Code wins on the invoice at large steps such as n8n Business, and at high volume.
What is the biggest risk of self-written automation?
Silent failure: a script stops, writes to a log nobody reads, and the process it replaced simply does not happen. The second is the bus factor — one person who knows how it works. Build a watcher that checks every morning whether each script ran and produced something before you move a single scenario to code.
