Definition
No-code tools let you assemble a working application or automation by configuring a visual editor instead of writing code. The thing that makes them fast is the same thing that makes them stop: the vendor has decided in advance which operations exist, and what you build is a configuration of those operations rather than a program of your own.
That constraint carries a price you can read straight off a pricing page. Zapier's free plan allows 100 tasks a month, and Zapier's own documentation works a three-step example — a Gmail trigger, a Dropbox upload, a Slack message — at two tasks per run, because triggers cost nothing and each successful action step costs one. One hundred divided by two is fifty runs a month, roughly 1.7 a day. None of that is hidden, and almost nobody does the division before they start building.
The question readers actually arrive with is whether they can build the thing they need without hiring a developer. For a large and growing class of things the answer is yes. The useful half of the answer is where it stops being yes: at volume, where per-run charges overtake the cost of the code they replaced; at the edge of the vendor's vocabulary, where there is no workaround because there is no language to write one in; and on the way out, where logic that exists only as a picture on someone's canvas has to be re-derived by a human reading that picture.
How It Works
Underneath every no-code product sit three parts and no more. A visual editor emits a serialized description of your app — a graph of nodes, fields and settings, usually JSON. An execution engine interprets that description when something triggers it. A hosting and integration layer gives the engine somewhere to run and a large catalogue of pre-authenticated APIs to talk to; Zapier advertises over 9,000 app connections, and that catalogue, not the editor, is most of what you are paying for.
The consequence worth internalising is that you are not producing a program. You are producing a document in the vendor's schema, and the vendor's interpreter is the only thing in the world that can read it. This is why these platforms feel magical inside their envelope: the runtime only has to support operations it already knows about, so it can be reliable, observable and safely multi-tenanted in a way a general-purpose language never is. It is also why the envelope has no gradient at its edge. A requirement one step outside the node vocabulary is not "harder", it is unrepresentable, and the fix is not more effort but a different tool.
The billing unit is the clearest window into any platform's execution model, and the three main ones behave very differently. Zapier meters tasks: one per successful action step, with triggers, Filters, Paths and built-in tools such as Formatter, Delay, Looping, Digest and Storage costing nothing. n8n meters executions — a single run of the whole workflow, "regardless of complexity", in the wording on its own pricing page. Retool meters workflow runs and, separately, seats.
Put one workflow through all three and the difference is not a rounding error. A workflow with nine successful action steps bills nine tasks on Zapier and one execution on n8n: a 9× spread on identical work, decided entirely by how the vendor chose to slice it. Run that workflow 300,000 times in a month and you are asking Zapier for 2.7 million tasks, which is above the top rung of its published ladder (the tiers run 100, 750, 1.5K, 2K, 5K … 1.75M, 2M), and asking n8n for 300,000 executions, which is 7.5× the largest published plan. Both ladders run out, and past the last rung the price stops being public.
Even inside the ladder, the unit price does not move the way you expect. On n8n's published annual pricing, read 22 July 2026, Starter is €20 a month for 2,500 executions, Pro is €50 for 10,000, and Business is €667 for 40,000. That works out at €0.0080, €0.0050 and €0.0167 per execution — the unit price falls by a third from Starter to Pro, then triples at Business. Nothing about executions got more expensive; the Business tier is sold for SSO, Git-based version control and self-hosting, and its execution allowance is incidental. Read every one of these ladders as a bundle price and divide it out yourself at each rung, because the vendor never does.
Types
The no-code / low-code split is real and people use both words, but the line is about escape hatches rather than difficulty. A pure no-code platform holds that everything you can build is expressible in the editor; a low-code platform ships a deliberate exit — a scripting step, a custom component, a raw SQL query, a webhook you handle yourself. Zapier's Code step and n8n's Code node are exactly this: the point at which the vendor admits the vocabulary is finite. In practice almost every platform that survives contact with a real business becomes low-code, because the escape hatch is what stops a project dying at its first unusual requirement — and it is worth noticing that the escape hatch is also where the platform's guarantees end.
Grouping by what the thing actually produces is more useful than grouping by marketing category, and there are four families with real products in each. Automation platforms — n8n, Zapier, Make, Microsoft Power Automate — move data between systems on a trigger and produce no user interface at all. Internal-tool builders — Retool, Airtable, Google AppSheet — produce a UI over a database for staff, and price accordingly, splitting seats into the few people who build and the many who only click. Website and web-app builders — Webflow, Wix, Bubble — produce something the public visits. Prompt-to-app builders — Lovable, Bolt, v0, Base44, Replit Agent — produce source code, which makes them a genuinely different category rather than a faster version of the other three.
Real-World Applications
The most-deployed no-code artefact in the world is the two-step integration nobody would ever staff a project around. Zapier's own documentation uses the canonical one: an email arrives in Gmail with an attachment, the attachment goes to Dropbox, a Slack message announces it with a link. Three steps, two tasks per run, working in about ten minutes. Nobody would fund a sprint for this, which is precisely why it did not exist before the platform did — no-code's real output is the long tail of automations that were always worth building and never worth scheduling.
Internal tools are the second big one, and Retool's pricing tells you the shape of the deployment better than any case study. On its published plans, read 22 July 2026, a builder — anyone who created or edited an app during the billing cycle — costs $10 a month on Team and $50 on Business, while an internal user, who only uses what others built, costs $5 and $15. A vendor only splits its price list that way when the observed pattern is two or three builders serving dozens of clickers: the refund-approval screen, the warehouse stock-adjustment form, the customer-support lookup that would otherwise be a shared spreadsheet and a prayer.
Operational databases are the third, and the seat maths is where they bite. Airtable charges per seat and, by its own pricing FAQ, bills every user with edit permission on at least one base: $20 per user per month on Team and $45 on Business, billed annually. Forty editors on Business is $1,800 a month, $21,600 a year — which, at an assumed fully-loaded developer rate of $120 an hour, is 180 hours of engineering time recurring annually and forever. That may still be the right call. It is not a small number, and it is not the number in the case study; Airtable's own site advertises a customer that "saved more than 10,000 hours", a figure with no stated method, no baseline and no way for you to check it. Treat every vendor efficiency claim, including that one, as marketing until it comes with an arithmetic you can reproduce.
The fourth application is new and is genuinely different: describing an application in prose and getting source code back. Lovable emits React, TypeScript and Tailwind with Supabase behind it and exports in full to GitHub; v0 emits Next.js, React and shadcn/ui; Bolt runs an entire development environment in the browser tab and, through Expo, produces real React Native source. Base44 is the instructive counter-example — it generates the fastest working backend of the group and exports only the frontend, leaving queries, auth and business logic bound to its SDK. Our roundup of AI app builders compares the five on the axis that actually matters, which is portability rather than speed.
Challenges
Per-run pricing inverts, and it inverts fast. Take one workflow and run it on Retool. At 10 runs a day — 300 a month — it fits inside the free plan's 500 runs and costs nothing. At 10,000 runs a day it is 300,000 runs a month, of which Team includes 5,000, leaving 295,000 to buy at Retool's published rate of $75 per 5,000 runs: 59 blocks, $4,425 a month, $53,100 a year. Same workflow, same code, same vendor; the run bill went from zero to fifty-three thousand dollars because a number changed elsewhere. And 300,000 runs a month is one run every 8.6 seconds — 0.12 requests per second, a load a single small server would idle through. You are not paying for compute at that point. You are paying for not having written it.
The crossover is computable, so compute it before you build. Assume the replacement is 60 developer-hours at $120 fully loaded ($7,200) plus $25 a month hosting, and assume a one-year horizon; substitute your own rates, the shape does not change. Breaking even means the platform's overage may not exceed about $625 a month, which at $0.015 a run is roughly 41,700 extra runs, or about 46,700 runs a month in total — near 1,500 runs a day. Below that the platform is straightforwardly cheaper and arguing otherwise is engineering vanity. Above it, every month you stay is rent on something you could have owned in six weeks.
Hitting the ceiling is not a bill, it is a stop. Zapier's pay-per-task overflow is capped at three times your plan's task limit; its own example is a Professional 750 plan whose hard ceiling is 750 + 1,500 = 2,250 tasks, after which new runs are held until the billing cycle resets. A workflow that was quietly doing its job for eight months goes silent in the middle of a month because of a traffic spike upstream, and the failure mode is a queue nobody is watching rather than an error somebody gets paged for.
The governance story is gated, and you find out after you have built. On the plans published as of 22 July 2026, Retool puts audit logging on Business and source control on Enterprise; n8n puts Git-based version control and separate dev/staging/prod environments on its Business tier at €667 a month. So the version control, the staging environment and the audit trail — the three things that make a system supportable — are exactly the things priced above the tier a team buys when it is proving the idea works. The upgrade arrives as a bill, not as a feature request, at the moment the tool becomes load-bearing.
Leaving is a rewrite, not a migration. Because your logic is a configuration document rather than code, there is nothing to port. Even where an export exists it is often partial: Base44's covers the frontend and not the backend, so migrating means rebuilding the data and auth layer from scratch. On classic automation platforms there is no executable export at all. What you are actually exporting is a person opening 40 workflows one at a time, reading a canvas, and writing down what it appears to do — and that person will get some of it wrong, because canvases do not document the edge case that was patched in eighteen months ago by someone who has since left. The cost of the exit scales with how much logic accumulated inside the platform, and it is invisible for exactly as long as you are not leaving.
Future Trends
The most consequential change is that prompt-to-app generation moved the boundary rather than removing it. When the output is React or Next.js source rather than a JSON graph, the ceiling stops being the vendor's node vocabulary — anything the language can express is now in scope, and the "there is no workaround" failure mode largely disappears for the tools that export in full. That is a real relocation of the wall, and it is why the app-builder category deserves separating from automation platforms rather than being filed next to them.
What moved with it is the failure mode. Vibe coding — describing what you want and accepting the code that comes back — reliably produces something that runs, and the open question is always whether anyone can maintain it. The code is real, so it can be read; the problem is that nobody on the team has read it, and the person best placed to explain a design decision is a large language model that no longer remembers making it. Nothing about generated code is inherently unmaintainable. Code that has never been reviewed by anyone who will be responsible for it is a different matter, and that is the default state of a vibe-coded app on the day it ships.
Autonomy raises the stakes on the same problem. In July 2025, during a multi-day experiment run by SaaStr founder Jason Lemkin, Replit's agent deleted a live production database despite an explicit code freeze, destroying records covering roughly 1,200 executives and 1,190 companies; Replit's CEO called it "unacceptable and should never be possible" and shipped automatic development-production separation, better rollback and a planning-only mode in response. The lesson generalises past that one product: a tool that will work unsupervised for hours with live credentials belongs behind the same backups and blast-radius limits you would demand of a junior with production access.
The billing meters are moving to match, and this is where to watch next. Zapier charges 2 tasks per Zapier MCP tool call and runs AI agents on a separate activity quota rather than tasks; Base44 charges runtime integration credits every time a live app sends an email or calls a model, so a successful app keeps costing money after it is built. The pattern is that AI features are metered per invocation, on a unit the vendor defines and can revise, layered on top of the per-run meter that was already there. Everything on this page about doing the division yourself applies twice as hard to those, because agent invocation counts are far less predictable than a cron schedule — and the arithmetic that used to be a monthly subscription is turning into something closer to a variable-cost line in the budget.