Low-code promises automation in a week, no developer, no IT department sign-off. Sometimes it delivers on that promise. More often than the landing pages admit — it doesn't. And the real cost only shows up six months in.
Make (formerly Integromat), Zapier and n8n are platforms where you connect one system to another by clicking: an order comes in from your marketplace — a message drops into Slack and a record appears in your CRM. It sounds like a dream for a business owner who's spent years hearing from IT vendors "that has to be developed, it'll take a quarter". And often the dream is real. But not always — and that's the entire conversation.
In the last two years we've seen automations that freed up half an FTE for people, and automations that silently swallowed 47 orders before anyone noticed. The difference almost never came from the platform. It came from how — and why — someone rolled it out.
When low-code actually makes sense
Low-code is in its element when: you're integrating two cloud systems with a decent API, the process is medium-critical (a short outage doesn't stop the business), and the volume is measured in hundreds, not hundreds of thousands of operations a month. That's where you actually win — no three-month project, just a few days of configuration and you move on.
At one of our clients — an 18-person electronics wholesaler in Wielkopolska — orders from Allegro and WooCommerce were flowing into Baselinker, and from there had to be moved by hand into Comarch Optima. A salesperson spent on average 4 minutes per order times 200 orders per week — 13 hours a week. A Make.com scenario (Baselinker → cloud Optima API) cut single-order handling to ~30 seconds. The freed ~12 hours a week went into debt collection, a gap the company had had forever.
Configuration took us 3 working days — not a quarter. Testing and rollout together — a week. Make licence cost: about 40 EUR a month for a plan sized to their volume. Payback: the first month.
Good candidates for low-code, in short:
- Notifications and syncs between SaaS systems (CRM ↔ Slack, form ↔ Trello, mail ↔ Notion).
- Importing/exporting from Excel to a system and back, when nobody wants to write a macro.
- Customer record updates between the CRM and marketing tools.
- Simple ETL between APIs — no accounting logic, no distributed transactions.
When low-code is a bad idea
The same technology can hurt the company badly if you push it into the wrong spot. A critical process — one whose failure means no invoice, no payroll or a tax fine — doesn't belong there. Not because the platform is bad. Because low-code tools are inherently "transparent": when the scenario dies at 2 a.m., you'll learn about it from a customer complaint, not from an alert.
Back to the wholesaler. Six months in, the Optima API vendor changed the rate limit — nobody sent an email. The scenario started silently dropping 2–3 orders a day, marking them as "processed" while they never made it into the system. Nobody noticed for 3 days. The result: 47 orders pulled by hand from Baselinker logs and entered manually over the weekend, one furious owner and a week of work on the monitoring that had been missing from day one.
Lessons worth taking before you start:
- Don't automate financially critical processes (KSeF, JPK, payroll) in Zapier. That's serious integration work with audit trails and logs.
- Don't connect on-prem systems via a cloud middleman if they don't expose an API to the internet — the whole scenario will always be fragile.
- Don't go low-code at high volume. 100,000 operations per month on Zapier is a six-figure annual cost. A developer will write the integration once and it will be cheaper.
- Don't build multi-step workflows with real business logic in clicks — no tests, no versioning, no code review. A year in, nobody will be able to read a 47-module scenario.
The hidden costs nobody mentions
The pricing page tells only part of the story. Zapier counts "tasks" — 100 tasks a month free, then from $20 for 750 tasks upwards. In a scenario that fires on every order and runs 5 steps, 500 orders is 2,500 tasks. Simple arithmetic scales fast.
Make is cheaper at volume — it counts "operations", with a 10,000-operation plan around 9 EUR a month. n8n you can self-host (open source), you pay only for a VPS, but then you need someone to maintain and update it.
The real hidden costs, the ones not on the pricing page, are:
- Maintenance. Every API change on the other side (new auth, deprecated endpoint) needs fixing. Typically 3–5 times over two years.
- Monitoring. Without email alerts and logs you're blind — and Make/Zapier don't do this well out of the box.
- Domain knowledge. Someone in the company has to know what the scenario does. If an external consultant built it and disappeared — congratulations, you have another legacy system, just a year younger.
- Versioning. There isn't any. If someone misclicks, rolling back is painful.
How to approach this pragmatically
A few rules that save companies pain:
- One scenario — one business owner. Not IT. The person who will notice something is off, because they use the output daily.
- Alerts to a channel someone actually reads. An email to 4 people "just in case" gets read by nobody. A Slack or Teams channel with one on-call owner — that gets read.
- A production test with a test customer. Always run the first order/record after any change on your own data before letting the automation touch real customers.
- One-page documentation. What the scenario does, its triggers, who owns it, where the API secrets live. Without this, in a year you can't touch it.
- A quarterly audit. 15 minutes, check whether the scenarios still fire and whether their stats look sane.
Which one: Make, Zapier or n8n
In practice: for a typical Polish 10–50-person SME with no in-house IT — Make. Considerably better value than Zapier, plenty of ready integrations including Baselinker, WooCommerce, cloud Comarch Optima, Subiekt GT via its own API.
Zapier has its place in a small business that lives entirely in Google Workspace and Slack — it's the simplest, but the fastest to get expensive.
Go with n8n when you have a technical person on the team, want full control, and plan to build a dozen or more scenarios. Then self-hosted n8n pays for itself in 2–3 months.
What next
Low-code is neither a cure-all nor a toy. It's a very good tool for very specific jobs and a very bad one for others. A business owner doesn't have to know every one of these tools — but they do have to be able to ask the question "if this dies, who finds out, and how many minutes later". If the vendor doesn't have an answer, this isn't a project yet, just a demo.
If you're wondering where in your business low-code would actually save hours — and where a few days of a developer would serve you better — come talk to us. No pitch at the end.
Low-code won't replace a proper integration where money is at stake. But in the many places where it isn't, it can save you half an FTE at a very small cost.