How to Automate Client Onboarding (Without Code)

All posts

A client signs on Friday afternoon. Everyone is pleased. The invoice goes out Monday, someone remembers the intake form on Tuesday, the kickoff call gets scheduled for Thursday, and the client receives their first real email from you on Wednesday of the following week.

Nothing went wrong. No one dropped anything. That is just how long it takes when twelve steps live in four people's heads.

This article breaks client onboarding into its actual steps, shows which ones can run without a person, and gives you a checklist you can copy. No developer required.

What client onboarding actually looks like in most agencies

Ask three people at the same agency to describe onboarding and you get three different answers. Written down, it is usually twelve steps:

Contract signed and countersigned
First invoice raised and sent
Client record created in the CRM
Folder structure created in the drive
Project created in the project tool
Shared channel opened
Intake form sent and chased
Access requested to the client's platforms
Internal team introduced and roles assigned
Kickoff call scheduled and prepared
First-week task list built
Status visible to whoever asks

Three or four people touch this. Most of it is copying information that already exists somewhere into somewhere else. And almost none of it starts until a human remembers it should.

Where onboarding actually breaks

"It takes too long" is not a useful diagnosis. Here is what actually goes wrong, in the order you will recognise it.

Access is never requested. Work starts, someone needs the ad account, and now you are three days into the engagement asking the client for a login. It looks disorganised because it is.

The intake form comes back half empty. Nobody checks it until the kickoff call, and then the call gets spent collecting information instead of planning work.

Tasks are created after the work starts. The project tool catches up with reality rather than driving it.

Nobody knows which step the client is on. The founder asks, the account manager checks four tools, and the answer takes twenty minutes to assemble.

Each one is small. Together they are the difference between a client who feels handled and a client who is already wondering.

What you can automate today, and what you cannot

An honest split, because half the articles on this topic imply you can automate the whole thing.

Can be automated: creating the client record, the folder, the project and the channel; sending the intake form and chasing it; sending the contract and the first invoice; requesting platform access; building the standard task list; notifying the team; drafting the welcome email; tracking and reporting status.

Should not be automated: the introductions between your people and theirs; anything about non-standard commercial terms; the strategy conversation on the kickoff call; and the decision about what to do when a client's situation does not match the template.

The useful line is not technical. It is whether the step involves a judgment two reasonable people would make differently. Those stay human. Everything else is copying, and copying is what software is for.

Build the process step by step

Step 1. The trigger: contract signed

The process should start from one event, and the signature is the natural one. Most e-signature tools can notify another system when a document completes. Everything downstream then stops depending on somebody remembering. Who owns it: nobody. That is the point.

Step 2. Collect what you need from the client

One intake form, sent automatically on signature: company details, billing contact, the platforms you will need access to, brand assets, and the two or three things specific to your service. Automate the chase as well as the send. A reminder at day two and day four removes the most common source of delay, which is not the client refusing but the client forgetting. What the system does instead of a person: sends, reminds, and flags when required fields are still missing 48 hours before the kickoff call.

Step 3. Create the workspace

Client record in the CRM, folder structure in the drive, project in the project tool, shared channel. Same structure every time, built from a template. This is the most mechanical step in the process and usually the one that eats an afternoon. It is entirely rules-based, which means it should never be done by hand again. What the system does instead of a person: all of it.

Step 4. Access and owners

Automate the request and the tracking. Do not automate the handling of credentials themselves: those should go into your password manager by the client's own hand, not through a workflow. Assign the internal owner for each part of the account at this step, not later. An account with no named owner for the reporting is an account where reporting will be late. What the system does instead of a person: requests access, tracks what is still outstanding, reminds both sides.

Step 5. The kickoff call and the first week

The call gets scheduled automatically once the intake form is complete. The agenda is drafted from what the client actually wrote, not from a generic template. The first-week task list is built from the scope. If you sell three or four service types, you have three or four task templates, and the right one gets selected based on what was sold. This is the first step where a rule alone is not enough. A scope that says "SEO retainer, plus paid social from month two" does not map cleanly onto one template, and someone has to read it and decide. This is the point where rules-based tools hand the work back to a person, and it is the reason the agent platform category exists at all. What stays human: the conversation itself. Automating the preparation is what buys you the time to have a better one.

