Make.com Automation Guide
for Beginners (2024)

What is Make.com and how does it work?

Make.com (formerly Integromat until a 2022 rebrand) is a visual workflow automation platform. You build "scenarios" — automated workflows that connect apps and services together — using a drag-and-drop diagram interface where each step is represented as a module and the connections between steps are visible as lines in the diagram. This visual representation is Make.com's most significant interface advantage over Zapier's linear list format: at a glance, you can see the entire logic of your automation, including all the branches and conditional routes.

Key concepts to understand before building

Scenario. The complete automation workflow. A scenario has a trigger (the module that starts the process) and one or more action modules (the modules that do things in response to the trigger). The equivalent of a "Zap" in Zapier or a "Workflow" in most other automation platforms.

Module. An individual step in the scenario. Each module connects to a specific app (Gmail, OpenAI, Google Sheets, Slack) and performs a specific action in that app (Watch Emails, Create a Completion, Add a Row, Send a Message). Modules are the building blocks; scenarios are the assembled structure.

Operation. One module execution. When a scenario runs and processes one item through a 4-module scenario (trigger + AI + Sheets + Slack), that uses 4 operations. The free tier provides 1,000 operations per month. Operations are Make.com's currency — understanding them helps you estimate costs and plan your automation architecture.

Bundle. The data object that flows from module to module through a scenario. When the Gmail "Watch Emails" trigger fires, it produces a bundle containing the email's subject, body, sender, timestamp, and other fields. Each subsequent module receives that bundle, can use its fields as inputs, and adds its own outputs to the bundle for downstream modules to use. Understanding bundles is the key to understanding data mapping in Make.com.

Router. A special module that splits the scenario into multiple paths. The Router evaluates conditions and routes the bundle to different downstream paths based on which condition is true. This is what enables conditional logic in Make.com — "if the AI classified this as BILLING, do this; if it classified it as SUPPORT, do that." The Router is the most powerful module in Make.com's library for building sophisticated automation logic.

The free tier is genuinely capable for meaningful AI automation work. 1,000 operations per month handles approximately 200–250 items through a 4-operation AI workflow. For a personal inbox with moderate email volume, a solopreneur's lead qualification workflow, or a small team's weekly reporting automation, the free tier is sufficient. Upgrade to Core ($9/month) when you consistently exhaust 1,000 operations or when the 15-minute minimum scheduling interval is a problem for time-sensitive workflows.

The Make.com interface: a practical orientation

Make.com's interface has four main areas. Understanding where to find things eliminates most beginner frustration.

The scenario editor (where you build)

When you create or open a scenario, you enter the scenario editor — a canvas where you build your workflow. The canvas starts with an empty circle (the trigger placeholder). You click circles to add modules, drag modules to reposition them, and click the connecting lines between modules to configure data mapping. The toolbar at the bottom controls scenario scheduling, testing, and activation. The history panel (accessible via the clock icon) shows all previous runs with their inputs, outputs, and any errors.

The module search

When you click an empty module placeholder or the "+" button to add a new step, a search dialog appears. Type the name of the app you want to connect (Gmail, OpenAI, Google Sheets, Slack, etc.) and Make.com shows all available modules for that app. Each module is a specific action — "Watch Emails" (trigger), "Send an Email" (action), "Add a Label to an Email" (action), "Create a Draft" (action) — and is typically named to describe exactly what it does.

The module configuration panel

When you click on an existing module, its configuration panel opens on the right side of the editor. This is where you set the module's parameters — the fields it needs to do its job. For a Gmail "Send an Email" module, these are: the connection (which Gmail account to use), the recipient, the subject, the body, and various optional settings. For an OpenAI "Create a Completion" module, these are: the connection (your OpenAI API key), the model, the messages (system and user), and optional parameters like temperature.

Data mapping — the most important skill

In the configuration panel for any module, you can click on any text field to open the data mapping interface. This shows all the data produced by previous modules in the current scenario, organised by module. You click on a piece of data to insert a reference to it into the current field. For example, when configuring the user message for your OpenAI module, you click inside the user message field, then click "Email Subject" from the Gmail module's data panel, type some separator text, then click "Email Body Plain" from the Gmail module. The field now contains a dynamic reference that will be populated with the actual email data when the scenario runs.

