Make (formerly Integromat): The Visual Automation Platform That Does Everything

If Zapier is the Honda Civic of automation — reliable, easy to use, gets the job done — then Make is the Subaru WRX. Same category, but under the hood, it’s a completely different beast.

Make (rebranded from Integromat in 2022) is a visual automation platform that lets you connect apps, automate workflows, and build complex logic — all without writing code. And for power users, it’s significantly more capable than Zapier at a fraction of the price.

Photo by Possessed Photography on Unsplash

What Is Make?

Make is a tool that connects your apps and automates repetitive work. Think of it as a visual programming language for non-programmers:

• Trigger: Something happens (new email, form submission, scheduled time)
• Actions: Do something in response (create spreadsheet row, send Slack message, update CRM)
• Logic: Add conditions, loops, filters, and data transformations
• Result: Complex workflows that run automatically

What makes Make special is the visual canvas. Unlike Zapier’s linear step-by-step approach, Make gives you a node-based visual editor where you can see your entire workflow as a flowchart.

Make vs. Zapier: The Real Comparison

This is the question everyone asks. Here’s the honest breakdown:

Visual Canvas vs. Linear Steps

Zapier: Step 1 → Step 2 → Step 3 → Step 4

Make: A visual node graph where data can branch, loop, merge, and flow in any direction

For simple automations (when X happens, do Y), Zapier’s simplicity wins. For anything with branches, conditions, or complex data manipulation, Make’s visual canvas is dramatically better.

Pricing

This is where Make really shines:

• Make Free: 1,000 operations/month
• Make Core: $10.59/month for 10,000 operations
• Zapier Free: 100 tasks/month
• Zapier Starter: $29.99/month for 750 tasks

Make gives you 10x more operations for 1/3 the price. For high-volume automations, the cost difference is massive.

Important: Make counts “operations” (each module execution) while Zapier counts “tasks” (each Zap trigger). A single Zapier task might equal 5-10 Make operations. But even accounting for this, Make is usually cheaper.

App Integrations

• Zapier: 7,000+ apps
• Make: 1,800+ apps + HTTP module for any API

Zapier has more native integrations. But Make’s HTTP module means you can connect to literally any API — you just need to configure the request yourself. For developers, this is actually more flexible.

Error Handling

Make’s error handling is far superior:

• Error routes: Define what happens when a module fails
• Retry logic: Automatically retry failed operations
• Incomplete executions: Save failed runs for later replay
• Break/Ignore/Resume: Fine-grained error control per module

Zapier’s error handling is basically “it failed, here’s an email notification.” Make lets you build resilient automations that handle failures gracefully.

Photo by Luke Chesser on Unsplash

Key Features

1. Scenario Builder (Visual Editor)

The canvas is Make’s crown jewel:

• Drag and drop modules onto the canvas
• Draw connections between them
• Branch workflows with routers
• Loop through arrays of data
• Filter which data passes through
• Aggregate results from multiple paths

It feels like building with Legos, not writing a step-by-step instruction manual.

2. Data Mapping

Make handles data transformation natively:

Input: "John Smith, john@example.com, 2026-02-05"
Transform: Split by comma → Map to fields → Format date
Output: { name: "John Smith", email: "john@example.com", date: "Feb 5, 2026" }

Built-in functions for:

• Text manipulation (split, replace, trim, case change)
• Date/time formatting and math
• Number operations
• Array operations (map, filter, reduce)
• JSON parsing

3. Routers and Filters

Routers split your workflow into multiple paths:

New Lead →
  ├── Route 1 (if budget > $10K) → Enterprise sales team
  ├── Route 2 (if budget > $1K) → Standard sales team  
  └── Route 3 (else) → Self-serve onboarding

Filters on connections determine which data passes through. This is incredibly powerful for building conditional logic.

4. Iterator and Aggregator

Iterator: Takes an array and processes each item individually Aggregator: Collects results back into a single output

Example: Get all rows from a spreadsheet → Process each row → Collect results into a summary report

5. HTTP Module

The universal connector. Any app with an API can be integrated:

Module: HTTP → Make a request
URL: https://api.example.com/data
Method: POST
Headers: Authorization: Bearer 
Body: {"name": "", "email": ""}

This single module makes Make infinitely extensible.

6. Data Stores

