Best Make.com Workflow for Form Submissions to CRM

Every web form submission is a moment of intent — someone raising their hand and saying they want to work with you. What happens in the next five minutes determines whether that intent converts into a relationship or evaporates into a folder of unread notification emails. Most small business owners handle form submissions the same way: the form sends an email, the email goes into a general inbox, and at some point today or this week someone reads it and manually enters the data into a spreadsheet or CRM. That gap — between submission and action — is where leads go cold and opportunities disappear. Make.com closes it. Here’s how to build the workflow that handles every submission automatically, routes it to the right place, and ensures nothing gets missed.

Why Make.com Works Better Than Zapier for This Use Case

Both Make and Zapier can connect web forms to CRM tools. The reason Make is worth choosing specifically for form-to-CRM workflows is its native Router module. In Zapier, if you want to send a form submission to different destinations based on the service requested — say, consulting inquiries go to one ClickUp list while product demo requests go to another — you need separate zaps with filters or a multi-step path add-on. In Make, the Router handles all branching logic inside a single scenario, with as many branches as you need and conditional filters on each one.

Make also handles data transformation more elegantly. Form submissions frequently arrive with inconsistent formatting — phone numbers with or without dashes, names in all-caps, dropdown values that don’t match your CRM’s field options exactly. Make’s built-in functions let you clean and transform that data before it reaches your CRM, inside the same scenario, without a separate step or tool.

For solopreneurs running on tight budgets, Make’s free plan covers 1,000 operations per month — enough to handle a meaningful volume of form submissions before you need to upgrade. Zapier’s free tier limits you to 100 tasks and single-step zaps, which won’t cover most real-world form-to-CRM scenarios.

Step 1: Choose Your Form Tool and Trigger Method

Make connects to form submissions in two ways: native app integrations and webhooks. Which one to use depends on your form tool:

• Typeform: Native Make module — connects directly, triggers on new submission, maps all fields automatically.
• Tally: Webhook — Tally sends submission data to a Make webhook URL you provide. Fast, reliable, and Tally’s free plan is generous.
• Jotform: Native Make module available; webhook also works.
• Google Forms: No native Make module — use a webhook via the Forms publisher add-on, or trigger via a Google Sheets row-added event if you’re logging responses there.
• Gravity Forms / WPForms (WordPress): Webhook — both support webhook notifications on submission.
• Notion forms (third-party): Webhooks via tools like Fillout or NotionForms, which post submission data to Make directly.

For most solopreneurs, Tally + Make webhook is the fastest setup and requires no paid plans on either side. Build your form in Tally, copy the Make webhook URL into Tally’s integration settings, and your trigger is live in under five minutes.

Step 2: Parse and Clean the Submission Data

The first module after your trigger should be a Set Variables or Tools > Set Multiple Variables module where you define clean versions of each field you’ll use downstream. This is the data transformation layer — where you standardize what came in before anything gets written to your CRM.

Common transformations worth handling here:

• Name formatting: Use Make’s capitalize function to ensure names aren’t stored in all-caps or all-lowercase regardless of how the user typed them.
• Phone number standardization: Strip non-numeric characters with a replace function so all phone numbers land in your CRM in a consistent format.
• Email lowercasing: Apply lower to email addresses to prevent duplicate records from the same person submitting with different capitalization.
• Date formatting: If your form captures a date, convert it to your CRM’s expected format using Make’s formatDate function.
• Service type mapping: If your form dropdown options don’t match your CRM’s field values exactly, map them here — “Website Design” → “Web” — so the Router’s filters work cleanly.

Step 3: Add the Router for Conditional Branching

The Router module is where Make earns its advantage. After your data cleaning step, add a Router and configure a branch for each destination or condition you need:

Example: Service-Based Routing

A freelance agency’s contact form collects a “Service Interested In” dropdown. The Router sends each submission to the right place based on the answer:

• Branch 1 — Strategy Consulting: Filter: Service = “Strategy” → Create record in Airtable “Consulting Leads” table → Assign to founder → Send Slack notification to #strategy-leads
• Branch 2 — Done-For-You Services: Filter: Service = “DFY” → Create task in ClickUp “DFY Intake” list → Set priority to High → Send email confirmation to submitter
• Branch 3 — Course or Product: Filter: Service = “Course” → Create record in Airtable “Product Leads” table → Add to email marketing sequence via Mailchimp module
• Branch 4 — Catch-all: No filter (always runs) → Send email to owner inbox with full submission data for manual review

The catch-all branch is important — it ensures that submissions with unexpected or missing values don’t disappear silently. You always want a fallback that surfaces unrouted submissions for human review.

Example: Lead Quality Routing

An intake form asks for estimated budget. The Router splits on that field:

