Name every step between a signed contract and the moment a new client can actually do something useful, and do it without opening your onboarding checklist. Try it out loud. The list runs longer than you expect, and every item on it is somebody’s afternoon: the shared folder, the kickoff brief, the CRM record, the welcome email, the invoice that nobody wants to be the one to send.
You are going to build that list once as software, then build it a second time on a different platform. The Zapier version catches an intake webhook and converts the messy part of the form into validated JSON. From there it creates the client’s folder and kickoff brief, writes the CRM record, and stops at a human approval step before anything contractual leaves the building. Then you rebuild the same run as a Make scenario with a real error route, and price both against monthly client volume.
What One Onboarding Run Contains
Start with the unit each platform bills you for, because the two are not comparable by name. In Zapier a workflow is a Zap, and you pay per task. Zapier counts a task for every successful action step, while triggers, Filter steps and Paths steps cost nothing. In Make a workflow is a scenario on a visual canvas, and you pay per credit, the unit Make previously called an operation. For the non-AI modules in this build, one credit covers one module run against one bundle of data.
One onboarding run here means one intake submission goes in, and one client comes out with a folder, a kickoff brief, a CRM record, and a welcome email that references all three. Anything contractual waits for a person to say yes.
Prerequisites
To build along, you need:
-
A Zapier Professional plan or higher, because webhooks, Paths, and the Human in the Loop approval step are all gated above Free and this build uses all three.
-
A Make account on any tier. The Free plan’s 1,000 credits per month cover testing, and the 15-minute scheduling floor never applies because the trigger here is an instant webhook.
-
An OpenAI API key, needed only for the Make build. Zapier’s built-in AI step runs without one.
-
A Google account with Drive and Docs connected on both platforms, plus a kickoff-brief document that uses
{{merge_field}}placeholders. -
A CRM you can write to. HubSpot, Pipedrive, or Airtable all work, as long as the CRM exposes a create-record action on both platforms.
-
An intake form that can POST JSON. Skip this if your form app has a native trigger on both platforms; the raw webhook is here so you can read the payload with your own eyes before you map a single field.
The Intake Payload That Starts Everything
Every client onboarding automation begins with a client intake form, and the shape of that submission decides how much work the rest of the workflow has to do. Typeform and Google Forms both post JSON, and so does a form you build inside Zapier Forms. Here is the payload this build expects. Save it as intake-sample.json in the directory you run curl from; the webhook test below and the staging checklist at the end both post this exact file:
{
"submitted_at": "2026-03-04T14:22:08Z",
"form_id": "client-intake-v3",
"contact": { "name": "Dana Ruiz", "email": "[email protected]", "role": "COO" },
"company": { "name": "Northgate Logistics", "domain": "northgate.io", "size": "11-50" },
"engagement": {
"type": "retainer",
"start_date": "2026-03-17",
"monthly_value_usd": 6500,
"scope_notes": "need the weekly carrier report automated, plus something for the driver check-in texts, ideally before our Q2 board meeting"
}
}
Only scope_notes is unstructured. Everything else is already typed by the form itself. The AI step gets the free-text field and nothing more, so it never has the opportunity to reformat an email address or round a dollar amount. That boundary holds through both builds.
Build the Onboarding Zap
The Zapier build is linear by design, which is its advantage here. Eight steps run in a fixed order from webhook to welcome email, with a single filter that stops bad data before it reaches anything the client can see.
Catch the Intake Webhook
Add Webhooks by Zapier as the trigger and choose the Catch Hook event. Zapier issues a URL; paste it into your form’s webhook setting, then push a real sample through it from your terminal:
curl -X POST https://hooks.zapier.com/hooks/catch/000000/abcdef/ \ -H "Content-Type: application/json" \ -d @intake-sample.json
Zapier flattens nested JSON on the way in, so engagement.scope_notes becomes a mappable field named engagement__scope_notes. Use Catch Hook rather than Catch Raw Hook unless you plan to parse the body yourself. The trigger costs no tasks, so you can re-test it as often as you need.
Turn the Scope Notes Into Structured JSON
Add an action step, search for AI by Zapier, and select it. There is no action event to choose here; the step opens straight into its Configure panel. Map engagement__scope_notes as the only input, then write a prompt that tells the model to pull the onboarding details out of that field and invent nothing.
The prompt alone will not give you anything to map. With no output fields defined, AI by Zapier returns one combined result, which the Filter in the next step cannot test and the welcome email cannot reference. Open Settings, expand Output Fields, and click + Add field once for each of the five below, giving every one a name and a field type. This is the shape those fields describe, not text you paste into the prompt:
{
"project_title": "string, 60 characters or fewer",
"deliverables": "one string, deliverables separated by commas",
"first_milestone_date": "YYYY-MM-DD",
"risk_flags": "one string, flags separated by commas",
"welcome_paragraph": "two sentences, no pricing, no dates"
}
Check Is this output field required? on project_title and first_milestone_date. Those are the two the Filter gates on in the next step, and marking them required is what stops the model from quietly dropping a key. Put the constraints in each field’s description: welcome_paragraph forbids pricing and dates, so an invented number can never reach a client inbox.
Two of those keys hold more than one value, and that is where builders get stuck. Zapier documents the Field type control but publishes nothing about the options inside it, so do not design the step around a type you have not seen in your own dropdown. Describe deliverables and risk_flags in their field descriptions as a single string with the values separated by commas, and pin the risk vocabulary there too: scope_creep, tight_deadline, unclear_owner, nothing else. Anything downstream reads that string with the (Text) Contains rule, which Zapier documents for both Filter and Paths steps and which is not case-sensitive. A rule reading risk_flags (Text) Contains tight_deadline fires whether the model returned that one flag or all three.
Warning: The scope notes your client typed are client data. Before you send that field to any model, confirm which provider processes it and what your engagement letter promises about third-party processors.
Model tier changes the bill, not just the quality. AI by Zapier charges by tier: Standard costs 1x tasks, Advanced 3x, Premium 5x, with the formula (1 × model rate) + (number of tool calls × model rate). This step needs no tools, so Advanced costs three tasks per run.
Gate the Run on the Schema
Add a Filter step immediately after the AI action. Continue only when project_title exists and first_milestone_date is not empty. Filters never consume tasks, so this gate is free insurance.
Without it, a model that returns a partial object still lets the run proceed, and the failure surfaces as a kickoff brief with a blank project title sitting in the client’s folder. You find out when they reply asking what it is.
Fan Out to Folder, Brief, and CRM
Google Drive → Create Folder makes the client’s directory and returns a shareable link. Google Docs → Create Document from Template copies your brief and fills the moustache placeholders from the AI output. Your CRM’s create-record action writes the company, contact, and engagement value. Each of those three actions costs one task.
The Create Document from Template dropdown lists only Google Docs you created yourself, not the stock templates Google ships, and hunting for a file that never shows up there costs people an hour. If your brief is missing from the list, it is because Zapier only shows documents you created. Make your own copy of the file in your Drive and select that.
Pause Before Anything Contractual
Add Human in the Loop → Request Approval. The Zap run stops here and notifies a reviewer by email or Slack with the AI-generated brief attached for review.
Set Timeout to something shorter than your actual response time, then choose deliberately between Skip and continue and End run. Skip and continue means an unanswered request still sends the welcome email; End run means a client who signed on Friday hears nothing until Monday. Approved fields arrive downstream labeled Submitted Content {field name}, and anything the reviewer changed arrives as a separate Edited Content {field name} field. On a Professional plan you can only route requests to yourself, which is enough for testing but not for a team.
Send the Welcome Email
The final Gmail step maps three things: the AI welcome_paragraph, the Drive folder link, and the kickoff brief URL. That is welcome email personalization with no template variables left dangling, because the filter already proved they exist.
Counting tasks for the whole run: three for the AI step, one each for Drive, Docs, CRM, approval, and Gmail. Eight tasks per client, as the step list below shows.
Rebuild the Same Workflow in Make
The Make version does the same work with two differences that matter: you control the AI request body directly, and a failing module hands its bundle to a dedicated error route while the rest of the run finishes. Build it as a new scenario on a blank canvas.
Start With a Custom Webhook
Add Webhooks → Custom webhook, click Add, name it, and copy the URL. Send the same sample payload with curl while the module is listening, and Make derives the data structure from what arrives.
When your form later gains a field, that structure does not update itself. Click Re-determine data structure and re-send a sample, or the new field will never appear in the mapping panel. Make’s webhook documentation covers the distinction between custom webhooks and app-specific instant triggers.
Force the AI Step to Return Your Schema
Make’s OpenAI modules do carry an output format selector, so this is not a missing feature you are routing around. Use HTTP → Make a request anyway, because it hands you the whole response_format object rather than a dropdown, including strict: true and additionalProperties: false, and it keeps the exact payload readable. Point it at the Chat Completions endpoint with this body:
{
"model": "gpt-4.1",
"messages": [
{ "role": "system", "content": "Extract onboarding fields from the notes. Never invent dates or amounts." },
{ "role": "user", "content": "{{1.engagement.scope_notes}}" }
],
"response_format": {
"type": "json_schema",
"json_schema": {
"name": "onboarding_brief",
"strict": true,
"schema": {
"type": "object",
"properties": {
"project_title": { "type": "string" },
"deliverables": { "type": "array", "items": { "type": "string" } },
"first_milestone_date": { "type": "string" },
"welcome_paragraph": { "type": "string" }
},
"required": ["project_title", "deliverables", "first_milestone_date", "welcome_paragraph"],
"additionalProperties": false
}
}
}
}
strict: true binds the model to the schema at decode time. required must list every property, and additionalProperties: false blocks extra keys; OpenAI’s structured outputs guide requires both. The model value has to be one that supports strict schemas, so check that guide before you paste a model name. And a schema-valid response can still be a refusal, so read the refusal field before you trust content.
The two builds diverge on purpose at deliverables: it is a real array here because OpenAI’s guide lists Array among the supported structured-output types, while the Zapier version carries the same values as comma-separated text.
Route the Valid Runs and Park the Rest
Add a Router after the JSON parse. The first route filters on project_title existing and carries on to Drive, Docs, CRM, and Gmail. The second route catches everything else and writes the raw bundle to a Data Store with the parse error attached.
Count modules, not visual steps, when you price this: every module that touches a bundle costs a credit. The parked route costs one credit and turns a malformed submission into a row you can open and read.
Hand the Approval to a Second Scenario
Make has no approval pause on any plan you would actually buy for this build. It does publish a Human in the loop app, but that one is Enterprise-only and still in closed beta, so split the workflow rather than faking a pause with a sleep. Scenario A ends by sending the reviewer a message containing an approve link that points at Scenario B’s custom webhook, with the Data Store record ID in the query string. Scenario B fetches that record and sends the contract and first invoice.
The split earns its keep. The money and legal path gets its own execution history and its own error route, so a failed invoice never shows up as a failed onboarding, as you can see in the canvas below.
Zapier Tasks Versus Make Credits
Now price the same run on both platforms. The Zapier build consumes eight tasks per client. The Make build consumes roughly twelve credits per client: eight modules in Scenario A including the approval notification, and four in Scenario B.
The Bill at 10, 50, and 200 Clients
Multiply those per-run figures by monthly volume and the two pricing models separate immediately.
| Clients per month | Zapier tasks | Make credits | What that clears |
|---|---|---|---|
| 10 | 80 | 120 | Under Zapier’s 100-task Free cap, but this build needs Professional anyway; well inside Make’s 1,000-credit Free tier |
| 50 | 400 | 600 | Professional’s entry tier of 750 tasks; Make Core’s entry tier of 10,000 credits |
| 200 | 1,600 | 2,400 | Above Professional’s 750-task tier, so you buy a larger task tier; still inside Make Core’s 10,000 credits |
Illustrative: task and credit counts derived from this build’s step list, not from vendor benchmarks.
Reality Check: The AI step is 37.5 percent of the Zapier run’s task cost on the Advanced tier. Drop it to Standard and the same workflow costs six tasks.
Where the Cost Curve Bends
Volume moves you up Zapier’s price ladder, because every paid Zapier tier sells you a specific task count. Volume barely moves you on Make, because every paid Make plan starts at 10,000 credits; there you climb tiers to unlock features. Custom variables and full-text execution log search begin at Pro.
List prices at the entry tiers, read from each vendor’s own page: Zapier Professional starts at $29.99 per month billed monthly, or $19.99 billed annually, at 750 tasks, per Zapier’s published plan pricing. Make Core starts at $16 per month billed monthly, or $12 billed annually, at 10,000 credits; Pro is $28 billed monthly, or $21 billed annually. Both vendors sell volume in fixed steps, so price your exact tier before committing.
Handle the Failures That Actually Happen
Total outages announce themselves. The run that creates the folder, writes the CRM record, and then dies on the CRM’s rate limit leaves a client half-onboarded with no alert anywhere.
Make: Retry, Then Fix the Bundle
Right-click the module most likely to fail and choose Add error handler, then attach the Retry error handler. Retry pulls the failing bundle out of the flow, stores it as an incomplete execution, and lets the remaining bundles finish.
Retry needs Store incomplete executions enabled in scenario settings, and that is a scenario-level toggle, not a module-level one. Set the number of attempts and the interval between them; Make’s own example is three more tries at fifteen-minute intervals. Make already auto-retries RateLimitError, ConnectionError, and ModuleTimeoutError once incomplete executions are on. Do not reach for Rollback here: it only reverses database-style actions, and it cannot unsend the welcome email. On the canvas the handler appears as a second route off the module, drawn as a transparent, dotted connection, as the screenshot below shows.
Zapier: Autoreplay Costs Tasks and Hides the Failure
Autoreplay is a setting you turn on account-wide or per Zap, on every plan including Free, and it replays a failed step up to five times, with the last attempt landing roughly ten and a half hours after the first error. While it is retrying, Zapier sends no error email, so a broken CRM connection stays quiet most of a working day.
The two replay modes behave differently, and mixing them up will cost you. Autoreplay and manual replay from Zap history never touch Filter and Paths steps at all. Replaying an entire run from the Zap editor does the opposite: it re-charges the actions that already succeeded and re-runs your Filter and Paths steps against the currently published Zap. Order your steps around that split.
Pro Tip: Put the welcome email last, after the approval step. A whole-run replay re-executes earlier actions. You can delete a duplicate Drive folder quietly; a duplicate welcome email costs you an apology.
Test It Before a Real Client Signs
Run this sequence against a staging copy before you point the production form at anything:
-
POST
intake-sample.jsonto the staging webhook withcurl, then run the Make scenario once and confirm every downstream field maps. -
Use a company domain you control so the welcome email lands in your own inbox.
-
Send
scope_notesas an empty string. The Zapier Filter or the Make router should stop the run; a blank kickoff brief in Drive means the gate is wrong. -
Approve one request, then decline another. Confirm the declined path leaves no orphan CRM record behind.
-
Open the Zap run in Zap history or read Make’s execution log, take the actual task and credit count for the run, and multiply by your real monthly volume.
Roll back by deleting the test folder, the generated doc, the CRM record, and the Data Store row. Leave the Zap run itself in history; its task count is the only real measurement you have before a paying client arrives.
Zapier or Make, and How To Move Between Them
Your app list and your branch count settle this, and the two builds you just walked through show why.
-
Pick Zapier when your stack includes a niche app that only Zapier connects to. A native approval step and a readable linear step list matter too, especially if the person who inherits this from you would rather not learn a canvas.
-
Pick Make if the run branches more than twice, or if you need the raw request body for API calls like the structured-output one above. High monthly volume pushes the same way, because per-task billing stings once you are onboarding a few hundred clients a month.
You do not have to pick once and live with it. Bridge the two with webhooks: a Webhooks by Zapier POST action can hand a payload to a Make custom webhook mid-run, and a Make HTTP module can hand it back. Migrate the AI and branching logic to Make first, leave the niche app actions in Zapier, and cut over one section at a time. If you would rather have someone map your existing process before you build it twice, Adam works on exactly this kind of business process automation.
Where To Take This Next
You now have a client onboarding automation that validates its own AI output, stops for a human before money or contracts move, and recovers from the mid-run failures that used to strand a client between the folder and the welcome email. The reusable shape underneath is a typed intake payload that feeds a schema-bound AI step, with approval broken out onto its own path. Swap the form and the templates and the same shape covers vendor intake or employee onboarding.
The tight_deadline flag is already in your schema and currently goes nowhere. Fix that first:
-
Add a
risk_flagsbranch that pings you in Slack when the model tags an engagement astight_deadline. In Zapier that is a Path carrying one rule,risk_flags(Text) Containstight_deadline; in Make it is a second router route testing the same string. Zapier’s guide to conditional logic covers the branching side. -
Set a calendar reminder to re-read your actual task and credit consumption after thirty real clients. The estimate in the table above is arithmetic; your invoice is the measurement.
