Make — Module 22.7

How This Lesson Fits the Module & Volume

n8n gave you self-host and engineer Code nodes. Make (formerly Integromat) is the SaaS visual orchestrator power users love: scenarios with routers, aggregators, iterators, error handlers, and fine-grained data mapping—without running Postgres yourself. Vol. 21 workflow automation still applies: durable runs, HITL, untrusted AI modules. Vol. 15 agentic workflows warn against letting an AI module choose every next enterprise write.

Make sits between n8n (code/self-host) and Zapier (simplest UX + widest catalog). Vol. 18 deployment is what you avoid operating—until volume, residency, or custom SLAs force you back to n8n or Celery.

Learning Objectives

By the end of this lesson, students should be able to:

Describe Make as a SaaS scenario builder (not a self-host engine like n8n).
Explain operations-based metering qualitatively and why routers can multiply cost.
Place AI modules as untrusted steps with schema/HITL gates.
Use routers, aggregators, and error routes as the visual analogue of Vol. 15 control flow.
Compare Make vs n8n vs Zapier on catalog, visual power, and residency.
Know when Make’s visual depth beats Zapier’s simplicity—and when to leave SaaS.

Definition

Make is a cloud automation platform where you design scenarios: a trigger plus a graph of modules (apps, HTTP, tools, AI). Data bundles flow through mapping UI. Advanced modules—Router, Iterator, Aggregator, Repeater, error handlers—are why practitioners call Make more “program-like” than basic Zaps. It is SaaS by default (enterprise plans may add region/compliance options—verify; do not invent VPC SKUs). AI appears as dedicated modules and assistants that help build scenarios. Metering is typically operations (module executions), not “one Zap = one task”—read the current billing FAQ.

SaaS Visual Power vs Self-Host

Need	Make	n8n	Zapier
Self-host in VPC	Not the default story	Yes	No (classic)
Visual routers / aggregators	Headline strength	Possible; more engineer-y	Paths exist; historically simpler
Ops / non-engineer UX	Strong (steeper than Zapier)	Weaker for pure ops	Strongest onboarding
Code escape hatch	Limited vs n8n Code node	First-class	Code steps exist; not the center
Meter surprise	Operations per module	Executions (Cloud) or infra	Tasks per action

Make scenario patterns

Router: fan-out by intent
Iterator: one row at a time
Aggregator: batch after loop
Error route: compensate / alert

Vol. 15 mapping

Router ≈ explicit control flow
AI module ≈ untrusted node
Sleep/approval ≈ HITL
HTTP module ≈ tool call

Ops hygiene

Count operations before go-live
Filter early to cut modules
Idempotency on writes
Secrets in connection store

AI Steps in Make

Make’s AI modules (and scenario-copilot helpers) should follow the same contract as n8n LLM nodes: structured output, validate, HITL before customer send or money. Do not let “Make AI” become an unbounded agent over production credentials. If you need a true tool-using agent pocket, cap iterations and allowlist HTTP endpoints—same Vol. 15 discipline.

Catalog Snapshot (Qualitative)

Dimension	Make	n8n	Zapier
Pricing posture	SaaS plans + operations (each module run can count)—live sheet; routers/iterators multiply	Self-host infra or Cloud executions	SaaS plans + tasks
Strengths	Visual data mapping; routers/aggregators/error handlers; ops-friendly power; AI modules	Self-host + Code + AI Agent nodes	Catalog breadth; simplest UX; enterprise procurement familiarity
Weaknesses	SaaS data path; operation bills surprise; less self-host; steeper than Zapier for beginners	Ops burden if self-host; smaller long-tail apps	Less visual sophistication per task; task cost at volume
AI steps	AI modules + builder assistants	LLM + AI Agent nodes	AI actions / agents / copilot (names evolve)
Residency	Cloud SaaS (+ any enterprise region options—verify)	VPC possible	Cloud SaaS (+ enterprise options—verify)

Scenario Contract Sketch

