Make.com Tutorial: Building Your First Real Automation in Under 30 Minutes

Before You Start: What You'll Need

To complete this tutorial, have these three things ready—you don't need to set them up yet, just be aware:

• A Make.com account (free tier is fine, 1,000 operations/month)
• An Airtable account (free tier works—you'll use it as a database)
• A Slack workspace (where you'll receive notifications)

If you don't have these yet, don't panic. I'll walk you through signing up as we go. The whole process takes about 10 minutes if you're starting from scratch.

Step 1: Create Your Make.com Account & First Scenario (5 minutes)

Head to Make.com and sign up. Use your email, create a password, and verify your account. You'll land on the dashboard.

Next, click "Create a new scenario" (or "New scenario"). You'll see a blank canvas—this is where the magic happens. A scenario is just a fancy word for a workflow or automation. Don't be intimidated by the empty space.

Step 2: Understand the Make.com Canvas

Your scenario canvas has a few key parts:

• Modules: The boxes you'll connect together. Each one does one thing (receive data, transform it, send it somewhere)
• Bundles: The data flowing between modules. Think of it like packages traveling down a conveyor belt
• Canvas: The gray area where you drag and connect modules
• Module panel: On the left side. You'll drag modules from here onto the canvas

Here's what we're building: Webhook (receive form data) → Airtable (save to database) → Slack (send you a notification).

Step 3: Add Your Trigger (Webhook)

Every scenario starts with a trigger—an event that kicks everything off. In our case, someone submitting a form.

Here's how:

1. Click the first (blank) module in the center of your canvas
2. Search for "Webhooks" in the module panel that appears
3. Find "Webhooks" and click "Custom Webhook"
4. Click "Add" to create a new webhook
5. Make.com will generate a unique webhook URL. Leave it open for now—you'll use this later to test

What's happening: You've just created a special URL that will listen for incoming data. When someone fills out your form (or you test it), that data gets sent to this URL, and your scenario fires.

Pro tip: The webhook URL looks like: https://hook.us1.make.com/xxxxx. Save this somewhere safe. You'll need it to test your workflow later.

Step 4: Add Your First Action (Airtable)

Now you'll add a module that takes the incoming form data and saves it to Airtable.

Steps:

1. In the canvas, click the plus sign (+) to the right of your Webhook module
2. Search for "Airtable" in the module panel
3. Select "Airtable" → "Create a record"
4. You'll be asked to connect your Airtable account. Click "Add" and log into Airtable
5. Make.com now has permission to write to your Airtable base

Next, configure the Airtable module:

1. Select your base (or create a new one called "Contact Submissions" if you don't have one)
2. Select the table (or create one called "Contacts")
3. You'll see fields like "Name," "Email," "Message." These are what we'll map to the form data

Step 5: Map the Data (The Slightly Tricky Part)

This is where most beginners get stuck, but it's actually straightforward once you understand it. Mapping is just telling Make.com: "When someone fills out the form, put their name in the Name field, their email in the Email field," etc.

Here's how it works:

1. In the Airtable module, you'll see a form with fields. Click in the "Name" field
2. A popup will appear showing the data available from your webhook. You'll see options like "data :: name", "data :: email", etc.
3. Click "data :: name" and it'll auto-populate in the Name field
4. Repeat for Email and any other fields you want to capture

What's actually happening: The webhook receives data structured like: { name: "John", email: "john@example.com", message: "I love your tool" }. You're telling Make to take the "name" part and put it in Airtable's "Name" column.

Step 6: Add Your Notification (Slack)

Add one more module so you get notified when someone submits the form.

Steps:

1. Click the plus sign after your Airtable module
2. Search for "Slack" and select "Send a message"
3. Connect your Slack workspace (click "Add" and authorize)
4. Select the channel where you want notifications (e.g., #notifications or a DM to yourself)
5. In the message field, type something like: "New submission from [data :: name] - [data :: email]"

Make.com will use the actual data from the form when it sends the message.

Step 7: Test Your Workflow

Before activating, test everything. This is crucial.

Here's how to test:

1. Click the "Test" button (usually at the bottom of the Webhook module)
2. A test window opens. Paste some sample data in JSON format, like:

{ "name": "Jane Doe", "email": "jane@example.com", "message": "This is a test" }

3. Click "Send" and watch your scenario run
4. Check your Airtable—a new row should appear
5. Check Slack—you should see the notification

If something didn't work: Check the execution history (the bottom panel) to see where the data stopped. Usually it's a mapping issue—the module can't find the data you told it to use. Go back and re-map.

Step 8: Activate & Connect Your Form

Once the test passed, activate your scenario. Click the big "On/Off" toggle in the bottom left. It should turn blue.

Now the webhook is listening. To actually use this, you need to connect a form. You can:

• Use Make's built-in form builder (easiest for testing)
• Use a third-party form service like Typeform, Google Forms, or Formspree and point it to your webhook URL
• Have a developer add your webhook URL to your website

For this tutorial, test it manually by pasting JSON data into the test panel, or use a tool like Postman to send data to your webhook URL. The automation will work the same way either way.

What Comes Next

You've just built your first real automation. From here, you can:

• Add more modules: After Slack, send an email, add a delay, call an API, anything
• Add conditions: Only send a Slack message if the email contains "@company.com"
• Use filters & transformers: Clean up data, reformat dates, split text
• Scale it up: Add your form to your website and it'll run automatically for every submission

The core concept stays the same: trigger → action → notification. Every complex workflow I've built starts with this exact pattern.

Common Beginner Mistakes (And How to Avoid Them)

1. Forgetting to activate the scenario. You'll build everything perfectly, but if the toggle isn't on, nothing happens. Always check that blue toggle.

2. Mapping data with the wrong field names. Make sure the data your form sends matches what you're mapping. If your form sends "user_email" but you're mapping "email," it won't work.

3. Testing with real data instead of making a test submission first. Always test with sample data before connecting a real form. Catches 90% of issues.

4. Not checking execution history when something fails. Every module run leaves a log. Click on the failed execution to see exactly where it broke. This is your best debugging tool.

5. Trying to do too much in one scenario. Start simple (3 modules). Once it works, add complexity. Complex scenarios are just simple ones stacked together.