.svg)
Make Scenarios for GTM: Automating Sales and Marketing Workflows
If you've spent any time building go-to-market workflows, you know the pain: data lives in a dozen different tools, handoffs between enrichment and outreach break constantly, and your team burns hours every week on tasks that should run themselves. Make (formerly Integromat) has become one of the most popular platforms for stitching these tools together into reliable, automated scenarios.
This guide breaks down exactly how GTM teams use Make scenarios to automate sales and marketing workflows — from lead enrichment and CRM syncing to multi-step outbound sequences. We'll cover the most impactful use cases, walk through scenario setup, and share best practices so you can build workflows that actually hold up at scale.
Whether you're a RevOps engineer wiring up your first automation or a GTM leader evaluating orchestration tools, this is a practical reference for getting real value out of Make.
What Are Make Scenarios?
A Make scenario is a visual workflow that connects two or more apps through a series of modules — triggers, actions, filters, and routers. Each scenario runs either on a schedule (e.g., every 15 minutes) or in response to a webhook event. The visual canvas lets you map out branching logic, error handling, and data transformations without writing code.
For GTM teams, scenarios replace the fragile spreadsheet exports, manual copy-paste routines, and single-purpose Zapier zaps that tend to accumulate as your stack grows. A single Make scenario can pull a new lead from your CRM, enrich it through Clay or Clearbit, score it against your ICP criteria, route it to the right sales rep, and trigger a personalized outbound sequence — all in one execution.
Key Concepts
| Concept | What It Does | GTM Example |
|---|---|---|
| Trigger | Starts the scenario when a condition is met | New row in Google Sheet, new deal in HubSpot, incoming webhook from Clay |
| Action | Performs an operation in a connected app | Create contact in Salesforce, send Slack alert, add to Instantly campaign |
| Router | Splits the flow into multiple branches based on conditions | Route enterprise leads to AEs, SMB leads to automated sequence |
| Filter | Blocks execution unless criteria are met | Only proceed if email is verified and company has 50+ employees |
| Iterator | Loops through an array of items | Process each contact in a batch enrichment response |
| Data Store | Internal database for persisting state between runs | Deduplication table to prevent emailing the same lead twice |
Top Make Scenarios for GTM Teams
Below are the scenarios we see GTM teams build most often — and the ones that deliver the highest ROI in terms of hours saved and pipeline generated.
1. Inbound Lead Enrichment and Routing
When a new lead fills out a demo request form, speed matters. A Make scenario can instantly enrich the lead with firmographic and technographic data, score it against your ICP, and route it to the appropriate owner in your CRM — all before a rep even sees the notification.
Typical flow: Webhook from Typeform or HubSpot → Enrich via Clay or Clearbit → Score with a filter/router → Create or update contact in Salesforce → Notify the assigned rep in Slack → Add to onboarding sequence.
This is the kind of multi-tool coordination that becomes painful to manage manually. If you're already using Clay for enrichment, our guide on coordinating Clay, CRM, and sequencer in one flow covers the architecture in detail.
2. Outbound List Building and Activation
Outbound prospecting generates the most repetitive work in most GTM orgs. A Make scenario can monitor a shared Google Sheet or Airtable base where your SDR team adds target accounts, automatically enrich each row, find verified email addresses, and push qualified contacts directly into your sequencing tool.
Typical flow: Watch Google Sheet for new rows → Enrich company via Apollo or Clay → Find decision-maker contacts → Verify emails → Filter by ICP fit → Push to Instantly or Outreach → Log activity in CRM.
3. CRM Hygiene and Data Sync
Dirty CRM data kills pipeline forecasting and breaks downstream automations. Make scenarios can run on a schedule to normalize fields, deduplicate records, fill in missing firmographic data, and sync changes bidirectionally between your CRM and other tools.
Typical flow: Scheduled trigger (daily) → Search Salesforce for contacts missing industry or employee count → Batch enrich via Clearbit → Update Salesforce records → Log changes in a data store for audit.
Teams that invest in CRM hygiene automations early avoid the compounding mess that makes every subsequent workflow harder to build. For more on keeping your RevOps stack clean, check out our roundup of the best AI tools for RevOps teams in 2026.
4. Intent Signal Processing
Buying intent signals — website visits, G2 page views, job postings, funding announcements — are only valuable if they're acted on quickly. Make scenarios can ingest these signals via webhooks or API polling, cross-reference them against your target account list, and trigger immediate outreach.
Typical flow: Webhook from intent data provider → Match against target account list in data store → If match, enrich contact → Add to high-priority outbound sequence → Alert account owner in Slack.
5. Multi-Channel Campaign Orchestration
Running coordinated campaigns across email, LinkedIn, and ads requires tight synchronization. A Make scenario can act as the orchestration layer, ensuring a prospect who opens an email gets added to a LinkedIn touchpoint and a retargeting audience — all timed appropriately.
For teams thinking about broader orchestration strategy, our post on what a GTM engineer actually does gives useful context on how this role is evolving.
How to Build a Make Scenario for GTM: Step by Step
Let's walk through building a practical scenario — inbound lead enrichment and routing — from scratch. This pattern is applicable to most GTM workflows with minor modifications.
Define Your Trigger
Start by choosing what kicks off the scenario. For inbound lead routing, you'll typically use a webhook trigger that fires when a new form submission or CRM record is created. In Make, add a "Custom Webhook" module and copy the generated URL into your form tool or CRM's webhook settings.
If you're polling an existing data source instead, use the app-specific "Watch" module (e.g., "Watch New Rows" for Google Sheets, "Watch New Contacts" for HubSpot).
Add Enrichment Modules
After the trigger, add an HTTP module or a native app module to call your enrichment provider. If you're using Clay, you can send a webhook to a Clay table and wait for the enriched response, or use Clay's API directly. Map the trigger's email or domain field to the enrichment request.
Our guide on enriching leads with Clay and pushing to CRM covers the enrichment configuration in depth.
Set Up Routing Logic
Add a Router module after enrichment. Create branches for each segment — for example, one branch for enterprise leads (500+ employees), one for mid-market (50-499), and one for SMB or disqualified leads. Each branch gets a filter condition based on the enriched data.
This is where Make's visual canvas genuinely shines compared to code-based solutions. You can see every branch, adjust thresholds, and add new paths without refactoring anything.
Connect Your CRM and Sequencer
On each branch, add the appropriate action modules. The enterprise branch might create a Salesforce contact, assign an owner using round-robin logic, and send a Slack notification. The mid-market branch might push directly to an automated email sequence in Instantly or Apollo.
If you want to go deeper on connecting your CRM to your sequencing tools, see coordinating Clay, CRM, and sequencer in one flow.
Add Error Handling
This is the step most people skip and later regret. Add error handlers to critical modules — especially your CRM and enrichment calls. Make supports "Resume," "Commit," "Rollback," and "Break" error-handling directives. At minimum, use a Break directive that sends a Slack or email alert so you know when something fails.
Test with Real Data, Then Activate
Run the scenario manually with a real (or realistic) test payload. Check every branch. Verify the data lands in your CRM correctly. Confirm Slack notifications fire. Only then turn on scheduling or live webhook listening.
Best Practices for Make Scenarios in GTM
Building the scenario is only half the job. Keeping it running reliably as your stack evolves is the other half. These practices come from teams that have been running production GTM automations in Make for years.
Design for Observability
Every scenario should have logging. Add a Google Sheets or data store module at the end of each branch that records what happened — which lead came in, what enrichment returned, which branch was taken, and whether the CRM write succeeded. When something breaks at 2 AM, this log is your first debugging tool.
Use Data Stores for Deduplication
GTM workflows are notorious for processing the same lead multiple times. Use Make's built-in data stores to maintain a dedup table keyed on email address or domain. Check against it early in your scenario and exit if the record already exists. This prevents duplicate CRM records, double-sends, and inflated metrics.
Keep Scenarios Modular
Resist the urge to build one massive scenario that does everything. Instead, build smaller scenarios connected by webhooks. An enrichment scenario, a routing scenario, and a sequencing scenario are easier to debug, test, and modify independently than a single 40-module monolith.
This modular approach is one of the principles behind modern GTM engineering — treat your automations like software, not one-off scripts.
Monitor Operations Usage
Make charges by operations (each module execution counts as one operation). A scenario with 10 modules processing 100 leads uses 1,000 operations. Monitor your usage dashboard and optimize by adding early filters to exit the scenario before expensive enrichment calls when leads are clearly unqualified.
| Practice | Why It Matters | Implementation |
|---|---|---|
| Error handling on every API call | Prevents silent failures that corrupt data | Add Break directive + Slack alert module |
| Deduplication via data store | Prevents duplicate outreach and CRM records | Check email/domain against data store before processing |
| Execution logging | Enables debugging and audit trails | Append row to Google Sheet or data store on each run |
| Modular scenario design | Easier maintenance and testing | Connect scenarios via webhooks, one responsibility per scenario |
| Early filtering | Saves operations and prevents bad data propagation | Add filter after trigger to reject unqualified leads immediately |
Make vs. Other Automation Platforms for GTM
Make isn't the only option for GTM workflow automation. Here's how it compares to the tools we see teams evaluate most often.
| Platform | Best For | GTM Strengths | Limitations |
|---|---|---|---|
| Make | Complex multi-step workflows with branching | Visual canvas, routers, data stores, cost-effective at scale | Learning curve for non-technical users, can get complex quickly |
| Zapier | Simple integrations, non-technical teams | Huge app library, easy to set up basic zaps | Expensive for multi-step workflows, limited branching |
| n8n | Self-hosted, code-friendly teams | Open source, full code access, no operation limits if self-hosted | Requires infrastructure management, smaller community |
| Octave | End-to-end GTM orchestration | Purpose-built for GTM, native integrations with sales/marketing stack, AI-driven | Focused specifically on GTM (not general-purpose automation) |
If your needs are primarily GTM-focused — enrichment, routing, sequencing, CRM sync — a purpose-built platform like Octave can save you from wiring together dozens of Make modules. But if you also need to automate non-GTM workflows (finance ops, customer support, product analytics), Make's general-purpose flexibility is hard to beat.
For a more comprehensive comparison of the orchestration landscape, see our post on the best platforms for GTM engineers in 2026.
Common Pitfalls to Avoid
Scaling Make Scenarios Across Your GTM Stack
Once your first few scenarios are running reliably, the question shifts from "how do I build this?" to "how do I manage ten or twenty of these?" Here's what we recommend.
Establish Naming Conventions
Name every scenario with a consistent pattern: [Team] - [Trigger] - [Action] - [Version]. For example: SDR - New Inbound Lead - Enrich + Route to SFDC - v2. This makes it possible to find and audit scenarios as they multiply.
Centralize Webhook Management
Keep a master document listing every webhook URL, which scenario it belongs to, and which upstream tool sends to it. Webhook URLs are effectively API endpoints for your business logic — treat them with the same rigor you'd apply to any production API.
Create Shared Templates
Make allows you to clone scenarios. Build a set of template scenarios for your most common patterns — enrichment, CRM sync, Slack alerting — and clone them as starting points. This reduces build time and enforces consistency.
As your automation footprint grows, consider whether a dedicated orchestration platform would simplify management. Octave is built specifically for this — managing complex GTM workflows without the overhead of maintaining dozens of independent scenarios. It's worth evaluating once you're managing more than a handful of interconnected automations.
For more on how teams are structuring their automation stacks, see our posts on building a modern GTM tech stack and when to replace Zapier with a GTM platform.
Frequently Asked Questions
How much does Make cost for GTM automation?
Make's free tier includes 1,000 operations per month — enough to test a scenario but not enough for production use. The Core plan starts at $9/month for 10,000 operations. Most GTM teams running 3-5 active scenarios land on the Pro plan ($16/month for 10,000 operations, with access to priority execution and full-text log search). High-volume teams processing thousands of leads monthly typically spend $50-150/month depending on scenario complexity.
Can Make replace my current GTM orchestration stack?
Make can handle the automation and integration layer, but it's a general-purpose tool — it doesn't have native concepts like "lead," "account," or "sequence." You'll still need your enrichment tools, CRM, and sequencer. Make connects them. If you want a platform that natively understands GTM concepts, Octave is purpose-built for that.
How reliable is Make for production GTM workflows?
Make's uptime has been consistently above 99.9% over the past two years. The bigger reliability risk comes from the external APIs your scenarios depend on — CRM rate limits, enrichment provider downtime, email tool throttling. Invest in error handling and monitoring to catch these failures early.
Is Make better than n8n for GTM use cases?
If your team is comfortable self-hosting and wants full code access, n8n is excellent. If you want a managed service with a gentler learning curve and a large library of pre-built app integrations, Make is the better choice. Both are significantly more capable than Zapier for complex GTM workflows.
How do I handle sensitive data (emails, phone numbers) in Make?
Make is SOC 2 Type II compliant and encrypts data at rest and in transit. However, be mindful of what gets logged in execution history — Make stores input/output data for each module execution for 30 days by default. If you're handling highly sensitive data, review Make's data residency options and consider their Enterprise plan for additional compliance controls.