Ryz Labs/Rescue/Make and Zapier to production
Rescue

Make and Zapier to Production: Fixing the Automation Monolith

Inventory every scenario and Zap, keep simple glue in the tool, and move the paths that touch money into a small typed service with a queue, idempotency keys and retries.

Taking a Make or Zapier setup to production means turning a web of scenarios and Zaps that quietly runs your orders, invoices and onboarding into something you can test, monitor and change without fear. We recommend you keep the simple glue in the tool, harden what stays there, and move only the money paths (anything that charges, refunds, provisions or emails a customer about a payment) into a small typed service with a queue. Success depends on one property: every step that can be retried must be safe to run twice.

How Make and Zapier run your business today, and where production begins

Both tools are hosted workflow engines. You connect accounts, pick a trigger and chain actions; the vendor runs the engine, stores credentials as connections and bills by usage.

Make bills in credits: "As of August 27, credits are the billing unit in Make" (Make pricing), and for non-AI apps "1 operation equals 1 credit." A scenario is a graph of modules, and failures are handled by error handler routes. Make's current error handler names are Skip, Retry, Resume, Commit and Rollback (Skip and Retry replaced the older Ignore and Break). Persistent state can live in data stores, and a whole scenario can be exported as a blueprint, which "downloads to your device as a .json file" (Make blueprints).

Zapier bills by task. Its task usage article counts a task for each successful action step, and "Zap triggers never use tasks"; filters and paths are free too. A Zap is a list of steps with optional paths.

That is a great way to get a company running. Production begins when the automations stop being helpers and become the system: dozens of scenarios and Zaps, passing data through sheets, data stores and webhooks, with no single place that describes how an order flows. We call this the automation monolith. It has a monolith's coupling without a codebase's tests or types.

Where automation monoliths break first

Retries that duplicate orders, charges and emails

Retries are a feature in both tools. Make's Retry handler exists to "store incomplete executions and enable automatic or manual retries." Zapier's autoreplay will "attempt to replay the step up to 5 times" over roughly ten and a half hours on Professional and above. If a step creates an invoice, charges a card or sends a receipt and the run fails after that step but before the run is marked done, the next attempt does it again.

Failures nobody hears about

The Skip handler is described as a way "to disregard errors," and Resume will "set a substitute value for a failed module and continue scenario processing." Fine for optional enrichment, dangerous on a payment. Incomplete executions in Make are stored in limited space, and when that storage fills with data loss disabled, Make pauses scheduling (incomplete executions options), which stops the scenario entirely. On Zapier, "Filter and Paths steps are never replayed," and Zap history guarantees only 60 days of run data, up to 10,000 runs shown.

Credentials that belong to one person

Connections are created by whoever built the automation, often with their own login to the CRM, the accounting system and the payment provider. Blueprints don't carry them: Make's blueprint docs note connections are excluded from exports. On Zapier, the export article says "you can only export Zap workflows you own." When that person leaves, flows break.

Scenarios and Zaps that hit run limits

Make stops a scenario that runs for more than 45 minutes (10 minutes on Free), per its errors and warnings guide. File handling has per-plan caps: 5 MB on Free up to 1,000 MB on Enterprise. Zapier's Zap limits cap a Zap at 100 steps including steps inside paths, and paths nest at most three deep.

Throttling and dropped webhooks under load

Make's webhook docs say it "can process up to 300 incoming webhook requests per 10 second interval," returning 429 above that, and each webhook queue holds 667 items per 10K credits up to 10,000; a full queue answers 400 with "Queue is full." Zapier's webhook rate limits are 20,000 requests every five minutes per user (1,000 per Zap on legacy routes), and Zapier "may return a 200 status code but delay webhook processing." Flood protection holds triggers when 100 or more events arrive at once.

Data stores and spreadsheets used as the database

Make data stores are sized at 1 MB per 1,000 credits (1 MB minimum each), capped at 1,000 per organization and 15 MB per record. Fine for a lookup cache; risky for order status or balances that several scenarios write, since nothing outside the scenarios enforces relationships or stops concurrent updates.

