This Make.com tutorial takes you from empty account to a working automation in about 10 minutes — and covers the one mistake that breaks nearly every beginner's first scenario (it's in Step 4). No coding, no prior automation experience needed.
We'll build a real workflow — new Gmail attachment → saved to Google Drive → Slack notification — because it teaches every core concept you'll reuse forever: triggers, actions, connections, filters, and scheduling.
Key Takeaways
- Your first scenario needs just two things: a trigger module (watches for events) and an action module (does something about them)
- Always click “Run once” before activating — without sample data, you can't map fields in later modules, the #1 beginner failure
- The free plan (1,000 credits, 2 active scenarios) is plenty for this tutorial and your first real automations
- Clone from the template library for automation #2 onward — building from scratch is for learning, templates are for shipping
New to the platform entirely? Skim what Make.com is and how it works first for the vocabulary — this tutorial assumes you know what a scenario and a module are.
Step 1: Create Your Free Account (2 minutes)
Sign up at Make.com — the free plan needs no credit card and includes 1,000 credits/month. After registering, you'll land on the dashboard. Rename your organization (top of screen) to your business or personal name, then click Scenarios → Create a new scenario.
You're now looking at the blank canvas: a big empty space with a single “+” circle in the middle. Everything you build starts here.
Step 2: Add Your Trigger Module (2 minutes)
Click the + and search for Gmail. Select it, then choose Watch Emails — this is your trigger, the event that starts everything.
Make will prompt you to create a connection: click “Add,” sign into Google, and grant access. Connections are reusable — you authenticate each app once, ever.
Configure the trigger: choose your inbox folder, set “Criteria” to only watch for emails with attachments, and set the maximum number of results to 1 while testing.
Key concept: trigger modules poll on a schedule (every 15 minutes on free, down to 1 minute on Core) or fire instantly via webhooks. Each poll costs a credit whether or not new mail exists — remember that when you scale.
Step 3: Add Your Action Modules (3 minutes)
Hover over the right edge of your Gmail module until a “+” appears. Add Google Drive → Upload a File.
Now the crucial part — mapping. In the file field, you'll see a panel of data elements from the Gmail module. Drag the Attachment item into the file field, and the attachment's File Name into the name field. You just told Make: “take whatever Gmail found and pass it here.”
Add one more module after Drive: Slack → Create a Message. Choose your channel and compose a message using mapped fields: “New attachment saved: [File Name]”.
Three modules, one flow. This exact chain pattern — watch → process → notify — underlies the majority of business automations you'll ever build.
Follow along live — create your free Make account in 60 secondsStep 4: Run Once Before You Activate (THE Critical Step)
Here's the mistake that breaks most first scenarios: activating without ever clicking “Run once.”
Why it matters: Make can only show you real, mappable data after the scenario has executed at least once with live data. If you skipped ahead and your mappings look right but reference empty structures, the scenario fails silently or writes blanks.
The correct ritual, every time:
- Click Run once (bottom left)
- Send yourself a test email with an attachment
- Watch the modules light up as data flows through — click each bubble to inspect exactly what passed between modules
- Fix any mapping issues now, while you can see the actual data
This inspection view is Make's superpower. You can see the precise input and output of every module — debugging here is dramatically easier than in linear tools.
Step 5: Add a Filter and Schedule It (3 minutes)
Filter: click the wrench icon on the line between Gmail and Drive → “Set up a filter.” Add a condition — e.g., only continue if the sender contains your client's domain. Filters keep junk out of your automation (note: each filter evaluation costs a credit).
Schedule: toggle the scenario ON (bottom left). Click the clock icon on the trigger to set frequency — every 15 minutes is the free plan's floor and honestly fine for most use cases.
Congratulations: you have a production automation.
5 Starter Recipes to Build Next
Steal these — each takes under 15 minutes with the skills you just learned:
- Typeform → Gmail → Notion: survey response → email the team → archive to database
- WooCommerce → Google Sheets + Email: log every order, alert on big ones
- Google Calendar → Slack: DM yourself 30 minutes before meetings
- RSS → Slack: monitor competitor blogs or industry news into a channel
- Instagram → Facebook + X: post once, syndicate everywhere
Want more? We've documented 17 Make.com automation examples grouped by business function, most clonable from Make's template library.
Skip the blank canvas — browse Make's free template libraryBeginner Mistakes to Avoid
- Not running “Run once” first (covered above — it's that important)
- Polling every minute out of caution. A 1-minute interval burns ~43,000 credits monthly on checks alone. Start at 15 minutes; tighten only when a workflow genuinely needs speed. More credit-saving tactics as you scale: watch your free plan limits dashboard weekly.
- Building giant scenarios first. Two or three modules, tested and boring, beat a ten-module masterpiece that fails mysteriously.
- Ignoring error handlers. Right-click any module → “Add error handler” once your scenario touches real business data.
Level 2: Your First Router (When You're Ready)
Once the basic chain feels comfortable — give it a few days — the router is your next unlock, and it's what separates Make from linear tools.
The exercise: upgrade your attachment-filing scenario to sort intelligently. Right-click the connection after your Gmail trigger and add a Router. Create three branches: attachments from clients (filter: sender contains client domain) → “Clients” Drive folder; invoices (filter: filename contains “invoice”) → “Accounting” folder + a Sheets log row; everything else → “Misc” folder.
Three concepts this teaches at once: branch filters (each route has its own conditions, evaluated independently), fallback routes (designate the “everything else” branch as fallback so nothing vanishes), and branch-specific chains (notice the invoice branch does two things — branches are full module chains, not single actions).
Run once, send yourself three test emails matching each condition, and watch the inspector show data flowing down different paths. That moment — seeing one trigger fan into conditional logic you can trace visually — is when most people understand why Make users don't go back to linear builders.
Credit note: the router itself is free to traverse, but each branch's modules bill normally, and every filter evaluation counts. A three-branch router scenario costs roughly the same as its active branches — you pay for what runs, not what could run.
Ready for routers? Everything in this tutorial runs on Make's free planReading Your Execution History (2-Minute Skill)
Before you build scenario number two, learn to read what scenario number one actually did — this is the debugging skill that separates people who progress from people who quit.
Click the History tab on any scenario. Every execution shows its status, duration, and credit cost. Click into one and the canvas replays it: each module displays a bubble with the exact data bundles it received and produced. When something misfires, you don't guess — you click the module, open bundle 1, and read the actual values.
Three things to check on your first real execution: the trigger bundle contains the fields you expected (empty fields here mean a mapping problem downstream), each module shows the right number of bundles (2 bundles in, 1 out usually means a filter ate one), and the credit count matches your mental math (surprises here reveal hidden module runs — usually an iterator).
Five minutes in the History tab teaches more than an hour of documentation.
FAQ
Is Make.com good for beginners? Yes, with a caveat: expect 30-60 minutes to comfort, versus minutes on simpler tools. The visual canvas pays that back the first time you need branching or debugging.
Do I need the paid plan for this tutorial? No. Everything here runs on the free plan. Upgrade when you need more than 2 active scenarios or faster polling.
What's a scenario vs a module? A scenario is the whole workflow; modules are the individual app blocks inside it.
Where do I learn advanced features like routers? Build three simple scenarios first, then explore routers and iterators — and read our full Make.com review to understand the credit implications of advanced modules before you scale them.
That's the complete Make.com tutorial: trigger, action, mapping, Run once, filter, schedule. Master those six moves and every automation on the platform is just a bigger arrangement of the same pieces.
