If you want to know how to automate client onboarding with Make, the answer is one scenario that starts with a webhook from your intake form, then creates the Google Drive folders, copies template docs, creates the ClickUp project, sets up the Slack channel, logs everything to a Google Sheet and sends the welcome email. Each module passes IDs and links to the next. Add a router for package-specific steps and an error route that alerts you in Slack.
This is the same pattern I used on a live agency build that replaced about 40 manual setup steps with one form submission. Below is the full structure, module by module.
Before you open Make
A Make.com client onboarding scenario is only as good as the process it copies. Have these ready:
- A finished intake form with dropdowns for package, primary service and account lead
- A naming convention, for example "Acme Plumbing" for folders and projects
- Template documents in Google Docs with clear placeholders such as {{client_name}} written as plain text tags your team agrees on
- A Drive parent folder where client folders live
- A ClickUp space or folder and a task template for onboarding
- A Google Sheet client tracker with one column per field and link you want to store
- A test Slack channel and a test Drive folder
If you have not mapped the process yet, start with the marketing agency client onboarding process post, then come back.
How to automate client onboarding with Make: the scenario at a glance
Here is the order I use for a Make scenario onboarding build:
- Webhooks: Custom webhook (trigger)
- Data check: filter for required fields and a duplicate check against the tracker
- Google Drive: create the client folder
- Iterator or repeated modules: create subfolders
- Google Drive or Google Docs: copy template documents and fill placeholders
- ClickUp: create the project and onboarding tasks
- Slack: create the channel and post the summary
- Google Sheets: add the tracker row with every ID and link
- Email: send the welcome email
- Slack: notify the account lead
- Error handler route on the risky modules
Step 1: Start with a custom webhook
Use the Webhooks app and its Custom webhook trigger. Make gives you a URL. Point your form tool at it: most form tools, and GoHighLevel workflows, can post submissions to a webhook.
Send one real test submission so Make learns the data structure. Name your fields clearly in the form, because those names become the variables you map in every later module.
Right after the webhook, add a filter that stops the run if required fields are empty. Then add a Google Sheets search on the tracker for the client name or domain. If a row already exists, stop or route to an alert. This prevents duplicate workspaces when someone submits the form twice.
Step 2: Create the Drive folder tree
Use the Google Drive module that creates a folder, with your Clients parent folder as the destination and the client name as the folder name. Save the folder ID it returns.
For subfolders such as 01 Admin, 02 Brand, 03 Strategy and 05 Reporting, you have two options:
- Separate modules, one per subfolder. Simple to read and debug.
- An array plus an Iterator, which loops through a list of subfolder names. Tidier if you have many.
I usually use separate modules for five or six folders because anyone on the team can follow it.
Step 3: Copy and fill template documents
Use the Google Docs module that creates a document from a template. It lets you replace placeholder tags in the template with mapped values, such as client name, website, start date and account lead. Set the destination to the right subfolder ID from Step 2.
Typical documents to generate:
- Audit document
- Strategy and 90-day plan
- Kickoff agenda
- Meeting notes doc
For files that do not need placeholders, such as a spreadsheet template, use the Google Drive copy file module instead.
Step 4: Create the ClickUp project and tasks
The ClickUp app in Make has modules for creating tasks, lists and more. For onboarding I usually:
- Create a list or folder for the client inside the right space
- Create the onboarding tasks, either from a ClickUp task template or from an array of task names, with assignees set by package
- Put the Drive folder link and key intake answers in the description of the parent task
If a module you need is missing, the ClickUp app also offers a generic API call module, and ClickUp's public API supports creating items from templates. Check ClickUp's API documentation for the current endpoints before relying on one. I go deeper on this in ClickUp client onboarding template.
Step 5: Set up Slack
Use the Slack modules to create the client channel and invite the right team members. Then post a message with:
- Client name, package and start date
- Account lead and specialists
- Links to the Drive folder, the ClickUp list and the tracker row
- The top three goals from the intake form
That one message saves a lot of "where is the folder?" questions.
Step 6: Log everything to the tracker
Add a Google Sheets row with the client name, package, start date, account lead, Drive folder link, ClickUp list link, Slack channel ID, onboarding status and the scenario run date. This sheet becomes the source of truth for later automations like reporting and health monitoring.
Step 7: Send the welcome email and notify the lead
Send the welcome email through Gmail or your CRM, with the access checklist and kickoff booking link. Then send the account lead a direct Slack message saying the workspace is ready.
Use a router for package differences
If an SEO client needs a content folder and a PPC client needs an ad account audit task, add a Router after the shared steps. Each route has a filter on the package field and runs only the extra modules for that package. Keep shared steps before the router so you do not duplicate them.
Error handling for an automated onboarding workflow
Onboarding runs rarely, so silent failures are the real risk. In Make, you can attach an error handler route to any module. Make offers several directives, such as Retry (formerly Break), Skip (formerly Ignore), Resume, Commit and Rollback. A practical setup:
- On modules that call Google, ClickUp and Slack, add an error route that posts to a private ops channel with the client name, the module that failed and the error message.
- Use Retry (formerly Break) on steps you want Make to retry later, if incomplete executions are enabled in the scenario settings.
- Use Ignore only for truly optional steps, such as posting a welcome GIF.
Read Make's error handling docs for how each directive behaves, because the choice affects whether later modules run.
Test mode
Add a hidden field to the form, or a query parameter on the webhook, called test. When it is set, use filters or variables so the scenario writes to the test Drive folder, the test ClickUp space and the test Slack channel. Run at least three tests: one per package and one with deliberately missing data. In live builds I split live and test channels from the start.
Field mapping checklist
Before going live, confirm each mapping:
- Client name used consistently in folder, project and channel names
- Channel name cleaned to lowercase with hyphens, since Slack channel names have format rules
- Dates formatted the same way in every document
- Assignees mapped by role from a lookup, not typed by hand
- Every created ID and URL saved to the tracker
Operations and cost
Every module that runs uses operations or credits on your Make plan. An onboarding scenario with 20 to 30 modules runs only when a client signs, so usage is small for most agencies. Check Make's current pricing page for plan allowances, since they change.
How I build this
This is the core of what I deliver in the Agency Onboarding Engine: a Make scenario built on your accounts that turns one form into a ready workspace. On the live onboarding build, the workspace is ready in under two minutes and the build took five days. If you already have a scenario that half works, the Automation Rescue offer fixes it, or you can start with a free teardown.
FAQ
Can Make.com automate client onboarding?
Yes. Make can receive a form submission by webhook and then create Drive folders, fill Google Docs templates, create ClickUp tasks, set up Slack channels and log everything in Google Sheets in one scenario.
What trigger should I use for a Make onboarding scenario?
A custom webhook from your intake form is usually best because it carries all the client data. You can add a filter so the scenario only runs once a contract is signed or payment is confirmed.
How do I stop duplicate onboarding runs in Make?
Search your tracker sheet for the client right after the webhook and stop the run if a row already exists. Using a unique field, such as the client's domain, makes the check reliable.
Is Make better than Zapier for onboarding automation?
Both can do it. Make's visual routers and per-module error handling suit multi-branch onboarding well, while Zapier is simpler for short linear flows.