Make has built-in databases (Data Stores) for storing information between runs:

• Store counters, states, or lookup tables
• No external database needed
• Query and update within your scenarios
• Perfect for tracking progress, deduplication, or caching

Real-World Automation Examples

1. Content Pipeline

RSS Feed (new blog post)
  → AI Module (generate social media captions)
  → Router:
      ├── Twitter → Post tweet
      ├── LinkedIn → Post update
      ├── Buffer → Schedule for later
      └── Slack → Notify team

2. Lead Management

Typeform (new submission)
  → Filter (score > threshold)
  → Google Sheets (log lead)
  → HubSpot (create contact)
  → Gmail (send personalized email)
  → Slack (notify sales team)
  → Wait 2 days
  → Gmail (send follow-up if no reply)

3. Invoice Processing

Gmail (new attachment matching "invoice")
  → Google Drive (save PDF)
  → AI Module (extract invoice data)
  → Google Sheets (log in finance tracker)
  → QuickBooks (create expense entry)
  → Slack (notify finance team)

4. Social Media Monitoring

Schedule (every 30 minutes)
  → HTTP (Twitter API search mentions)
  → Filter (sentiment = negative)
  → Slack (alert customer support)
  → Google Sheets (log for reporting)

5. E-commerce Order Fulfillment

Shopify (new order)
  → Router:
      ├── Digital product → Send download email
      └── Physical product:
            → Inventory check
            → If in stock → Create shipping label
            → If out of stock → Notify purchasing
  → Customer email (order confirmation)
  → Google Sheets (sales log)

AI Modules in Make

Make has embraced AI with dedicated modules:

• OpenAI (ChatGPT): Generate text, analyze content, classify data
• Anthropic (Claude): Alternative AI text generation
• DALL-E / Stability AI: Generate images
• Whisper: Transcribe audio files
• Custom AI: Connect any AI API via HTTP module

Example AI automation:

New customer review (Trustpilot)
  → OpenAI (classify sentiment: positive/negative/neutral)
  → Router:
      ├── Negative → Slack alert + create support ticket
      ├── Positive → Add to testimonials page
      └── Neutral → Log for analysis

Getting Started

Step 1: Sign Up

Go to make.com and create a free account. The free tier gives you 1,000 operations/month — plenty to learn.

Step 2: Start With Templates

Make has hundreds of pre-built templates:

• Browse by app (Gmail, Slack, Notion, etc.)
• Browse by use case (marketing, sales, HR, etc.)
• Click “Use template” and customize

Step 3: Build Your First Scenario

1. Click Create a new scenario
2. Add a trigger module (what starts the automation)
3. Add an action module (what should happen)
4. Map data from the trigger to the action
5. Test with real data
6. Activate to run automatically

Step 4: Learn These Concepts

• Routers: Split workflows into branches
• Filters: Conditional data flow
• Iterators: Process arrays item by item
• Data stores: Persist information between runs
• Error handling: Make automations resilient

Tips for Power Users

1. Use naming conventions — label every module clearly
2. Add notes to complex scenarios for documentation
3. Test incrementally — run one module at a time, not the whole scenario
4. Use data stores for state management instead of external databases
5. Set up error routes on critical modules
6. Monitor operation usage — optimize to stay within your plan
7. Use the HTTP module for apps without native integrations
8. Schedule strategically — not everything needs to run every minute

Limitations

• Learning curve is steeper than Zapier
• Fewer native integrations (1,800 vs 7,000)
• UI can feel overwhelming for simple automations
• Mobile app is limited
• Documentation could be more beginner-friendly
• Some modules have inconsistent behavior across versions

The Bottom Line

Make is the power user’s automation platform. If you’ve outgrown Zapier’s limitations, if you need branching logic, if you want better error handling, or if you’re tired of paying $50+/month for basic automations — Make is your answer.

The visual canvas is genuinely the best way to build and understand complex automations. Once you’ve used it, Zapier’s linear interface feels limiting.

For beginners who just want “when email arrives, save attachment to Drive,” Zapier is simpler. For everyone else, Make offers more power at a better price.

Verdict: The best automation platform for power users and growing teams. ⭐⭐⭐⭐½

Want to compare automation approaches? Check out our guides on Zapier and n8n for different philosophies on workflow automation.