Make.com (formerly Integromat) is one of the most powerful automation platforms available to non-developers. It connects hundreds of apps, handles complex logic, and can run automations that would otherwise require custom code — all through a visual drag-and-drop interface.
But Make’s power is also its learning curve. The platform has hundreds of modules, and beginners often get lost choosing between them or miss the ones that unlock the platform’s real potential.
These are the 10 modules every creator, marketer, and solopreneur should know — not because they’re the most advanced, but because they’re the foundation of almost every useful automation you’ll ever build.
What Is a Module?
In Make, a module is a single action or trigger in your automation scenario. Every scenario is a sequence of modules connected in a flow. Some modules trigger a scenario (something happens → scenario starts). Others perform actions (do this → produce that). Understanding which modules exist and what they do is what separates people who build powerful automations from those who get stuck.
1. Webhooks — Custom Webhook (Trigger)
What it does: Creates a unique URL that can receive data from any external source — a form, an app, another automation platform, or custom code. When that URL receives a payload, your Make scenario triggers.
Why it’s essential: Webhooks are the universal input. If an app doesn’t have a native Make integration, you can almost always send data to a webhook instead. They’re the foundation for connecting Make to tools that aren’t in its native app library.
Practical use: Typeform submissions trigger a Make scenario → AI processes the responses → sends a personalized email + adds a row to a Google Sheet.
Key tip: After creating the webhook module, send it a test payload from the source app so Make can “learn” the data structure. This makes mapping fields in subsequent modules much easier.
2. HTTP — Make a Request
Build this with the free AI Toolkit
Starter prompts, system maps, and the first workflow for each DSHQ system — the fastest way to put this into practice.
Get the Free ToolkitWhat it does: Sends an HTTP request (GET, POST, PUT, DELETE) to any API endpoint. Essentially, this module lets Make talk to any service that has an API — even if there’s no native Make integration.
Why it’s essential: This is Make’s escape hatch from its native module library. Once you understand this module, you’re not limited to Make’s 1,000+ integrations — you can connect to literally any API-enabled service.
Practical use: Send a POST request to the OpenAI API with a prompt → receive the AI-generated response → use that response in the next module to update a Notion database or send an email.
Key tip: Set the “Body type” to “Raw” and the content type to application/json for most modern API calls. Store API keys in Make’s “Connections” rather than hardcoding them in the module for security.
3. Router
What it does: Splits a scenario into multiple parallel branches based on conditions. Each branch runs independently based on the filter you set.
Why it’s essential: Real workflows aren’t linear. A new customer might need different handling than a returning customer. A high-priority ticket needs different routing than a routine inquiry. The Router is what makes conditional logic possible in Make.
Practical use: A new form submission routes to Branch A (new lead → CRM + welcome email) or Branch B (existing contact → update record + notification to sales) based on whether the email already exists in your database.
Key tip: Add filters to each Router branch immediately — an unfiltered branch will process every bundle that passes through, which causes duplicate actions. Right-click the branch connection to add a filter.
4. Iterator
What it does: Takes an array (a list of items) and processes each item one at a time through the rest of the scenario. Instead of handling all items at once, the Iterator feeds them one by one.
Why it’s essential: Many APIs and modules return lists — a list of emails, a list of rows, a list of Notion pages. Without the Iterator, you can’t act on each item individually. With it, you can loop through any list and apply logic to each element.
Practical use: Google Sheets returns an array of rows. Iterator processes each row one at a time → for each row, send a personalized email based on that row’s data.
Key tip: After an Iterator, Make shows “1 bundle” in each module because it’s processing items sequentially. This is expected behavior, not an error.
5. Array Aggregator
What it does: The opposite of the Iterator. It takes individual items processed in a loop and combines them back into a single array. This is how you collect results from a loop and use them together in a single downstream action.
Why it’s essential: Iterator + Array Aggregator is the complete loop pattern in Make. You need both to build workflows that process multiple items and then do something with the combined results.
Practical use: Loop through 10 product names (Iterator) → generate an AI description for each → collect all descriptions (Array Aggregator) → send one email with all 10 descriptions compiled.
Key tip: In the Aggregator settings, set the “Source Module” to the Iterator that started the loop. This tells Make which loop this Aggregator closes.
6. Text Parser — Parse Text (Regex)
What it does: Extracts specific text patterns from a string using Regular Expressions (regex). This lets you pull out emails, URLs, phone numbers, specific words, or any defined pattern from unstructured text.
Why it’s essential: Real-world data is messy. Emails contain text you need to extract. AI outputs often include the information you need surrounded by other text. The Text Parser is how you pull exactly what you need from a larger block of text.
Practical use: AI returns a response with a recommended price embedded in prose: “Based on the analysis, I recommend a price of $249.” Text Parser extracts “249” so you can use the number in the next module.
Key tip: You don’t need to be a regex expert to use this module effectively. For common patterns (email addresses, URLs, numbers), search “regex for [pattern]” and copy the expression.
7. Tools — Set Variable / Get Variable
What it does: Stores a value in memory during a scenario run (Set Variable) and retrieves it later (Get Variable). Variables persist throughout the scenario but reset when the scenario ends.
Why it’s essential: Variables let you reference a value at multiple points in a scenario without having to recalculate or re-fetch it. They also let you carry a value across Router branches or out of Iterator loops.
Practical use: Calculate a total price early in the scenario → store it as a variable → reference that same total in three different modules later (email body, CRM field update, Slack notification) without recalculating.
Key tip: Name your variables clearly (e.g., customer_email, total_price, submission_date). Vague names like var1 become confusing quickly in complex scenarios.
8. Flow Control — Sleep
What it does: Pauses a scenario for a specified number of seconds before continuing to the next module.
Why it’s essential: Many APIs have rate limits — they only accept a certain number of requests per second or per minute. Without a Sleep module, Make can fire requests too fast and get rate-limited or blocked, causing scenarios to fail.
Practical use: Looping through 50 rows and making an API call for each one. Add a Sleep of 1–2 seconds between each call to stay within the API’s rate limits.
Key tip: Check the API documentation for rate limits before building loops. Most common APIs (OpenAI, Notion, Google) have documented limits. Build in Sleep from the start — retrofitting it after scenarios are failing is frustrating.
9. Data Store — Search Records
What it does: Queries Make’s built-in Data Store (a simple database) to find records that match conditions. Make Data Stores let you store and retrieve structured data across scenario runs without needing an external database.
Why it’s essential: Many automations need memory — they need to know what happened in previous runs to decide what to do now. Has this email been processed before? Has this user already received this message? Data Stores answer those questions.
Practical use: Before sending a follow-up email, check the Data Store for the lead’s email address. If found → skip (already followed up). If not found → send the email + add their address to the Data Store.
Key tip: Data Stores are not built for large datasets (they have storage limits). For anything beyond a few thousand records, use Airtable or Google Sheets instead and query those with their respective Make modules.
10. Error Handler — Break / Resume / Rollback / Ignore
What it does: Defines what Make should do when a module fails. Without an error handler, a scenario stops completely on any error. With error handlers, you can choose: ignore the error and continue, retry the operation, roll back completed actions, or log the error and stop.
Why it’s essential: Production automations encounter errors — API timeouts, unexpected data formats, missing fields. An unhandled error means the entire scenario fails silently. Error handlers mean your scenarios are resilient and failures are visible.
Practical use: Sending 100 emails in a loop. One email address is malformed and causes an error. Without error handling, all 100 stop. With an Ignore error handler, that one address is skipped and the other 99 send successfully.
Key tip: Right-click any module to add an error handler. For most production scenarios, add at minimum an error handler that logs failures to a Google Sheet or sends a notification to Slack. This gives you visibility into what’s failing without manual monitoring.
Putting It Together: A Real Example Using All 10
Here’s a scenario that uses every module above — an AI-powered content processing pipeline:
- Webhook receives a new blog post submission
- HTTP calls the OpenAI API with the post content to generate a summary
- Text Parser extracts the summary from the API response
- Data Store checks if this post has already been processed
- Router splits into “New” and “Already processed” branches
- Tools / Set Variable stores the summary for use across branches
- Iterator loops through each social platform (Twitter, LinkedIn, Facebook)
- Sleep pauses 1 second between each API call
- Array Aggregator collects all social captions
- Error Handler catches any failures and logs them to a sheet
One scenario. Every module from this list. The output: automated content processing from submission to multi-platform distribution.
The Learning Path
If you’re new to Make, don’t try to master all 10 at once. Build scenarios in this order:
- Start with a simple 2-module trigger + action (e.g., Gmail → Google Sheets)
- Add a Router to handle conditional logic
- Build your first loop with Iterator → Array Aggregator
- Connect an external API with the HTTP module
- Add error handling to any scenario you rely on
Each step builds on the last. Within a few weeks of building with this progression, these 10 modules become second nature — and the more advanced Make features become accessible because the fundamentals are solid.
Make.com isn’t hard to learn. But like any powerful tool, understanding the right components first makes everything else click.
Published on DigitalSavvyHQ.com — practical AI systems for creators, marketers, and small business owners who want to work smarter.