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 provides a detailed visual engine. Scenarios are drawn as a flowchart with modules connected by visible data paths; modules animate as they run, errors appear on the module that failed, and routers split a scenario into branches while iterators and aggregators fan arrays out and back. Relay.app targets a different, human-in-the-loop workflow model.

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 listed 3,000+ apps when verified 2026-09-20. Relay.app publishes a smaller catalog focused on approval-driven workflows, with HTTP for additional APIs. If an uncommon connector matters, verify the exact trigger, action, and authentication support rather than inferring coverage from catalog size alone.

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 a candidate for teams that want a managed visual canvas for unattended business-SaaS automation. Its 3,000+ app catalog (verified 2026-09-20), routers, iterators, and error-handling surfaces can support complex scenarios without operating infrastructure. Validate the actual connector depth, credit use, and maintainer workflow.

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.