Running on Make?

Make scenarios blowing up or burning operations? We clear the backlog.

A Make scenario that worked fine for six months is usually what brings us in. A connection expired, an upstream API slowed down, or a router branch started firing on every run and quietly tripled the operations bill. We open the scenario, read the execution history, and rebuild the fragile parts into something that will survive the next schema change.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

make-scenario.log

still broken

What it is

Make (Integromat) at a glance

Make, which used to be called Integromat, is a visual automation platform where you wire up modules on a canvas to pass data between apps. It competes with Zapier and n8n, and its distinguishing feature is a richer execution model: iterators, aggregators, routers, data stores and nested bundles let you build things that would be a multi-Zap chain elsewhere.

Billing is based on operations, where every module that runs for every bundle counts as one. That makes scenario design directly financial: a router that lights up every branch on every run, or an iterator over a 10,000-row payload, can quietly eat a plan's monthly operations in an afternoon.

Type
Visual workflow automation (iPaaS)
First released
2012 as Integromat, rebranded to Make in 2022
License
Proprietary SaaS, operation-based pricing
Maintained by
Celonis (Make)
Typically used for
App integrations, data syncs, scheduled workflows, webhook processing

The honest version

Make (Integromat) pros and cons

No technology is all upside. This is where Make (Integromat) earns its place and where it tends to cause trouble.

Where Make (Integromat) is strong

  • Visual editor with real powerIterators, aggregators, routers and error handlers mean you can build logic in the canvas that would need code elsewhere, and still see how the data flows.
  • Deep app catalogModules exist for most SaaS your team uses, and the HTTP module lets you talk to anything else without writing a custom connector.
  • Execution history is detailedEvery bundle at every module in every run is stored and inspectable, which makes debugging a failed integration far less of a guessing game than in rival tools.
  • Scenario control is granularScheduling, max cycles, retry policy and error handlers can be configured per scenario, so one broken scenario does not take the whole workspace down.
  • Reasonable pricing at modest scaleOperation-based pricing tends to be cheaper than Zapier's task pricing for scenarios that process bundles in batches rather than one at a time.

Where Make (Integromat) bites

  • Operation bills can explode overnightA router that fires on every branch, an iterator over an unbounded array, or a trigger polling every minute will consume a plan's monthly operations alarmingly fast.
  • Error handling is subtleThe default rollback behavior stops the scenario on repeated errors, which protects data but also silently blocks important workflows until somebody notices.
  • Connection token expiry is a recurring headacheOAuth connections lapse on their own schedule, and when they do the scenario fails quietly on the next run with a 401 nobody is watching for.
  • Complex scenarios become unreadablePast about thirty modules the canvas is easier to explain than to maintain, and any handover between engineers needs documentation Make does not generate for you.
  • Versioning is thinThere is no real git-style history of a scenario. A bad edit in the canvas can be reverted within a short window, and after that the previous shape is gone.
  • Vendor lock-in is realScenarios are not portable. Moving a complex automation off Make means rebuilding it in Zapier, n8n, or custom code rather than exporting and importing.

Sound familiar?

Common Make (Integromat) problems we fix

The Make (Integromat) problems that bring people to us, and what you have once each one is fixed.

Operations used 1,089,412 / 1,000,000

Operations bill is over plan every month

A router with multiple active branches, a scheduled trigger running too often, or an iterator processing arrays that have grown by an order of magnitude since the scenario was built.

Scenarios restructured within budget

token has been expired 401

Connections keep expiring

OAuth tokens that lapse quietly, usually on a long weekend, with no alerting in place so the scenario just stops running until somebody logs in on Monday.

Connection health monitored and alerted

Maximum consecutive errors reached

Scenario stopped and nobody noticed

An upstream API returning 500s, the rollback behavior stops the scenario after three failures, and the only signal is an email nobody reads.

Alerts routed to Slack or on-call

data loss may have occurred

Bundles disappeared mid-run

Incomplete executions that never got requeued, usually after a crash in a long iterator or a timeout on an HTTP module near the end of a batch.

Incomplete executions reconciled and replayed

DataStoreError already exists

Data store primary keys clash

A scenario that uses the data store as a dedupe layer, with a key that is not unique enough for the real traffic, so writes start rejecting.

Keys reworked, dedupe stable

HTTP module timeout 40s

An upstream API slowed down

The HTTP module gives up at forty seconds, and a slow partner API takes the whole scenario out even on a normal payload.

Async pattern or queue in front

Mapping error: missing key 'items'

The upstream API changed shape

A new version of a partner API returning data under a different key or wrapping it in an envelope the mapper was not written for.

Mappings updated against the new shape

router processed 814 bundles

A router is fanning out too wide

A single trigger run suddenly producing hundreds of downstream executions because of an upstream batching change, which is also what sent the operation bill up.

Fan-out shaped and capped

What we do

Make help, from scenario rescue to design

Hire us for one failing scenario, or let us own the whole Make workspace.

Rescue
Scenarios dead, operations over plan, or bundles going missing. We get the automations running again and then show you what was draining them.
Scenario design
Iterators, aggregators, routers and error handlers composed so the happy path, the retry path and the alert path are all explicit instead of implicit.
Operations optimization
Audit of which scenarios burn the most operations, with concrete rewrites that keep behavior the same and cut the bill.
Connection and auth hygiene
OAuth token monitoring, service account strategies, and alerting on 401s so expired connections do not silently stop the workflow.
Migrations
Moving onto Make from Zapier or n8n, or off Make onto n8n or custom code, without losing any of the business rules in the process.
Managed Tech
Ongoing coverage: we watch error rates, operation usage and connection health, and respond when a scenario starts to drift.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Make (Integromat) alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Make (Integromat) questions

Something else? Call+1 737 727 7327

Why has our Make operations bill tripled?

Almost always one of three things: a router that activated a dormant branch, a scheduled trigger polling at one minute instead of fifteen, or an upstream dataset that grew into an iterator built for small payloads. We pull the operations breakdown per scenario, find the two or three culprits, and rewrite them to spend less without losing behavior.

Our Make scenario stopped silently, how do we fix that?

By default Make stops a scenario after three consecutive errors to protect data. The fix is a combination of per-module error handlers for recoverable failures, a dead-letter data store for anything that cannot be replayed, and real alerting into Slack or PagerDuty so a stopped scenario shows up in seconds rather than days.

Should we use Make or Zapier?

Make tends to win on scenarios that move batches of records with conditional logic, where its iterators and routers are genuinely cheaper and clearer. Zapier tends to win on one-trigger-one-action flows run by non-engineers, where its catalog depth and simpler mental model matter more than its pricing.

Can you migrate our Make scenarios to n8n?

Yes, when the move is justified. n8n is self-hostable and has no per-operation cost, which matters at high volume, but the modules do not map one-to-one, so we rebuild each scenario with the same business rules rather than running an export. For some workflows a custom service is cheaper than either tool.

How do you handle Make connections that keep expiring?

OAuth connections expire on the provider's schedule, not Make's, and the default behavior is to fail quietly. We add explicit heartbeat scenarios that call the connection daily, alert the moment a 401 appears, and document the rotation path per provider so renewal is a known five-minute job.

How much does Make help cost?

The estimate is free. Describe the scenarios and the symptoms and we respond with a scoped price.

Free estimate

Make scenarios giving you trouble?

Tell us which scenario is broken or which bill is climbing and we come back with a plan and a price.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.