Step 6. Notify the team and track status

One message to the team with everything they need: who the client is, what was sold, what is needed by when, who owns what. Not fourteen separate notifications from six tools. And a single place where anyone can see which step each client is on, without asking. What the system does instead of a person: assembles the summary and keeps the status current.

The trigger is the easy part

It is worth being clear about what the signature actually buys you, because "when X happens, do Y" is where most automation projects both start and stop.

Starting on its own solves the forgetting problem. It does not solve any of the others. A process that runs still has to know where each client got to, hold the steps that need a person, tell you when something failed rather than finishing quietly, and belong to the team rather than to whoever built it.

That is the difference between an automation and a process you can actually run a business on, and it is where the work is.

Doing this without code

What this actually requires from your team is less technical than people expect and more organisational than they hope.

What you need before you start: one agreed version of the process, one intake form everyone uses, and one named owner per step. If three account managers currently do onboarding three different ways, fix that first. Automating an inconsistent process just makes the inconsistency faster.

How long it takes: plan for weeks rather than days, and expect most of that time to go on agreeing internally what the process is rather than on configuring anything.

What you build it on: a rules-based automation tool such as Zapier, Make or n8n will handle the mechanical steps well. Where they stop is the judgment ones, like reading a half-completed intake form and working out what is missing, or picking the right task template from a non-standard scope. Platforms like Asuri handle those steps by having agents perform them inside the process, and sensitive actions pause for human review before they take effect.

The honest caveat: whatever you build, someone owns it. APIs change, forms change, tools get replaced. Write down what the process does, where it runs, and who fixes it.

The 12-step client onboarding checklist you can copy

Print this, or paste it into your project tool as a template.

Contract signed. Triggers everything below. Owner: automated.
Invoice raised and sent, from the contract value. Owner: automated, finance notified.
Client record created in the CRM, populated from the contract. Owner: automated.
Intake form sent within one hour of signature. Owner: automated.
Workspace created: folder, project, channel, from template. Owner: automated.
Access requested, with the list generated from the services sold. Owner: automated, client actions.
Intake form complete, chased at day two and day four, flagged if gaps remain. Owner: automated, account manager escalates.
Internal owners assigned, one named person per workstream. Owner: account manager.
Kickoff call scheduled once the form is complete. Owner: automated.
Kickoff agenda drafted from the client's own answers. Owner: automated, account manager reviews.
Welcome email sent: drafted automatically, sent by a human. Owner: account manager approves.
First-week tasks live, from the scope template. Owner: automated, project manager adjusts.

Nine of the twelve run without a person. The three that need one are the three that involve judgment, and that split is worth keeping deliberately: the value is not in removing people from the process, it is in removing them from the copying.

Where the twelve steps sit across several tools, the practical difficulty is that nobody can see the whole thing at once. That is the problem Asuri is built around: the task, the agents responsible for it, the tools, the approvals and the outcome stay connected in one visible workflow rather than spread across four systems.

How to tell it is working

Three numbers, tracked from the month before you start:

Days from signature to work starting. The headline number, and the one clients feel.
Share of clients with a complete intake form before the kickoff call. This is the leading indicator. Fix this and the first number moves on its own.
Manual actions per client. Count them once by hand, before you automate anything. It is usually a larger number than anyone expects, and it is the one that tells you whether the work paid off.

FAQ

How long should client onboarding take? From signature to work starting, two to three days is a reasonable target for a standard engagement. Done manually it usually takes considerably longer, and the wait is almost always the intake form and platform access rather than the work itself.

What should be in a client onboarding process? At minimum: a trigger, an intake form, a created workspace, an access request, assigned owners, a kickoff call, a first-week plan, and a visible status. The twelve-step checklist above expands each of these.

Can you automate onboarding without a developer? Yes, for most of it. The mechanical steps run on standard automation tools with no code. The steps involving judgment need either a person or an agent platform. What you cannot skip is the organisational work of agreeing on one version of the process first.

What should not be automated in client onboarding? Introductions, non-standard commercial terms, the strategy conversation, and anything where the client's situation does not match your template. Automating those produces a worse experience than doing nothing.

Ready to automate your client onboarding?

Build a workflow that keeps every step, agent, approval, and handoff connected in one place.

Get early access →