Move your team from Relay.app to Make.
Each person gets a short interview, then a personalized step-by-step guide showing exactly where their saved work, prompts, and projects land in Make — and the few things that need a manual step, walked through. You send one invite; nobody becomes the help desk, and nothing in Relay.app is changed or cancelled. Want to see where you’re paying for both first? Run the free audit.
Both products let teams embed AI reasoning into automated workflows, but the implementation model differs. Make builds AI agents on the scenario canvas using module chains that call AI apps (OpenAI, Anthropic Claude, Gemini, Perplexity, etc.) and can branch based on model output; agents are first-class scenario types with step-by-step reasoning traces. Relay.app exposes AI as step types inside a workflow: pre-built AI actions (extraction, classification, summarization, transcription) or fully custom AI steps where you pick any provider and model, write a prompt, and define an output schema. To migrate a Make AI agent scenario to Relay: identify each AI module call in the Make canvas, re-create it as an AI step in Relay with the same provider and prompt, and replace Make's adaptive branching logic with Relay's branches/paths. For enterprise teams, Relay also supports private model deployment via AWS Bedrock, Google Vertex, or Azure — note Make does not advertise equivalent private hosting of AI inference.
- Warning: Make gates AI agent capabilities at Core plan and above; Relay.app meters AI usage through AI credits included on every plan but charges against a credit quota — teams running high-volume AI workflows should compare per-run credit costs carefully before migrating.
- Warning: Make's reasoning-trace logs are built into the execution history and visible directly on the canvas; Relay does not advertise a dedicated reasoning-trace view, so debugging complex AI decision chains may require more manual inspection of step outputs.
- Warning: Model availability differs: Make lists 400+ AI-specific app integrations; Relay natively supports Anthropic, OpenAI, Gemini, DeepSeek, Mistral, Perplexity, Groq, xAI, and Qwen — confirm your specific model is available in Relay before committing to migration.
Both products provide a large library of pre-built app connectors accessible on all plans, so most workflows that connect common SaaS tools can be rebuilt on either side. Make advertises 3,000+ connectors; Relay.app advertises 500+ native integrations. When migrating from Make to Relay: list every app module used in the Make scenario, then confirm each exists as a native connector in Relay's integration catalog at relay.app/integrations. For any gap, Relay provides a native HTTP request step to call arbitrary REST APIs, mirroring Make's built-in HTTP module. Relay also adds native web scraping utilities (content extraction, screenshots, link crawling) not available in Make's connector model. When migrating from Relay to Make: every Relay app step maps to a Make module of the same app; for Relay's HTTP steps, use Make's HTTP/Webhooks module.
- Warning: Make's library is approximately 6x larger (3,000+ vs 500+) — niche or regional SaaS apps available in Make may not have a native connector in Relay.app and will require the HTTP fallback, which adds configuration work.
- Warning: Make states no integration is gated by pricing tier; Relay similarly includes all app connectors on all plans, but the actual per-run costs (credits) scale with plan tier, so high-throughput integrations may cost more at lower Relay plans.
- Warning: Both support OAuth-based authentication for connected apps, but credentials are stored differently — Make uses 'connections' scoped to the scenario owner, while Relay uses per-step authorization — re-auth will be required for every app when migrating.
Both products address the need for humans to stay in control of automated workflows, but they approach it from different angles that complement each other during a migration. Make focuses on visibility after the fact: step-by-step execution logs are accessible from the scenario canvas for every run, and Pro plan adds full-text log search across historical runs — teams use this to catch and diagnose errors. Relay.app focuses on proactive human gates mid-run: it offers Approval steps (run pauses until an assignee approves via Slack or email), Data Input steps (run pauses to collect information only a human can provide), and built-in AI review steps (human approves, revises, or rejects AI-generated output before the workflow continues). When migrating workflows that relied on Make's error monitoring to catch bad AI outputs, consider re-architecting in Relay to insert a human review step before the consequential action, making the oversight proactive rather than reactive. When migrating Relay approval workflows back to Make, the closest equivalent is adding an email or Slack notification module followed by a wait/webhook step that resumes only after a human response.
- Warning: Make's full-text execution log search requires the Pro plan ($21/month); Relay.app does not have an equivalent searchable log feature advertised in its public docs — teams that rely heavily on querying historical run data for compliance or debugging will lose that capability in Relay.
- Warning: Relay's human-in-the-loop steps send approval notifications via Slack or email; Make has no native mid-run pause-for-human-approval primitive, so replicating Relay's HITL pattern in Make requires a workaround (outbound notification + inbound webhook to resume), which is more complex to set up.
- Warning: Make AI agent runs include reasoning traces in execution history; Relay does not advertise a dedicated reasoning-trace log, so AI workflow debugging visibility differs meaningfully between the two products.
Both products support time-based scheduling and event-driven triggers, covering the two primary ways to start an automated workflow. Make calls the automation a 'scenario' and attaches a scheduling interval (minimum 15 minutes on Free, 1 minute on Core+) or a webhook trigger for real-time events. Relay.app calls it a 'workflow' and supports schedule triggers (e.g. every weekday at 5pm), app-event triggers, webhooks, forms, mailhooks, table updates, RSS, manual button clicks with inputs, and batch triggers. To migrate a Make scheduled scenario to Relay: note the Make interval and set an equivalent schedule trigger in Relay's workflow editor. To migrate a Make webhook-triggered scenario: create a Relay webhook trigger and update the sending system's URL to the new Relay endpoint. Relay's 'dynamic waiting' primitive (pause until a condition occurs mid-run) has no direct Make equivalent and may allow simplifying scenarios that previously used polling loops.
- Warning: Make Free plan enforces a 15-minute minimum run interval and caps at 2 active scenarios simultaneously; Relay.app does not publicly document per-plan caps on concurrent active workflows in the same way — verify limits with Relay support before migrating high-frequency or high-volume scheduled workflows.
- Warning: Make allows up to a 40-minute maximum single-scenario execution time on paid plans; Relay does not advertise an equivalent per-run timeout limit in its public docs — long-running Make scenarios (file processing, large batch loops) may behave differently in Relay.
- Warning: Make's webhook triggers are available on all plans; Relay's batch trigger and mailhook trigger types are worth testing for equivalence with Make's more advanced trigger configurations before assuming a like-for-like swap.
Both products center on a no-code visual canvas for building multi-step automations, so migrations are largely one-to-one at the structural level. In Make, users drag modules onto a canvas and connect them with lines; in Relay.app, you describe the automation in a chat prompt (powered by Claude) and then refine it in a drag-and-drop editor. To migrate a Make scenario to Relay: export or screenshot the scenario map, then paste a plain-language description of the logic into Relay's chat builder to generate a starting workflow; edit branches, filters, and step order in Relay's visual editor to match the original. Going the other way (Relay to Make), identify each Relay step type (app step, AI step, utility) and map it to the corresponding Make module in the app library, then wire them on the Make canvas. Both support conditionals, loops, and routing, though the naming differs (Make: 'routers' and 'filters'; Relay: 'branches' and 'paths').
- Warning: Make's canvas is purely drag-and-drop from the start; Relay.app's primary entry point is a natural-language chat builder that then outputs a visual workflow — teams who prefer to wire modules manually from scratch may find the chat-first approach requires extra refinement steps.
- Warning: Make calls automations 'scenarios'; Relay calls them 'workflows' — internal documentation and team naming conventions will need updating after migration.
- Warning: Relay's visual editor exposes 'sequences' (reusable packaged step series) as a first-class concept with no direct Make equivalent; complex Make scenarios with repeated module patterns may need to be restructured as Relay sequences for best maintainability.