Introduction to Make — Visual automation

Section 10.6.1 : Introduction to Make — Visual automation

🎯 Learning objective

Understand what Make (formerly Integromat) is, how no-code visual automation works, and why it's the essential tool for connecting AI to your business processes. You'll learn the fundamental concepts, vocabulary, and build your first connection.

Why automate? The problem of "invisible work"

Every day, you perform dozens of repetitive micro-tasks: copying data from an email to a spreadsheet, sending a follow-up message, updating a CRM, compiling a report... These tasks take 5-10 minutes each, but combined, they represent 2 to 3 hours per day — "invisible work" that creates no value but consumes your cognitive energy.

Automation eliminates this invisible work. And with AI, automation goes further: it doesn't just copy data from one tool to another, it can understand, analyze, categorize, and write intelligently.

Concrete examples of what AI automation makes possible:

• →A complaint email arrives → AI categorizes it, assesses urgency, drafts a reply → auto-send (if low urgency) or manager alert (if high urgency)
• →A prospect fills out a form → AI analyzes their needs, scores lead quality, writes a personalized email → send + sales notification
• →A weekly report → AI compiles data from 5 sources, generates an analytical summary → distributed by email Monday morning at 8am

Make: automation for everyone

Make (make.com) is a visual automation platform that lets you connect 1800+ applications together without coding. You create "scenarios" by dragging and dropping modules onto a visual canvas, like a flowchart.

Why Make over another tool?

• →Powerful visual interface: routes, iterators, and aggregators enable complex workflows (not just A → B → C)
• →Native OpenAI module: ChatGPT/DALL-E/Whisper integration in a few clicks
• →Functional free plan: 1,000 operations/month, enough for prototyping
• →Excellent documentation and active community
• →Detailed execution history: each run is logged, each module inspectable

Essential Make vocabulary

To understand Make, master these 8 key concepts:

Make vs Zapier vs n8n: which tool to choose?

Recommendation: start with Make if you're following this course. It's the best power/accessibility tradeoff, and skills transfer directly to n8n or Zapier.

Understanding Make's pricing model

A crucial point before starting: Make charges by operations, not per scenario. Understanding what constitutes an operation avoids surprises.

What counts as 1 operation: each module executed = 1 operation. A 5-module scenario that runs once = 5 operations. Note: an iterator looping over 10 items with 3 modules in the loop = 10 × 3 = 30 operations.

Cost optimization tip: batch API calls. Instead of one OpenAI module per email (10 emails = 10 AI operations), use an aggregator to combine 10 emails into a single prompt, then a single OpenAI call (1 AI operation), then an iterator to redistribute responses. This divides your consumption by 10 on the most expensive modules.

Essential modules for AI automation

Make offers hundreds of modules. For AI automation, here are the 10 modules you'll use in 90% of your scenarios:

Error handling: what separates an amateur scenario from a professional one

A scenario without error handling will crash. An API timeout, an email without a subject, a malformed CSV — edge cases are inevitable. Make offers 4 error handling strategies:

1. →Ignore: the error is ignored, the scenario continues. Useful for non-critical modules (e.g., bonus Slack notification).
2. →Resume: the error is logged, the module produces a default output, the scenario continues. Useful when you have a fallback.
3. →Rollback: the entire execution is canceled and queued for retry. Useful for transactional processing.
4. →Break: execution stops, the item is stored in an "error queue" for manual reprocessing. This is the recommended default for AI scenarios — if the OpenAI API times out, you don't want to ignore (data loss) or retry in a loop (cost), but store the item for later reprocessing.

To configure error handling: right-click on a module → Add error handler → choose the type. Always add a handler on AI modules (OpenAI/Claude API) and file reading modules.

A real scenario: intelligent email sorting

Here's a complete scenario you'll build in the following sections, but it's useful to understand the architecture now:

Objective: every incoming email is automatically categorized, summarized, and routed to the right Slack channel.

Scenario architecture (7 modules):

1. →Gmail – Watch Emails (trigger, every 5 min)
2. →OpenAI – Create Completion (prompt: "Categorize this email as URGENT/IMPORTANT/FYI and summarize in 1 sentence: {{1.subject}} — {{1.textContent}}")
3. →JSON – Parse JSON (parse the AI's structured response)
4. →Router (3 routes: urgent → #alerts channel, important → #tasks channel, FYI → #watch channel) 5-7. Slack – Send Message (one per route, with adapted emoji and formatting)

Estimated cost: 7 operations per email × 50 emails/day = 350 ops/day = ~10,500 ops/month ≈ Core plan at $9/month. That's a savings of about 45 minutes per day of manual email triage.

The Make interface in detail

The canvas (main workspace): your playground. This is where you drag and drop modules and connect them with lines. Each module is represented by a circle or hexagon with the application icon.

The configuration panel: when you click on a module, a panel opens on the right. This is where you configure credentials (API connection), parameters (which AI model, what temperature), and data mapping (which data from the previous module to use).

Data mapping: this is the key to Make. Each module produces "outputs" (data). Subsequent modules can use these outputs by referencing them with {{N.variable}} where N is the module number. For example, {{1.email}} = the email extracted by module 1.

Execution history: every execution of your scenario is logged. You can click on any execution to see the input and output data of EACH module. Essential for debugging.

Scheduling: once the scenario is complete, you define when it runs: every 15 minutes, hourly, once a day at 8am, on-demand via webhook...

Exercise: your first scenario in 10 minutes

1. →Create a free account on make.com
2. →Click Create a new scenario
3. →Add a trigger: Google Sheets > Watch New Rows (connect your Google account, select a spreadsheet)
4. →Add an action: Slack > Send a Message (connect your Slack account)
5. →Map the data: in the Slack message, write New entry: {{1.Name}} — {{1.Email}}
6. →Click Run once to test → add a row in your Google Sheet → verify the Slack message appears
7. →If it works: activate scheduling (every 15 minutes)

Congratulations: you have your first working Make scenario. In the next sections, we'll add AI.