Make.com Tutorial for Beginners: Your First 5 Automations in 2026 (Step by Step)

So you've decided to use Make instead of Zapier. Good call — we've spent 90 days comparing them and for most solopreneurs Make wins on price and power.

But here's where most people get stuck: they sign up, stare at the blank canvas, watch a 45-minute YouTube tutorial about an abstract example they'll never use, and give up.

This tutorial is different. We're going to build 5 real automations — the exact ones that save solopreneurs the most time — step by step. By the end, you'll have a working automation system and understand Make well enough to build your own.

No theory dumps. Just build.

Before We Start: Make Vocabulary in 60 Seconds

Make uses slightly different words than Zapier. Here's all you need:

• Scenario = an automation (Zapier calls this a "Zap")
• Module = one step in a scenario (a single action or trigger)
• Credit = one run of one module. Make used to call these "operations" and renamed them to credits — for standard, non-AI automations like the five below, 1 credit = 1 operation, so any older guide's maths still holds. Your plan gives you a monthly credit budget; the free plan has 1,000/month
• Trigger = the event that starts the scenario (new email, form submission, etc.)
• Scenario builder = the visual canvas where you connect modules

That's it. Now let's build.

Read This Before You Start: The Free Plan Runs Two Scenarios

This is the single most important limit in this tutorial, and it has nothing to do with credits.

Make's free plan allows only 2 active scenarios at a time, with a minimum scheduling interval of 15 minutes. This tutorial builds five automations. You cannot run all five on the free plan — not because you'd run out of credits, but because you'd run out of scenario slots.

So here's the honest framing for the rest of this guide:

• On Free: build all five to learn them, then keep the two that earn their place switched on. The others sit inactive until you need them. Two active scenarios is genuinely useful — it's still multi-step automation with real conditional logic, which is more than Zapier's free plan gives you.
• On Core ($9/month): all five run at once, with 10,000 credits instead of 1,000. This is the upgrade the tutorial is really pointing at, and it's the one we'd make first in any solo stack.

Everything below works identically on either plan. Just don't be surprised when the third scenario refuses to turn on.

Setup (5 minutes)

1. Go to Make.com and create a free account
2. Verify your email
3. You'll land on the dashboard. Click "Create a new scenario" (top right)
4. You'll see a blank canvas with a single circle in the middle — that's where your first module goes

Keep this tab open. We'll build all 5 automations here — remembering that on Free only two of them can be active at once.

Automation 1: Save Email Attachments to Google Drive

The problem it solves: Clients send invoices, contracts, and files by email. You manually download and file them. This wastes 10-15 minutes a day and things get lost.

What it does: When an email with an attachment arrives in a specific Gmail label, Make automatically saves the attachment to a Google Drive folder.

Build it:

1. Click the center circle → search "Gmail" → choose it
2. Select the trigger "Watch emails"
3. Connect your Gmail account (click "Add", authorize)
4. Configure: choose the folder/label to watch (e.g., "Clients"), set "Watch emails" to "Only with attachments"
5. Set "Maximum number of results" to 1 (process one at a time to start)
6. Click OK
7. Now click the "+" next to the Gmail module → search "Google Drive" → choose "Upload a file"
8. Connect Google Drive
9. In the file field, map the attachment from the Gmail trigger (click the field, select "Attachments[ ]: Data" from the dropdown)
10. Choose the destination folder
11. Click OK

Test it: Click "Run once" at the bottom left. Send yourself a test email with an attachment to that label. Watch it appear in Drive.

Schedule it: Toggle the scenario ON (bottom left). Set it to run every 15 minutes.

Credits used: ~2 per email. At 20 client emails/day, that's ~1,200/month — right at the free tier edge, so this one alone might push you to the $9 Core plan eventually. Worth it.

Automation 2: Add New Form Submissions to a Google Sheet

The problem it solves: Leads come in through a contact form. You copy-paste them into a spreadsheet (or worse, lose them in your inbox).

What it does: Every new form submission automatically becomes a row in a Google Sheet, timestamped.

Build it:

1. New scenario. Center circle → search your form tool (Typeform, Google Forms, Tally, etc.)
2. Choose the trigger "Watch new submissions" (or equivalent)
3. Connect and configure to watch your specific form
4. Click "+" → "Google Sheets" → "Add a row"
5. Connect Google Sheets, choose the spreadsheet and worksheet
6. Map each form field to a column (Name → Column A, Email → Column B, etc.)
7. Add a timestamp: in an empty column, type {{now}} to capture submission time
8. Click OK

Test it: "Run once", submit a test form entry, confirm the row appears.

Schedule it: Toggle ON, run every 15 minutes.

Credits used: ~1 per submission. Negligible for most solopreneurs.

This is the foundation of a simple CRM if you don't want a full tool yet — though once you have more than ~50 leads, we'd recommend a proper free CRM.

Automation 3: Auto-Reply to New Leads Instantly

The problem it solves: A lead fills out your form at 11 PM. You reply at 10 AM the next day. By then they've contacted two competitors. Speed-to-lead is everything.

What it does: The moment someone submits your form, they get a personalized email reply within seconds — even while you sleep.

Build it:

1. Open the scenario from Automation 2 (the form → sheet one)
2. After the Google Sheets module, click "+" → "Gmail" → "Send an email"
3. Connect Gmail
4. In the "To" field, map the email field from the form trigger
5. Write your subject: e.g., Thanks for reaching out — here's what happens next
6. Write your body. Use mapped fields to personalize:

Hi {{Name}},