• High-value: Budget ≥ $5,000 → Create ClickUp task with High priority → Send immediate Slack DM to owner
• Mid-range: Budget $1,000–$4,999 → Create Airtable record → Add to standard follow-up sequence
• Below threshold: Budget < $1,000 → Send templated email with self-serve resources → Log to Airtable for reporting only

Step 4: Write to Your CRM

Each branch ends with a module that creates or updates a record in your destination tool. Here’s how the setup looks for the three most common targets:

Routing to Airtable

Use the Airtable > Create a Record module. Map each form field to the corresponding Airtable column — Name, Email, Phone, Service, Budget, Submission Date, Notes. Set the Submission Date field to Make’s now function so every record is timestamped automatically.

Before the create step, add an Airtable > Search Records module that checks whether a record with the same email already exists. If it does, route to an Airtable > Update a Record module instead of creating a duplicate. This deduplication step is one of the most valuable additions to any form-to-CRM scenario and takes about three minutes to configure.

If you haven’t built your Airtable lead tracker yet, the step-by-step Airtable lead tracker guide walks through the base structure that works best as the destination for this kind of automation.

Routing to Notion

Use the Notion > Create a Database Item module. Select your Contacts or Leads database and map each field. Notion’s property types matter here — a text field in Make needs to go to a Text property in Notion, a date to a Date property, and a select value needs to match one of your existing Select options exactly or the module will error.

Notion doesn’t have native deduplication via Make’s module, so use a Notion > Search Objects step first, filtering by email address, to check for an existing record before creating a new one. For a deeper look at structuring Notion as your primary CRM, using Notion for client project management covers the database architecture that makes these automations most effective.

Routing to ClickUp

Use the ClickUp > Create a Task module. Map the submission fields to task name, description, and custom fields. Set the task’s List based on the routing branch — different service types land in different Lists within your CRM space. For a fully built-out ClickUp CRM structure that this automation slots into cleanly, the freelancer CRM in ClickUp guide covers the List and custom field setup.

CRM Destination Comparison for Make.com Form Workflows

Step 5: Notifications and Confirmation Emails

Every form-to-CRM scenario should end with two notification steps — one internal, one external:

Internal notification: A Slack message or email to you (or your team) with the key submission details and a direct link to the newly created CRM record. Don’t make yourself hunt for the record — the notification should contain name, email, service requested, budget, and the CRM link in one message.

External confirmation: An automated email to the submitter confirming receipt and setting expectations for next steps. Use Make’s Gmail or Email module to send a templated message with the submitter’s name pulled from the form data. A simple “Thanks [Name], we received your inquiry about [Service] and will follow up within 24 hours” does more for conversion than most follow-up sequences — because it arrives immediately while the person is still in buying mode.

Frequently Asked Questions

Do I need a paid Make plan to build this workflow?

The free Make plan covers 1,000 operations per month. A single form submission through this scenario uses approximately 6–10 operations depending on how many modules you’ve added (trigger, router branches, deduplication check, CRM write, notification, confirmation email). At that rate, the free plan handles 100–160 submissions per month before you’d need to upgrade. The Core plan at ~$9/month raises that to 10,000 operations — sufficient for most small business intake volumes.

What’s the best form tool to use with Make.com?

Tally is the strongest free option — webhook integration is straightforward, the form builder is capable, and the free plan has no submission limits. Typeform is the best paid option if you need conditional logic within the form itself and want a polished respondent experience. For WordPress sites, Gravity Forms with the webhook add-on is the most reliable option. Avoid Google Forms as a Make trigger if possible — the workarounds (Sheets trigger or publisher add-on) add fragility that webhook-based tools don’t have.

Can I route the same submission to multiple CRM tools simultaneously?

Yes — Make’s Router can send to multiple branches in parallel, or you can add multiple modules in sequence after a single branch. A common pattern is writing to Airtable for your internal CRM and simultaneously adding the contact to a Mailchimp audience for email marketing — both happen in the same scenario run, triggered by a single form submission. Just be aware that each module adds to your operation count for that scenario run.

How do I handle file uploads in form submissions?

If your form collects file uploads (a brief document, a portfolio PDF, a logo), Make can access the file URL from the submission data and either pass that URL as a field value in your CRM or download the file and upload it to Google Drive or Dropbox using the respective Make modules. Airtable supports attachment fields natively — you can pass the file URL directly to an attachment field and it will appear as a linked attachment in the record.

What’s the difference between using Make versus Zapier for this workflow?

For a simple one-form-one-destination workflow, the tools are comparable and the choice mostly comes down to which interface you prefer. Make’s advantage becomes clear when you add conditional routing (Router module), data transformation (built-in functions without needing a Formatter step), or multi-step error handling — all of which require additional paid steps or separate zaps in Zapier. Make also runs scenarios on a visual canvas that makes complex workflows easier to read and debug. For anything beyond a two-step form-to-CRM connection, Make’s architecture handles the complexity more cleanly.