Make (Integromat) for Email Workflows: Complete Guide

What Make Does for Email

Make (formerly Integromat) is a workflow automation platform—think Zapier but more powerful for complex logic. For email, Make helps you:

1. Connect systems — Sync data between your CRM, ESP, and other tools
2. Trigger sends — Start email sequences from any event
3. Transform data — Clean, merge, and route data before sending
4. Build complex flows — Conditional branching, loops, error handling

Make doesn't send email directly. It orchestrates your email infrastructure.

Make vs Zapier for Email

Both can trigger email workflows. Key differences:

Factor	Make	Zapier
Visual builder	Flowchart with branches	Linear steps
Complex logic	Excellent	Limited
Pricing	Per operation	Per task
Free tier	1,000 ops/month	100 tasks/month
Data transformation	Powerful	Basic
Error handling	Detailed	Basic
Learning curve	Steeper	Gentler

For simple "when X happens, send email Y," Zapier is faster to set up. For "when X happens, check conditions A, B, C, transform data, then send different emails based on outcomes," Make excels.

Practitioner note: I recommend Zapier for quick prototypes and Make for production email automation. The visual flow in Make makes complex logic maintainable; Zapier's linear approach becomes unmaintainable past 5-6 steps.

Core Email Modules

Make has native integration with major email services:

Transactional Email

• SendGrid — Send, template management, contacts
• Mailgun — Send, lists, events
• Postmark — Send, templates
• Amazon SES — Send via SDK
• Gmail — Send, watch for emails
• Microsoft 365 — Send, calendar integration

Marketing Email

• Mailchimp — Campaigns, subscribers, lists
• ActiveCampaign — Contacts, automations, deals
• Klaviyo — Profiles, flows, events
• HubSpot — Contacts, emails, workflows
• Brevo — Contacts, campaigns

Universal

• HTTP Module — Connect to any API
• Email Module — Generic SMTP sending
• Webhooks — Receive triggers from anywhere

Common Email Workflows

1. Webhook-Triggered Transactional Email

When your app needs to send email:

[Webhook] → [Router] → [SendGrid: Send]
                    → [Log to Google Sheets]

The router lets you send AND log simultaneously.

2. Form Submission to Welcome Sequence

When someone fills out a form:

[Typeform] → [Filter: Valid email?] → [Mailchimp: Add subscriber]
                                   → [SendGrid: Send welcome]

Parallel execution: add to list and send confirmation simultaneously.

3. CRM to Email Sync

When a deal closes:

[HubSpot: Watch deals] → [Filter: Closed won] → [Get contact details]
                                             → [Klaviyo: Update profile]
                                             → [SendGrid: Send onboarding]

4. Conditional Email Based on Data

Different emails based on criteria:

[Webhook] → [Router]
             ├─ [Filter: Plan = Pro] → [Send Pro welcome]
             ├─ [Filter: Plan = Basic] → [Send Basic welcome]
             └─ [Filter: Plan = Trial] → [Send Trial welcome]

Make's routers make conditional logic visual and manageable.

Building Your First Email Workflow

Step 1: Create a Scenario

1. Log into Make
2. Click "Create a new scenario"
3. Choose your trigger module

Step 2: Add Email Module

1. Click the "+" to add a module
2. Search for your ESP (e.g., SendGrid)
3. Select "Send an Email"
4. Connect your account (API key or OAuth)

Step 3: Map Data

Use the mapping panel to insert dynamic values:

• {{1.email}} — Email from trigger
• {{1.first_name}} — First name from trigger
• {{formatDate(now; "MMMM D, YYYY")}} — Formatted date

Step 4: Add Logic (Optional)

• Filter: Only proceed if conditions met
• Router: Split into multiple paths
• Iterator: Process arrays (multiple recipients)
• Aggregator: Combine data from multiple sources

Step 5: Test and Activate

1. Click "Run once" with test data
2. Verify email sends correctly
3. Turn on scheduling (immediate or interval)

Data Transformation for Email

Make's transformation capabilities are powerful for email personalization:

Formatting Names

{{capitalize(1.first_name)}}
→ "john" becomes "John"

Conditional Content

{{if(1.plan = "pro"; "Welcome to Pro!"; "Welcome to our free tier!")}}

Date Formatting

{{formatDate(1.created_at; "MMMM D, YYYY")}}
→ "March 31, 2026"

Array Handling

If you need to process multiple recipients:

[Webhook] → [Iterator] → [SendGrid: Send]

The iterator processes each item in an array separately.

Error Handling

Make's error handling prevents failed emails from breaking your workflow:

Break Module

Stop processing and log error:

[SendGrid: Send] → [Error Handler: Break]
                → [Slack: Notify team]

Resume Module

Continue despite errors:

[SendGrid: Send] → [Error Handler: Resume]

Rollback Module

Undo previous steps on failure:

[Add to Mailchimp] → [SendGrid: Send] → [Error Handler: Rollback]

If email fails, the Mailchimp add is reversed.

Practitioner note: Always add error handling to production email workflows. A failed API call shouldn't silently drop emails. At minimum, log failures to a Google Sheet or send a Slack notification.

Scheduling and Triggers

Immediate Triggers

• Webhooks — Instant when called
• App watches — When data changes (e.g., new HubSpot contact)
• Email triggers — When email arrives

Scheduled Triggers

• Interval — Every X minutes/hours
• Specific time — Daily at 9 AM
• Day of week — Mondays at 10 AM

For email automation:

• Transactional: Use immediate triggers (webhooks)
• Batch operations: Use scheduled triggers
• Digest emails: Use specific time triggers

Performance and Limits

Operation Counting

Each module execution = 1 operation A typical email workflow uses 2-5 operations:

1. Trigger (1 op)
2. Data lookup (1 op)
3. Send email (1 op)
4. Log result (1 op)

Plan Limits

Plan	Operations/Month	Scenarios
Free	1,000	2
Core	10,000	Unlimited
Pro	10,000+	Unlimited
Teams	10,000+	Unlimited

For email automation, Core plan ($9/month) handles most use cases.

Execution Time

• Free: 5-minute scenarios
• Paid: 40-minute scenarios

Long-running email operations (processing thousands of records) need scheduling consideration.

Integration with n8n

If you're using n8n for email automation, note that Make and n8n solve similar problems differently:

• Make — Hosted, visual, easier for non-developers
• n8n — Self-hostable, more control, developer-oriented

Both can orchestrate email workflows effectively. See our n8n vs Make vs Zapier comparison for detailed differences.

Best Practices

1. Test with Real Data

Make's "Run once" with sample data catches issues before production.

2. Log Everything

Add a Google Sheets or Airtable log module to track all email sends.

3. Use Filters Liberally

Prevent unnecessary sends with filters:

• Check email validity
• Verify required fields exist
• Exclude unsubscribed contacts

4. Handle Rate Limits

ESPs have rate limits. For bulk operations:

• Add delays between sends
• Use aggregator to batch API calls
• Process in smaller chunks

5. Monitor Execution History

Make stores 30 days of execution history. Review regularly for:

• Failed executions
• Unexpected data
• Performance issues

If you're building complex email automation and need help architecting the right workflow, schedule a consultation to design a maintainable Make scenario.

Sources

• Make Documentation
• Make Pricing
• SendGrid Make Integration
• Make Templates

---

v1.0 · March 2026