Thanks for getting in touch. I've received your message about 
{{their inquiry field}} and I'll personally reply within 24 hours.

In the meantime, here's a quick overview of how I work: [link]

Talk soon,
[Your name]

7. Click OK

Test it: "Run once", submit a test form, check that the auto-reply arrives.

Why this matters: We covered the full speed-to-lead and follow-up system in our automated client follow-ups guide. This is the first piece of it.

Credits used: ~1 per lead. Tiny.

Automation 4: Turn Starred Emails into Tasks

The problem it solves: You star important emails meaning to act on them later. They get buried. Nothing happens.

What it does: When you star an email in Gmail, Make creates a task in your task manager (Todoist, Notion, ClickUp, etc.) with the email subject and a link back.

Build it:

1. New scenario. Center circle → "Gmail" → trigger "Watch emails"
2. Configure to watch the "Starred" label
3. Click "+" → your task tool (we'll use Todoist as example) → "Create a task"
4. Connect Todoist
5. Map the task content: use the email Subject as the task name
6. In the task description, map the email snippet and add the Gmail link
7. Optionally set a due date: {{addDays(now; 2)}} for 2 days out
8. Click OK

Test it: "Run once", star an email, confirm the task appears.

Schedule it: Toggle ON, every 15 minutes.

Credits used: ~1-2 per starred email. Minimal.

Automation 5: Weekly Digest of Your Key Metrics

The problem it solves: You never look at your numbers until something's wrong. A weekly snapshot keeps you honest without manual effort.

What it does: Every Monday morning, Make pulls data from a Google Sheet (your leads, revenue, whatever you track) and emails you a simple digest.

Build it:

1. New scenario. Center circle → click the clock icon to set a schedule trigger
2. Set it to run weekly, Mondays at 8 AM
3. Add "Google Sheets" → "Search rows" to pull your data (e.g., all leads from the past week)
4. Add a "Tools" → "Numeric aggregator" or "Array aggregator" to count/sum the rows
5. Add "Gmail" → "Send an email" to yourself
6. In the body, map the aggregated numbers:

Your week in numbers:

New leads: {{count}}
Total pipeline value: {{sum}}
Replies sent: {{...}}

Have a focused week.

7. Click OK

Test it: "Run once", check the digest email arrives with real numbers.

Credits used: ~3-5 per week. Nothing.

This is a simplified version of the metrics tracking we recommend in our solopreneur AI stack guide.

Understanding Credits (So You Don't Get Surprised)

Make's free plan gives you 1,000 credits/month. Here's roughly what the 5 automations above consume if you're moderately active:

Two separate ceilings, and people usually hit the wrong one first. The credit budget above is the ceiling everyone talks about — but as covered at the top, Free also caps you at 2 active scenarios. You'll bump into the scenario cap long before the credit cap, because it applies the moment you switch on a third automation regardless of how little it runs.

Running all 5 actively means the Core plan at $9/month, which lifts both ceilings at once: unlimited active scenarios and 10,000 credits instead of 1,000. For most solopreneurs that's still dramatically cheaper than the equivalent on Zapier — we broke down the full cost comparison in our Zapier vs Make analysis and Zapier alternatives guide.

Where 1 credit stops equalling 1 operation. The table above holds for standard app modules like the five in this tutorial. Two things break that ratio, and both can drain a budget fast:

• Make's native AI modules bill by token usage, not per run. A single AI step can cost many credits depending on how much text goes in and comes out — so an AI-heavy scenario is nothing like a Gmail-to-Sheets one on cost.
• Make Code (custom JavaScript) costs 2 credits per second of execution. A slow or badly-written script is charged by the clock, not the call.

If you add either, check your usage page after a day rather than trusting an estimate.

Pro tip to save credits: Set scenarios that don't need to be instant (like the digest, or attachments) to run less frequently — every 30-60 min instead of every 15. Cuts credit usage significantly. Note that Free enforces a 15-minute minimum interval anyway.

Common Beginner Mistakes

After helping solopreneurs set up Make, these are the mistakes we see most:

1. Running scenarios too often. Every-minute scheduling burns credits fast — and isn't available on Free, which enforces a 15-minute minimum. Most automations are fine at 15-30 min intervals.

2. Not using "Run once" to test. Always test with "Run once" before toggling a scenario live. It shows you exactly what data flows through.

3. Forgetting error handling. For critical scenarios, add an error handler (right-click a module → "Add error handler") so a single failure doesn't stop everything.

4. Over-automating too early. Build one automation, use it for a week, then build the next. Don't set up 10 at once — you won't understand them when they break.

5. Mapping the wrong field. When you see [ ] brackets in a field (like "Attachments[ ]"), that's an array — Make handles multiple items. Single fields don't have brackets. Mixing these up is the #1 cause of "it's not working."

Where to Go Next

Once these 5 feel comfortable, the natural next steps:

• Add filters: Right-click between modules to add a filter (e.g., "only if email is from a client domain")
• Add routers: Split a scenario into multiple paths based on conditions
• Connect AI: Make has native OpenAI and Anthropic modules — you can have ChatGPT draft replies, summarize emails, or categorize leads automatically
• Explore templates: Make's template library has thousands of pre-built scenarios you can clone and customize

For the bigger picture of where automation fits in your overall tool stack, see our complete solopreneur AI stack. And if you're still deciding between automation platforms, our Make alternatives guide covers the full landscape.

---

This tutorial was built using Make's actual 2026 interface. Steps may vary slightly as Make updates its UI. Some links may be affiliate links — read our policy.