No version control and no tests

Changes are made live in the editor. Zapier keeps version history by plan (Professional one month, Team six months, Enterprise one year, per Zapier pricing), and Zap JSON export and import exist only on Team and Enterprise. Make blueprints export as JSON but must be under 2 MB to import back.

Credit and task bills that jump with volume

Every module run costs credits in Make (error handler and Router modules don't count), and extra credits cost 25% more than plan credits, per Make's plan adjustments notice, which also caps Core at 300,000 credits a month. On Zapier, when you reach the limit "Zapier will hold any new Zap runs until your billing cycle resets," unless pay-per-task is on, which tops out at three times the plan's task limit.

Readiness checklist for automations that touch money

The plan: inventory, classify, move the money paths

Phase 0: Freeze and export everything

Pause edits to critical flows. Export every Make blueprint and every Zap you can (Team or Enterprise for Zap JSON; each owner exports their own), commit them to a repository, and build the inventory sheet. Draw the dependency graph between flows, data stores and sheets. Exit criteria: every live automation is in git and in the inventory, and nothing runs that nobody can name.

Phase 1: Security and ownership

Recreate connections under service accounts, rotate the personal credentials they replace, and transfer ownership of critical flows. Add authentication to inbound webhooks (a shared secret or signature check as the first step). Exit criteria: no critical flow breaks if any one employee's account is disabled.

Phase 2: Classify, then fix data

Score each automation on two axes: does it move money or customer-facing state, and how complex is it. Use the table below. Then move shared state out of data stores and sheets into Postgres, with the old store kept read-only until reconciliation passes. Exit criteria: every automation has a label (keep, harden, move) and every shared table has one writer.

Automation looks likeDecision
Notify Slack on a new lead, copy a form to a sheet, tag a CRM contactKeep in the tool as is
Internal sync where a duplicate or a missed run is annoying but cheapKeep, add error alerts and a service-account connection
Charges, refunds, invoices, provisioning, payment emailsMove to the typed service
Loops over large lists, long runtimes, high credit or task costMove to code as a queued worker
Several flows reading and writing the same stateMove the state to Postgres and give it one owner

Phase 3: Tests and CI/CD for the service

Write the service in TypeScript or Python with strict types for every inbound payload, so a renamed field fails validation instead of writing nulls. Capture past events and their side effects as characterization tests. Run tests and type checks in CI on every pull request, and deploy to staging, then production, from the pipeline. Exit criteria: no money-path change ships without a reviewed pull request and a green build.

Phase 4: Operations

Alert on queue depth, on failed jobs in the dead-letter queue, on incomplete executions and on held Zap runs. Track credits and tasks per flow against a monthly budget. Add a daily reconciliation job that compares source orders with target invoices and charges. Exit criteria: a deliberately failed event shows up in an alert and is reprocessed from the runbook without duplicates.

Phase 5: Move the money paths

The target shape is small. An HTTPS endpoint receives the event, verifies its signature, writes it to a queue and returns immediately. A worker pulls the event, inserts its idempotency key into a processed-events table with a unique constraint (a duplicate insert means "already done, skip"), performs the side effects, and marks the event complete. Failures retry with exponential backoff; after a set number of attempts the event goes to a dead-letter queue with an alert. The tool can stay as the trigger (a Zap or scenario that forwards the event to the endpoint) or step aside entirely. Move one flow at a time, run it in report-only mode beside the old one, compare, then switch. Exit criteria: each moved flow has run in parallel cleanly and the old scenario or Zap is turned off, not deleted, for one billing cycle.

PhaseGoalKey techniqueExit criteria
0. Freeze and exportSee the whole monolithBlueprint and Zap JSON in git, dependency graphEvery live automation named and versioned
1. Security and ownershipNo single-person dependencyService-account connections, webhook authAny one account can be disabled safely
2. Classify, fix dataClear keep or move decisionsTwo-axis scoring, shared state to PostgresEvery shared table has one writer
3. Tests and CI/CDChanges caught before customersTyped payloads, characterization tests, pipelineGreen build required to ship
4. OperationsFailures are loudQueue and dead-letter alerts, daily reconciliationDrill reprocessed without duplicates
5. Move money pathsSafe retries by designQueue, idempotency keys, backoff, parallel runOld flow off after clean parallel run

What an AI pod on your team does in the first two weeks

Week one

Week two

Our AI pod teams use coding assistants for the tedious parts: drafting the inventory from blueprint and Zap JSON, generating payload types and tests, and log triage. Every change still goes through human review and the test suite before it ships.

Keep in the tool, harden or rebuild?

SituationRecommendation
Mostly notifications and syncs, no money moves through automationsKeep in the tool: service accounts, alerts, git exports
A few money flows among many simple onesExtract those flows into a small service, keep the rest
The order pipeline is spread across many scenarios sharing data storesRebuild the pipeline as a service with Postgres, keep the tools for glue

Skip hiring a team if you are still finding product-market fit and the flows change weekly, if a handful of internal users depend on them and mistakes are cheap, or if the only issue is one Zap that needs a filter and an alert. An afternoon with the checklist will cover that.

Typical team shape

This work needs a tech lead who can read blueprints and Zap JSON and design the service, one to three senior engineers fluent in TypeScript or Python, queues and Postgres, part-time security and DevOps help for service accounts, secrets and the pipeline, and QA automation when the money flows have many branches. Many teams begin with a pod of 3 to 5 senior engineers (a tech lead plus engineers), and a full pod is about seven. Smaller rescues can start with a tech lead plus one or two engineers.

Ryz engineers on your team start from $7,000 per month (our published range is $7,000–$15,000 per engineer per month, mostly mid-level to senior), quoted per team. The arithmetic is team size × months × monthly rate. Once you say go, engineers can typically start in under two weeks. Ryz engineers work on your team, reporting to your leads. Scope your team with us.

Related

FAQ

Can Make or Zapier handle production volume?

For many workloads, yes. The limits that matter are documented: run duration and file size in Make, steps per Zap and path nesting in Zapier, webhook rate limits and queue sizes in both, and credit or task allowances. Duplicate side effects and silent failures usually bite before volume does.

Do we have to rewrite all our automations in code?

No. Most scenarios and Zaps are simple glue and should stay where they are, with company-owned connections and alerts. Only money flows, large loops and shared state earn a move to a typed service.

How long does it take to untangle an automation monolith?

It depends on how many scenarios and Zaps exist, how many touch money, how much shared state lives in data stores and sheets, and whether the builder is available. The first two weeks produce a full inventory, the first fixes and a plan for the rest.

What does it cost?

Cost is team size multiplied by months multiplied by the monthly rate per engineer. Ryz engineers start from $7,000 per month, within a published range of $7,000 to $15,000 per engineer per month, quoted per team. Your Make or Zapier subscription is separate.

Will we lose the ability to keep using Make or Zapier?

No. Operations and marketing teams keep building in the tool. Money paths now call a tested service, connections belong to the company, and exports in git make changes reviewable.

Questions we didn't answer? Email info@ryzlabs.com.

Thanks — your message has been sent. We’ll get back to you soon.

Something went wrong while sending your message. Please try again or email info@ryzlabs.com.

Explore Ryz Labs

Software development servicesAI development companyIndustriesStaff augmentationAI pod teamsNearshore software developmentHire engineers by roleEngineer ratesGuidesBuyer guidesCase studiesHow we vet engineers

Ryz Labs

Senior engineers on your team. AI pod teams that ship.

Tell us what you're building. You get a scoped plan, a price and the names of the people who would do the work.

  • Only the top 1% of tens of thousands interviewed make it
  • On US business hours, including New York hours
  • Trusted by Fortune 500 engineering teams

Tell us who you need

A Ryz partner replies with a scoped team plan.

Start a conversation →

Prefer to talk? Book a 15-min call →