Data mapping is the key skill that separates beginners who struggle with Make.com from those who are productive quickly. Once you understand that every module produces labelled output fields that can be referenced in any subsequent module's configuration, the rest becomes intuitive.

Connecting OpenAI to Make.com: complete setup

Here is the exact process for adding an OpenAI AI step to any Make.com scenario.

6 practical AI scenario examples with exact configurations

Here are 6 complete Make.com AI scenarios with the specific configurations used in real deployments. Each includes the system prompt, the module sequence, and configuration notes for the non-obvious settings.

You are an email triage specialist. Classify each email and assess its urgency.

CATEGORIES (choose exactly one):
BILLING - invoices, payments, charges, refund requests, subscription questions
SUPPORT - product help, technical issues, bug reports, how-to questions
SALES - new business enquiries, partnership proposals, vendor outreach
ADMIN - scheduling, logistics, administrative coordination
SPAM - unsolicited bulk email, clear promotional with no relationship
OTHER - anything not clearly fitting above

Return ONLY valid JSON:
{"category": "CATEGORY_NAME", "urgency": 1-5, "sentiment": "positive|neutral|frustrated|angry", "summary": "max 10 words describing the email"}

Urgency: 1=no rush, 2=respond within 24hr, 3=respond within 4hr, 4=respond within 1hr, 5=immediate action needed

Router configuration: After the OpenAI module, add a Router. Create 4 routes with these filter conditions: Route 1 = category equals BILLING OR category equals SUPPORT AND urgency is less than 4 → auto-response path. Route 2 = urgency is 4 or 5 → immediate escalation path. Route 3 = category equals SPAM → archive path. Route 4 = all other (fallback) → log only. Connect appropriate action modules to each route.

You are a B2B sales qualification analyst. Score this inbound lead against our ideal customer profile.

Our ICP: Companies with 20-200 employees, SaaS or professional services industry, decision-makers (VP, Director, Head of) looking to improve team productivity or automate workflows. Budget signals: Series A+, $2M+ ARR, or mentions of current tool spend.

Score 1-10 for ICP fit. Assign tier: HOT (8-10), WARM (5-7), COLD (1-4).

Return ONLY valid JSON:
{
  "score": integer 1-10,
  "tier": "HOT" or "WARM" or "COLD",
  "fit_reasons": "2-3 key signals that informed the score",
  "concerns": "main hesitation or missing information",
  "suggested_action": "specific recommended next step in one sentence"
}

You are a business analyst writing weekly executive performance summaries. Be direct, data-driven, and honest. Do not pad with generic positive statements.

Write a weekly performance summary using the metrics provided. Exactly this structure:

WEEK IN ONE LINE: The single most important performance fact.

TOP 2 WINS: Brief bullets on what went well and why it matters.

TOP 2 CONCERNS: What needs attention + one specific action for each.

KEY NUMBER: The one metric that most defines this week's performance.

NEXT WEEK PRIORITY: One clear focus recommendation for the team.

Under 200 words total. Use specific numbers from the data. Plain English only.

You are a social media content strategist. Adapt the article provided into three platform-specific posts.

Brand voice: [INSERT YOUR BRAND VOICE — e.g., "direct, data-driven, occasionally contrarian, never uses jargon without explanation"]

Return ONLY valid JSON:
{
  "linkedin": "230-280 word post. Start with a hook (a surprising fact, a counterintuitive claim, or a specific result). 2-3 insight bullets. End with one question.",
  "twitter": "Max 250 characters. One bold claim or insight. No emojis. End with [LINK].",
  "instagram": "130-160 words conversational. The most relatable/human angle from the article. End with 7 hashtags on a separate line."
}

You are a support specialist for [COMPANY NAME]. Draft a helpful, personalised first response to this customer enquiry.

KNOWLEDGE BASE:
[PASTE YOUR KEY FAQs, POLICIES, AND PRODUCT INFORMATION HERE — keep under 2,000 tokens]

