Building a Simple Automation: From Form Submission to Team Notification

A lot of small business workflows follow the same basic shape: someone fills out a form, that information needs to end up somewhere organized, and someone else needs to know about it — ideally without a person manually moving it from one place to the other every time.

This post walks through a small automation I built to handle exactly that: a Google Form connects to a spreadsheet, applies some basic logic to sort responses, and sends notifications via Slack and email. It’s a simple system, but it’s a good example for understanding how these pieces fit together — and where the “simple” part stops being simple.

What this automation does

This automation connects four common tools:

• Google Forms – where someone submits their info
• Google Sheets – where the responses are stored
• Email – to notify or alert based on the form data
• Slack – to notify the team in real-time

Once set up, the flow is: a form gets submitted → the response is logged in a spreadsheet → depending on what was submitted, a notification goes to Slack and/or email. No manual step in between.

🧩 How It’s Built (Step-by-Step)

Step 1: The trigger — watching for form submissions

(AKA: “Wake up, something happened!”)

Every automation starts with a trigger—the event that kicks everything off. In this case:

• A lead fills out a Google Form (because it’s free and easy).
• Make.com (formerly Integromat) watches for new responses like a digital watchdog.

How I Set It Up:

1. I picked Google Forms as my trigger.
2. Selected “Watch Responses” (so it triggers every time someone submits).
3. Connected my Google account (so Make.com can peek at my forms).

Pro Tip: If you’ve ever given an app permission to access your Google Drive, this is the same thing—just saying, “Hey, Make.com, you can read my form responses. Cool? Cool.”

---

Step 2: Storing responses in Google Sheets

Now that we’ve caught a new lead, we need to store it somewhere useful. Enter: Google Sheets.

How I Made It Happen:

1. Added a Google Sheets “Add a Row” action.
2. Mapped form fields (name, email, budget, etc.) to spreadsheet columns.
3. Made sure duplicates don’t sneak in (because nobody likes spammy spreadsheets).

Example:
If “John Doe” submits the form, his details auto-fill into my “Leads” sheet. If he submits again? The system updates his existing row instead of creating a duplicate.

---

Step 3: Categorizing responses — and where this needs judgment

This is the step where automation starts making decisions, not just moving data — and it’s worth slowing down here.

In this setup, an “If” condition checks a field like budget and assigns a category:

• Budget above a certain threshold → “High Priority”
• Mid-range → “Follow Up Later”
• Below a minimum → marked as lower priority

Example:

1. Used an “If” function to check the lead’s budget.
   • If budget = “$1,000+” → Mark as “High Priority.”
   • If budget = “$100−$1,000” → Mark as “Follow Up Later.”
   • If budget = “<$100” → Mark as “Rejected.” 
2. Added a checkbox in Google Sheets to track who’s been contacted.

The useful way to think about this step isn’t “the system decides who matters” — it’s “the system does a first pass, so a person’s attention goes to the right place first.” The categorization is a sorting mechanism, not a verdict.

---

Step 4: Notifications — and a note on notification design

Once a response is categorized, it can trigger a Slack message (for the team) and/or an email (for a more persistent record). Mapping the relevant fields — name, email, category — into the Slack message means whoever’s on call doesn’t need to open the spreadsheet to see what came in.

Example:

1. Slack Notification:
   • Every new high-budget lead triggers a Slack message in my team’s channel.
   • Includes name, email, budget, and website for quick follow-up.
2. Email Alert:
   • Sends me a plain-text email with lead details (because HTML is overkill).

Bonus: If a lead hasn’t been contacted in 24 hours, the system reminds me via Slack. No more forgotten follow-ups!

---

Step 5: Error handling

APIs occasionally fail — a Google Sheets request might get rate-limited, for instance. A basic safety net handles this gracefully:

• If a step fails, wait a short period (e.g., 15 minutes) and retry.
• Limit retries (e.g., 3 attempts) before giving up.
• If it still fails, send a notification so a person knows something needs attention.

This is a small addition, but it’s the difference between a workflow that fails silently — where a submission just disappears — and one where a failure is at least visible.

---

Final Result: A Fully Automated Lead Machine

(AKA: “I just saved 10 hours a week.”)

✅ Leads auto-fill into Google Sheets.
✅ High value leads get flagged instantly.
✅ Slack/email alerts keep me in the loop.
✅ Errors get handled gracefully.

What You Can Do with This:

• Sales teams: Never miss an important lead again.
• Agencies: Automate client inquiries.
• Small businesses: Ditch manual data entry forever.

---

If you want to try this yourself

I’ve put together the full Make.com blueprint — modules, connections, and logic — here: Explore the full blueprint. For background on how Make.com’s modules and connections work more generally, their own documentation is a solid reference: Make.com Help Center.

---

A few practical questions

Can I use Airtable instead of Google Sheets? Yes — the Google Sheets module can be swapped for an Airtable module with minimal changes. The logic stays the same; only the destination for the data changes.

Is Make.com free for something like this? There’s a free tier with usage limits, which is enough for low-volume use. Higher-volume workflows (more form submissions, more operations per month) generally need a paid plan.

How do I set up Slack notifications specifically? Add a Slack module in Make.com, connect it to your workspace, choose the channel, and map the relevant fields from the form response into the message text.

Closing thought

What I keep coming back to with these small workflows is that the “automation” part is almost always the easy part. Connecting a form to a spreadsheet to a notification is a few hours of setup, at most. The part that actually requires thought is everything upstream of the mechanics: what should count as “high priority,” how often a notification should fire before it becomes noise, what happens when something goes wrong silently.

That’s been true of every system I’ve built and written about here — the tools handle the moving parts well. The decisions about what those parts should actually do are still the interesting problem, and they’re the part no automation platform can do for you.