Research checked 27 August 2026 against the providers’ official public pages and documentation. This is educational research, not personal testing, a recommendation for every business or a claim about traffic, savings or results. Features, limits and prices can change.
The short answer
There is no responsible universal winner. Make and Latenode are both hosted visual automation platforms, but they meter usage differently and place their emphasis in different areas. Make centres workflows on a visual scenario canvas and a large catalogue of pre-built apps. Latenode combines a visual node canvas with prominent JavaScript and AI-building options, and charges principally for workflow runtime rather than each node operation.
For a real decision, map one representative workflow in both systems. Confirm every required action and permission, test failure paths, then compare measured credit or CPU-second use. A simple headline such as “more integrations” or “not charged per step” does not show whether a platform fits your exact data, volume and maintenance capacity.
At-a-glance comparison
- Builder: Make calls automations “scenarios” and displays app modules, routes and filters on a visual canvas. Latenode also builds scenarios from connected nodes, with separate Development and Production states documented for deployment.
- Integrations: Make advertises more than 3,000 pre-built apps. Latenode’s documentation advertises more than 5,500 integrations across apps, AI models and core nodes. Those labels and counting methods are not necessarily equivalent; compare the exact trigger, action, field and authentication method you need.
- Code and AI: Make offers AI apps and agents, custom API requests, custom apps, and a Code app for JavaScript or Python. Latenode documents JavaScript, Node.js and Bun tools, AI-generated JavaScript nodes, AI agents and built-in model access. Generated logic still needs review and failure testing.
- Billing: Make primarily meters credits; most non-AI module operations use one credit, while code execution and some AI features use credits differently. Latenode meters scenario compute time in CPU seconds, while its Plug&Play AI tokens and optional add-ons are separate charges.
- Operations: Both provide run history and debugging information. Their recovery controls differ, so test the behaviour of retries, ignored errors, partial completion and replay before a live rollout.
1. Builder approach
Make’s official product overview describes a drag-and-drop visual builder with modules, routers, filters, data transformation and webhooks. This can make a multi-app flow easy to scan, but a large canvas can still hide assumptions in filters, mappings and individual module settings.
Latenode’s scenario-building documentation describes a left-to-right chain of nodes that can be run and inspected one at a time. Its publishing guide separates a Development version from the Production version, so edits can be prepared without immediately changing the live scenario.
Fit question: will the people maintaining the workflow understand a module-led visual canvas, or do they need a clearer development-to-production workflow and closer access to code?
2. Integrations: count less, verify more
Make’s public product and pricing pages advertise 3,000+ apps. Latenode’s official introduction advertises 5,500+ integrations and describes a catalogue that includes apps, AI models and core nodes. Because the categories differ, the headline totals are not a like-for-like measure of app coverage.
Search each catalogue for the exact business requirement. An app logo does not prove support for a particular UK account type, regional feature, attachment, custom field, webhook, search action or OAuth scope. If a native action is missing, Make documents HTTP and custom-app routes; Latenode provides API and JavaScript-based options. Either workaround transfers more maintenance responsibility to the business.
3. Custom code and AI options
Make’s pricing and credit documentation list a Code app that runs JavaScript or Python, charged at two credits per second of code execution. The same documentation distinguishes Make’s AI Provider, automatic connections and a business’s own AI-provider key; token-based or dynamic credit use may apply depending on the feature and connection.
Latenode describes itself in its official documentation as a low-code platform combining visual building, JavaScript and AI. Its AI node guide says a plain-language request or cURL command can generate a configured JavaScript node, which the user can review and adjust. It also documents direct JavaScript, Node.js and Bun code tools and AI-agent workflows.
AI assistance can shorten a first draft, but it does not validate permissions, data protection, edge cases or business rules. Custom code can solve gaps, but it also creates code ownership, dependency, security-review and handover work. Ask who will review generated code and maintain it when an API changes.
4. Billing units and entry plans
Make’s official pricing page currently lists a Free plan with 1,000 credits per month, two active scenarios and a 15-minute minimum scheduled interval. Its first paid tier is Core, shown with 10,000 credits at the selected entry volume, unlimited active scenarios and scheduling down to one minute. The displayed dollar price depends on the billing selection, so check monthly versus annual commitment, current taxes and the checkout currency rather than treating a captured figure as a UK quote.
Make explains that most non-AI apps use one credit per operation, but one scenario run can create many operations as bundles move through later modules. AI, code and some advanced features can consume credits differently. A short scenario is not automatically a one-credit run.
Latenode’s official pricing page currently lists a Free plan at $0 with 10,000 CPU seconds each month, five active workflows and no card required to start. Its next route is Pay as you go with no fixed base platform fee: the first 10,000 CPU seconds remain free, then tiered per-second rates apply. The paid route also lists higher capacity, including unlimited active scenarios, longer run history and more parallel workers.
Latenode’s CPU-second guide says billing is based on total scenario compute time rather than node count and that Free-plan runs have a minimum charge of one CPU second. Its billing documentation says Plug&Play tokens are separate from CPU seconds and documents optional add-ons and spend limits.
Do not compare 1,000 Make credits with 10,000 Latenode CPU seconds as if they were the same quantity. Model at least a quiet month, a busy month and a failure-heavy month. In Make, measure operations, repeated bundles, retries, code and AI use. In Latenode, measure runtime, concurrency, Plug&Play usage and any add-ons. Include separate third-party AI or API bills where you supply your own account.
5. Monitoring and error handling
Make’s error-handling overview documents error-handler routes and directives including retry, resume, ignore, rollback and commit behaviour. It also describes incomplete executions as a queue for failed or unfinished work when enabled. The selected response matters: continuing after an error can be useful, but it can also leave systems inconsistent if an early write succeeded and a later write failed.
Latenode’s execution-history guide documents run status, duration, billed CPU seconds, operations, node data and errors, plus reuse of execution data and restart of a past run. Its retry guide documents node-level retry attempts and delays; its ignore-errors guide says a scenario stops by default when a node fails unless that option is enabled.
For either platform, create test cases for expired authentication, duplicate triggers, rate limits, missing fields and downstream outages. Confirm alert delivery, data retained in logs, retry idempotency and the manual reconciliation process. A history screen is useful only if somebody owns its review.
6. Maintainability and business fit
Make may deserve the first evaluation when the required actions already exist in its catalogue, a visual operations team will own the workflow, and credit use can be estimated from representative runs. Latenode may deserve the first evaluation when runtime-based billing suits the workload, the team wants built-in JavaScript and AI options close to the canvas, or Development and Production versions are important to the change process. These are reasons to investigate, not conclusions about lower cost or greater reliability.
A platform is not maintainable merely because the original author can build quickly. Prefer the option another named person can understand, test and recover. Record the workflow purpose, owner, connections, fields, filters, code, expected volume, alert route, privacy decision, rollback or reconciliation method and review date. Avoid combining unrelated business processes into one large scenario simply to reduce apparent usage.
Decision questions before signing up
- Does the platform support every required trigger, action, field and UK account variation natively?
- If custom HTTP or code is needed, who will secure, review and maintain it?
- What did ten representative runs consume in credits or CPU seconds, including loops, AI, retries and failures?
- What other bills remain: AI-provider tokens, Plug&Play tokens, API subscriptions, add-ons, VAT or currency conversion?
- What happens after a mid-flow failure: stop, retry, ignore, resume, roll back or leave a partial update?
- How long is useful execution history retained on the intended plan, and who checks alerts and failed runs?
- Can changes be tested without altering the live workflow, and can a known-good version be restored?
- Which staff can access scenarios, connections, logs and stored data, and does that meet the business’s UK GDPR and security requirements?
- Can a second person understand and recover the workflow from the documentation?
- Which measured result would make the business choose the other platform—or keep the process manual?
A practical evaluation
- Choose one low-risk, representative workflow and write down its inputs, outputs, exceptions and owner.
- Build a small proof in each platform with non-sensitive test data.
- Record missing native actions and every use of HTTP, code or AI.
- Run normal, high-volume and deliberately failing cases.
- Compare measured usage, log visibility, recovery effort and handover clarity—not provider calculators alone.
- Only then select a plan and set spending, access, alerting and review controls.
For a platform-neutral preparation step, use the no-code automation checklist. The Make evaluation guide, Latenode evaluation guide and Latenode pricing guide provide more detail.
Affiliate disclosure
The two buttons below are affiliate links. If you register through one and later make an eligible purchase, UK Digital Tools Research may receive a commission, at no extra charge because of the link. The commercial terms differ by provider. This does not make either platform the better choice, and no saving, approval, performance or business result is guaranteed. Read this site’s full affiliate disclosure and check each provider’s current pricing and terms before deciding.
No personal testing, audience size, traffic, customer outcomes or affiliate results are claimed in this comparison.
Official sources checked
- Make product overview
- Make pricing and plan comparison
- Make Help Center: how features use credits
- Make Help Center: error handling
- Latenode documentation: introduction and integrations
- Latenode pricing
- Latenode documentation: CPU seconds
- Latenode documentation: billing
- Latenode documentation: execution history
- Latenode documentation: Development, Production and version history