RESPONSE RULES:
- Address by first name if available ("there" if not)
- Reference something specific from their message
- Answer using only information in the knowledge base above
- If not in the knowledge base: "I want to give you accurate info on this — let me check and reply within [TIMEFRAME]"
- Under 120 words
- One clear next step at the end
- No generic openers ("Thank you for reaching out", "Hope this finds you well")

You are a financial data extraction specialist. Extract all invoice data from the document provided and return it as structured JSON.

Return ONLY valid JSON. No other text:
{
  "supplier_name": "string",
  "invoice_number": "string",
  "invoice_date": "YYYY-MM-DD",
  "due_date": "YYYY-MM-DD or null",
  "currency": "ISO code e.g. USD GBP INR",
  "subtotal": number,
  "tax_amount": number or null,
  "total_amount": number,
  "payment_terms": "string or null",
  "confidence": "high" or "medium" or "low"
}

Set confidence "low" if any of these are unclear: supplier_name, invoice_number, invoice_date, total_amount. Validation will flag low-confidence extractions for human review.

Make.com production tips that documentation misses

Use the Iterator + Aggregator for processing multiple items

When your trigger produces multiple items in a single run (e.g., 5 new emails, or a Google Sheets row with multiple entries), Make.com processes them as an array. To process each item individually through the AI, add an Iterator module immediately after the trigger — this splits the array into individual bundles, one per item. After processing, add an Aggregator if you need to combine the results back into a single output (e.g., for a batch report).

The JSON module is your best friend for structured AI output

When your OpenAI module returns JSON, add a Make.com "JSON" → "Parse JSON" module immediately after. Configure the data structure either by pasting an example JSON response (Make.com auto-detects the schema) or by defining it manually. This transforms the raw JSON string into properly mapped fields that subsequent modules can reference cleanly — instead of referencing "OpenAI module output text," you reference specific parsed fields like "score," "tier," and "summary."

Store API keys in connections, not in module configurations

When you create a connection to OpenAI (or any other API), Make.com stores the credentials securely in the connection and reuses the connection across all modules and scenarios that need it. This is more secure than entering your API key into every module's configuration individually, and it means you only need to update the key in one place if it changes. Always create a named connection — never use the option to enter credentials directly in a module's configuration if a connection option is available.

Use the "Resume" error handler for non-blocking failures

In production scenarios, some module failures should not stop the entire scenario run — they should be logged and skipped so the remaining items can be processed. Make.com's error handling lets you add a "Resume" directive to any module: if that module fails, the scenario logs the error and continues to the next item rather than stopping entirely. This is particularly important for scenarios processing batches of items where one bad input should not block all the subsequent good ones.

The execution history is your debugging superpower

Every Make.com scenario run is logged in the execution history (accessible via the clock icon in the scenario editor). For each run, you can see: which trigger fired, the bundle data at every stage, each module's inputs and outputs, any errors with their specific error messages, and the total operations consumed. When an automation produces an unexpected output, clicking into the execution history and tracing the data through each module step is almost always sufficient to identify the cause within 5 minutes.

Planning your operation budget: how to stay on the free tier longer

1,000 operations per month is the free tier limit. Here is how to think about whether that is enough for your use case and how to extend it if needed.

Operation-saving techniques

Combine actions where possible. A Google Sheets module that both updates the score column AND marks a status flag uses the same 1 operation as a module that only updates the score column. Reduce the number of modules by combining what each one does where the app's API allows it.

Use filters early to avoid unnecessary processing. Add a Filter module immediately after the trigger to skip items that should not be processed (empty inputs, spam indicators, items from excluded senders). A filtered-out item still costs 1 operation for the trigger but saves all the downstream operations that would have been consumed by processing it through the AI call and subsequent modules.

Batch instead of one-at-a-time where possible. For weekly report generation, process all the data in a single run rather than one item per run. A scenario that retrieves 10 data points and sends one report uses far fewer operations than 10 separate scenarios each retrieving 1 data point.

Frequently asked questions about Make.com