Make vs Relay.app

The core difference

Make and Relay.app both automate workflows in the cloud, but they are built around different assumptions. Make assumes the workflow runs unattended: a trigger fires, modules execute along a visual canvas, and the scenario finishes without a human touching it. Routers, iterators, and aggregators handle branching and arrays, and the entire product optimises for a non-technical operator watching data flow as bubbles on a flowchart.

Relay.app assumes a human is often part of the loop. Its defining feature is first-class human-in-the-loop steps: a workflow can pause, route a drafted email or a proposed action to a person, and wait for that person to approve, edit, or reject before continuing. This makes it a natural fit for AI-assisted work where the model produces a draft and a human signs off, rather than fully autonomous automation.

That single design choice decides most comparisons. If your workflow should run to completion without supervision, Make is the more polished engine. If a person must review or approve something partway through — especially AI-generated content — Relay.app makes that a built-in step rather than a router-and-delay hack.

Human-in-the-loop

This is where Relay.app is purpose-built. Approval steps, edit steps, and assignment steps are first-class blocks on the canvas: the workflow can present a model-drafted reply for a human to tweak, ask for a yes/no before sending an email, or route a task to a specific teammate and wait. The waiting, the notification, and the resume are all handled by the platform, so building a review gate is a matter of dropping in a step.

Make can approximate human-in-the-loop, but it is a build-your-own pattern. You pause a scenario, notify a person, and resume on a webhook or a scheduled re-check — workable, but several moving parts you assemble and maintain rather than a native step. For workflows where approvals are the point, Relay.app removes real friction that Make leaves to the builder.

Visual power and control flow

Make is the more powerful visual engine. Scenarios are drawn as a flowchart with modules connected by visible data paths, and the editor is the most polished in the category — modules animate as they run, errors light up on the exact bubble that failed, and routers split a scenario into independent branches while iterators and aggregators fan arrays out and back. The model holds up well at thirty or forty modules, which is deeper control flow than Relay.app targets.

Relay.app deliberately keeps the model simpler. Workflows are cleaner and more linear with branches, tuned for readability and for the review-and-approve pattern rather than for deep programmatic control flow. A non-engineer can read a Relay workflow at a glance, but automations that need intricate branching, looping, or aggregation fit Make’s canvas better. The trade Relay.app makes is clarity and human-step ergonomics over raw visual flexibility.

AI

Both lean into AI, but from different angles. Make ships AI modules (OpenAI, Anthropic, generative helpers) that drop cleanly into a scenario for a one- or two-module AI step — summarise an email, classify a ticket, draft a reply — feeding the result into the rest of the flow. It is fast and polished when the AI step is one box inside a larger automation.

Relay.app treats AI as a step that produces structured output a human can then review. The model drafts a reply, classifies a ticket, or proposes an action, and the workflow routes that output into an approval or edit step before anything ships. For AI-assisted work where the value is a human catching the model’s mistakes before they go out the door, Relay.app’s pairing of native AI steps with native approval steps is more coherent than bolting an approval gate onto a Make scenario.

A useful filter: if the AI should act autonomously inside a polished visual flow, Make; if the AI should draft and a human should approve, Relay.app.

Integrations and operations

Make ships around 1,800 native apps, leaning into mainstream business SaaS — Slack, Google Workspace, Microsoft 365, HubSpot, Salesforce, Shopify, Notion, Airtable — and most modules expose more endpoints per app than simple one-trigger-one-action integrations. Relay.app’s catalog is smaller and younger, focused on the mainstream apps that show up in approval-driven workflows — email, Slack, calendars, CRMs — with HTTP for the long tail. If your automation depends on an obscure tool, Make is the safer bet on coverage.

Both tools are cloud-only with no self-hosting option, so neither satisfies data-residency or air-gap requirements — that need points to a self-hostable tool like n8n. Both handle the runtime, secrets, retries, and alerting for you, so the operational footprint is minimal on either side. Between these two, the choice is Make’s canvas depth and catalog against Relay.app’s native human-and-AI steps.

Who should choose Make

Make is the right call for teams who want the cleanest visual canvas in the category, run mostly business-SaaS automation that executes unattended, and would rather not think about infrastructure. The scenario editor is the easiest place to build and debug a branching flow, the 1,800-app catalog covers mainstream SaaS ready to click, and routers and iterators give real control flow without code. For an operations-led team building headless automations, Make is the faster and more capable home.

Who should choose Relay.app

Relay.app is the right call when a human is a required step inside the workflow. Teams that draft outreach with AI and want a person to approve before it sends, ops teams routing tasks and approvals between teammates, and anyone whose automation is really a review-and-approve pipeline get first-class steps for exactly that, wrapped in an approachable UX. The pairing of native AI steps with native approval steps makes human-in-the-loop AI work coherent in a way that bolting a gate onto a visual automation engine is not. Just go in knowing it is cloud-only with a smaller integration catalog than Make.