Make.com Tutorial: Build Your First Business Automation in One Evening

A prospect fills in your form at 9 a.m. You discover their request at 6 p.m., buried under a pile of notifications. In between, they may have signed up somewhere else. For a solopreneur, every slow reply is an opportunity going up in vapor.

In this Make.com tutorial, I show you how to build an end-to-end automated response in a single evening. A Tally form captures the lead. Make adds it to a Google Sheet, notifies you by email, and has AI summarize the request. Not a single line of code, and a credit model taken from the official pricing page on the day I write these lines.

The result at a glance

• The scenario: the Tally webhook triggers this Make.com tutorial’s scenario, which adds the lead to Google Sheets, sends a Gmail notification, and asks an AI module to summarize the request.
• The cost: $0 to get started. Make’s free plan includes 1,000 credits per month, and both Tally and Google Sheets offer a free tier.
• The consumption: four triggered modules amount to 4 credits per submission, roughly 250 leads covered every month without spending a dime.
• The prerequisite: a Google account, a Tally account, a Make account. The no-code automation is built entirely with your mouse.

This is the first automation I recommend to any Make beginner: useful from day one, readable on a single screen, and cheap. In this Make.com tutorial, every step starts from the real interface: you click, you test, you switch it on. By the end, your leads no longer sleep at the bottom of an inbox.

Why this Make.com tutorial starts from a real business case

Most Make tutorials in French recycle the same example: a Gmail email copied into a spreadsheet, or an attachment pushed to Drive. It’s clean, but it doesn’t feed a business. The three pages that dominate the SERP also still cite the old “operations” model, since replaced by credits.

Here, we automate a real moment of truth: the arrival of an incoming request. Automating lead intake is the first win the entrepreneurs I coach want to make their own. A form captures, a spreadsheet organizes, an email alerts, an AI summarizes. No-code automation follows a flow logic that you will see on screen, module after module.

The 2026 credit model, explained in two minutes

Before clicking anything, this Make.com tutorial needs to set one rule. Make has replaced operations with credits: every module action consumes one. Adding a row in Google Sheets: one credit. Fetching a submission through the webhook: one credit. Sending the Gmail notification: another one.

One module executed equals one credit consumed. It is the unit that governs every Make scenario, spelled out in black and white on the official pricing page.

A four-module scenario that runs ten times therefore consumes 40 credits. This granularity helps with budgeting: you know how many leads your plan covers before pulling out your credit card. Another official benchmark: data volume follows the same logic, with 5 GB of transfer allocated for 10,000 credits per month.

One last example to make things concrete. A monitoring scenario that checks a feed every 15 minutes consumes one credit per check, even with nothing new to process. When in doubt, prefer webhook triggers, which only run on demand. That’s the difference between automating tasks blindly and automating them with a budget under control.

Make.com pricing in 2026

Here is the grid taken from the official Make pricing page on the day this Make.com tutorial was published. Prices are per month; annual billing promises savings of 15% or more, and the Enterprise plan remains quote-based.

Three points deserve a solopreneur’s attention. The free plan caps active scenarios at two and the scheduled-run interval at 15 minutes. The Core plan, at $12, unlocks unlimited active scenarios and minute-level triggering. Finally, Make AI Agents in beta and the Make AI Toolkit are available on all plans, and the Maia by Make assistant helps build scenarios in natural language.

Step 1: create your account and get the lay of the land

Head over to make.com and create a free account. The dashboard boils down to three areas: Scenarios, the list of your automations; Connections, your app credentials; and the execution history, which shows the details of every data pass. Spend two minutes clicking around: a beginner gets as much out of it as a veteran.

The vocabulary of this Make.com tutorial fits in five words. A scenario is your complete automation. A module is one step: capture, add, send. The trigger is the first module, the one that fires things off. A router splits the flow into branches, and a filter decides whether a branch runs. That’s all it takes: you can already read a Make scenario.

On the account side, sign-up takes two minutes: an email address, a password, and an onboarding questionnaire you can skim through. The free plan starts immediately, with no commitment. Save the paid offer for later: this tutorial lives entirely in the free zone.

Step 2: prepare Tally and Google Sheets

On the form side, I’m sticking with Tally, the tool I cover in depth in my full Tally review. Create a simple form with three fields: name, email and message. The free version is more than enough to capture leads. Name your fields carefully: those labels become the variables Make displays in the mapping panel, and a clear form upfront saves guesswork downstream.

On the spreadsheet side, open a new Google Sheet named Leads. Create five header columns: Date, Name, Email, Message and AI Summary. This preparation, often rushed through in a typical Make.com tutorial, takes ten minutes and saves you back-and-forth during mapping. The spreadsheet becomes your lead database, with no subscription and no learning curve.

Step 3: wire up the Tally webhook

The heart of this Make.com tutorial starts here. In Make, click Create a new scenario. Search for the Webhooks module and choose Custom webhook. Name it, then copy the unique URL Make generates for your scenario.