# make_scenario.md — educational blueprint (draw in Make UI)
Trigger: Helpdesk "new ticket" (app module)
Filter: only tickets with tag demo_or_public   # dummy data
Module: Set variables — wrap description as untrusted text
Module: AI — extract JSON {intent, sentiment, draft}
        → parse JSON; on failure → error route → Slack
Router:
  a) intent=billing → HITL approval module → trusted HTTP to CRM
  b) intent=faq → send template (no free-form AI body)
  c) else → human queue
Iterator: if attachments[] dummy files only (no PII dumps)
Aggregator: summary row → spreadsheet (ops count!)

COST_WATCH = {
    "meter": "operations_per_module",
    "risk": "iterator over 10k rows without filter",
    "mitigations": ["filter early", "batch", "cap scenario"],
}

def estimate_ops(tickets: int, modules_happy_path: int, hitl_rate: float) -> float:
    """Qualitative teaching model — not a vendor invoice."""
    return tickets * modules_happy_path * (1 + hitl_rate)

When to Pick Make

Pick Make when

Ops/analysts need routers and aggregators, not just linear Zaps.
You will not self-host n8n but outgrew Zapier’s visual model.
SaaS connectors cover the apps, with HTTP for the rest.
You will actively budget operations.

Pick something else when

VPC / self-host is mandatory → n8n.
Widest catalog + simplest training → Zapier.
The automation is the product → Vol. 18 Celery/FastAPI.
Iterator volume would make operations unbounded.

Related Lectures

Lecture	Role
n8n	Self-host peer just covered
Workflow automation	HITL + untrusted LLM nodes
Agentic workflow	Routers vs free agents
Celery / deployment	Escape hatch at scale
Zapier	Next: catalog + Vol. 22 capstone

Common Misconception

“Make is just Zapier with a darker UI.” Routers/aggregators/operations metering are different product physics. Second: Make is a drop-in self-host like n8n. Third: AI modules can own CRM writes. Fourth: iterators are “free” because the scenario looks simple. Fifth: inventing per-operation dollar prices. Sixth: error handlers are optional if the happy path demo worked.

Knowledge Check

Short Answer: What did Make used to be called? Answer: Integromat.
True/False: Make’s default story is self-host in your VPC like n8n. Answer: False—it is SaaS-first.
Multiple Choice: Make metering is typically described as: (a) operations per module run, (b) GPU-hours only, (c) HumanEval pass@k. Answer: (a).
Short Answer: Name two Make modules that implement control flow. Answer: Any of Router, Iterator, Aggregator, error handler, Repeater.
True/False: AI modules should still emit typed JSON and face HITL before customer send. Answer: True.
Multiple Choice: Iterators without filters mainly risk: (a) exploding operation counts, (b) faster Tab autocomplete, (c) CUDA kernels. Answer: (a).
Short Answer: When pick n8n over Make? Answer: Self-host/residency or first-class Code node / engineer-owned graphs.
True/False: You should invent a fake $9/month Make price in the catalog slide. Answer: False.
Multiple Choice: Next lecture is: (a) Zapier, (b) Cursor, (c) Veo. Answer: (a).
Short Answer: Which Vol. 21 lecture is the product theory for Make scenarios? Answer: Workflow automation.

Key Takeaways

Make is SaaS visual orchestration with routers/aggregators—power between Zapier simplicity and n8n self-host.
Operations metering + iterators are the cost physics to teach.
AI modules remain untrusted Vol. 15/21 nodes with HITL.
Leave Make for n8n (VPC) or Celery (productized graphs) when residency or SLAs demand it.
Next: Zapier — Vol. 22 capstone.

Trainer’s Guide

Lab: Rebuild the n8n ticket graph as a Make scenario (dummy webhook). Add a Router and an error route. Estimate operations for 1,000 tickets qualitatively (no fake $).

Preview capstone: Zapier will win on catalog and simplicity; students must still defend HITL + AI-step policy.

Recap: Make is the SaaS visual power tool—operations, routers, AI modules as untrusted steps. Continue to Zapier.