Open your Tally form settings, webhooks section, and paste this URL. Submit a test response from the form, then confirm the data structure Make detects in the module. Your first automation just got a pulse: every Tally submission now lands in the scenario in real time.

Step 4: write every lead into Google Sheets

Add a second module: Google Sheets, Add a Row action. Connect your Google account, select the Leads spreadsheet and the target tab. Make then displays the columns detected in your sheet.

Mapping is done with the mouse: drag the Tally name variable into the Name column, the email into Email, the message into Message. Add the system date variable in the first column. One click on Run once, one test submission, and the row appears in the spreadsheet. It’s the most satisfying demonstration of this Make.com tutorial: your data flows without a single line of code.

Step 5: receive the instant email notification

Third module: Gmail, Send an Email action. Authorize the connection when the pop-up asks, then fill the recipient with your own address. The email subject line can reuse a variable: New lead from, followed by the mapped name field.

In the message body, map the message field and the lead’s email so everything is in view without opening the spreadsheet. This notification is the most visible deliverable of this Make.com tutorial: the request lands in your inbox a few seconds after the form is submitted. You read it over, you reply, you move on.

Step 6, the bonus: AI summarizes every request

Add a fourth module between the spreadsheet and the email: an AI module, for example OpenAI in Create a Chat Completion mode, or a built-in tool from the Make AI Toolkit. The prompt fits on one line: Summarize this incoming request in one actionable sentence, followed by the message field variable.

Map the module’s output into the AI Summary column of the spreadsheet, and into the notification body. Result: your alert email opens with a summary, not a wall of text. This module costs one extra credit per run, and it makes the scenario readable in three seconds. Almost all the entrepreneurs I coach keep this module once they’ve tried it.

Test, activate, monitor your credits

The final test of this Make.com tutorial comes down to three submissions. Hit Run once, send three test responses from Tally, and watch the bubbles above each module: they show the data flowing through. A red bubble flags where things jam, usually a badly mapped field. Fix it, run it again, then flip the scenario’s scheduling switch to ON.

With a webhook trigger, the scenario fires on every submission, with no waiting delay. Scheduled scenarios, on the other hand, respect the plan’s minimum interval: 15 minutes on the free plan, 1 minute from Core upward. Budget-wise, your scenario consumes 4 credits per submission with the AI module: the free plan covers roughly 250 leads per month, and your organization’s usage counter always displays the remaining consumption.

A word about the execution history: every run leaves a timestamped trace, module by module, with input and output data. When a notification fails to arrive, this is where you check whether the scenario actually ran. This quick read saves hours of debugging once you start chaining scenarios.

When your flows multiply and you want to host your scenarios yourself, other horizons open up: my N8N vs Claude write-up details the open-source alternative, but for a first automation, Make remains the most visual platform and the fastest to get the hang of.

Frequently asked questions about this Make.com tutorial

Is Make free in 2026?

Yes. The Free plan is still listed at $0 per month with 1,000 credits, the no-code visual builder, access to 3,000+ apps, plus routers and filters. For a beginner, the constraints boil down to two active scenarios and the 15-minute interval between scheduled runs. To follow this Make.com tutorial, the free tier is more than enough.

Make credits: what’s the difference with the old operations?

Make switched from operations to credits: every module action now consumes one credit, whether it is adding a Google Sheets row or sending an email. Plenty of content still cites 1,000 free operations, a leftover from the old pricing grid. The principle remains similar, but the official vocabulary has changed, and your dashboard counters now display credits.

How many credits does this tutorial’s scenario consume?

Four triggered modules amount to 4 credits per form submission: the webhook, the Google Sheets row, the Gmail email and the AI summary. Without the AI module, count 3 credits. With 1,000 free credits per month, the free plan absorbs roughly 250 complete leads, or 330 without the automated summary.

Do you need to know how to code to follow this Make.com tutorial?

No, and that’s the whole promise of no-code automation. Every step is configured with the mouse: pick a module, authorize a connection, map variables from one point to another. A complete beginner can assemble this scenario in one evening, and the official Make documentation details every module in case a setting escapes you.

Which plan should you choose when free is no longer enough?

The Core plan at $12 per month unlocks 10,000 credits, unlimited active scenarios and minute-level triggering. Pro at $21 adds priority execution, custom variables and full-text search across logs. Teams at $38 targets collaboration, with roles and scenario templates. For a solopreneur facing their workflows alone, Core covers several months of growth.

The final word

This Make.com tutorial boils down to one idea: a useful automation is worth a thousand demos. You have a form that captures, a spreadsheet that organizes, an inbox that alerts and an AI that summarizes, all without code and without exceeding the free plan. Automating repetitive tasks has never been this accessible.

The rest is up to you: duplicate the scenario for a second form, add a filter to sort urgent requests, try out a router. You progress in no-code automation by building, not by stacking theory. And if you put together a scenario you’re proud of, tell the story in the comments: I document mine, scars included.