A client onboarding process is the repeatable sequence an agency runs to take a signed client from contract to active work: collect access and context, run a kickoff, agree on scope and a communication cadence, and stand up a shared workspace. Done well, it sets expectations early and makes the first month predictable instead of chaotic.
Most studios already do a version of these steps — they just do them differently for every client, scattered across email, a project tool, a billing app, and one person’s memory. The fix is not more process. It is one process that runs the same way each time, landing in a single place the work lives. This is the version we’d hand a new account lead on their first day.
When does the client onboarding process start?
The clock starts when the contract is signed, not on the first day of billable work. The gap between “closed” and “kicked off” is where good engagements quietly go wrong: access requests sit in someone’s inbox, the client wonders if anything is happening, and the team starts work without the context to do it well. Treat onboarding as its own phase with a clear start and end, and that gap closes.
A complete process answers four questions before any real work ships: what are we doing (scope), who do we talk to and how often (comms), what do we need from you (access and assets), and where does all of this live (a shared workspace). Nail those four down in the first week and the rest of the engagement is execution, not archaeology.
What do you collect before the kickoff call?
Walking into a kickoff without the basics wastes the most expensive meeting of the engagement. Send an onboarding request the day the contract is signed and collect this before anyone gets on a call. Copy it into your own intake doc and trim to fit your discipline:
- Signed contract, SOW, and scope in writing — the single source of truth for what is and isn’t included.
- Primary point of contact, plus who signs off and who can’t.
- Brand assets: logo files, brand guidelines, fonts, tone-of-voice notes.
- Access: the tools, repos, analytics, ad accounts, CMS, or DNS you’ll need — at the right permission level.
- Existing material: past decks, prior agency work, research — anything you shouldn’t reinvent.
- Goals and the success measure — the number or outcome that tells everyone the work worked.
- Hard dates: launch, events, board meetings, blackout periods.
- Billing details: PO number, billing contact, net terms, preferred invoice format.
How do you run the kickoff call?
The kickoff converts a signed contract into a working relationship. Keep it to 45–60 minutes, send the agenda in advance, and drive it — the client hired you partly to bring the structure. A reliable running order:
- Introductions and roles (5 min) — who does what on both sides, and the single point of contact each way.
- Restate scope and success measure (10 min) — read it back out loud so any mismatch surfaces now, not in week six.
- Walk the timeline and milestones (10 min) — dates, dependencies, and what you need from them to hit each one.
- Agree the communication cadence (10 min) — meeting rhythm, status updates, response-time expectations, and the channel for each.
- Show the shared workspace (10 min) — where the brief, deliverables, status, and invoices live, so there’s one link to remember.
- Confirm next steps and owners (5 min) — three to five action items, each with a name and a date.
End by sending a short recap the same day — decisions, owners, dates. The recap is not admin; it is the first proof that you run a tight ship, and it sets the tone for everything after.
How do you set expectations and a comms cadence?
Most client friction is not about the work — it is about mismatched expectations on when things happen and how people hear about them. Decide the cadence at kickoff and write it down so nobody has to guess. A cadence that holds up for most retained or project work:
- Weekly: a short written status — what shipped, what’s next, what’s blocked. Same format, same day, every week.
- Every two to four weeks: a live working session to review deliverables and make decisions.
- Quarterly: a business review for retained clients — results against goals, and the renewal conversation.
- Always: a defined response window (say, replies within one business day) so silence never reads as a problem.
Put the cadence somewhere the client can see it, not buried in a contract appendix. When expectations are visible, scope creep and “are we still on track?” pings both drop — because the answer is already on the board.
Why give every client one board?
Here is the operational core of the playbook: give every client a single board, named with a slug like b/acme, that holds the brief, the deliverables, a time tracker, and the line-item invoices. Instead of context smeared across Notion, Harvest, FreshBooks, and Drive, the account lives at one URL anyone on the team can reach from the address bar.
In BookSlash a slug is more than a redirect — it resolves to a multi-tool canvas. A board behind b/acme can carry a kanban for deliverables, notes for the brief, a billable timer, invoice nodes, and live embeds of the Figma file or Loom walkthrough. See how the whole pattern fits together on the client work use case, and what a board can hold on the boards tour.
What lives on a client board
A workable starter set — copy it as your board template and adjust per discipline:
- Engagement brief — scope, deliverables, and the success measure, pinned where the client lands.
- Deliverables board — backlog to shipped, dragged across in real time so status never needs a status meeting.
- Billable timer — start it when you sit down; the minutes feed the invoice line items.
- Invoice ledger — one node per month, with status, line items, and a PDF link.
- Live embeds — the Figma frames and Loom recordings the client actually wants to see, never a stale screenshot.
Why the context travels
When the account lead is out, anyone can open b/acme and see exactly where the engagement stands — no hunting through inboxes, no “who has the latest invoice?” The shorthand itself is a go link: type the slug, land on the board in about 40 milliseconds. New to the idea? Start with what are go links.
One board vs the scattered stack
The argument for consolidating is not aesthetic. Every extra tool is another login to provision for a new contractor, another place a fact can go stale, and another bill. Here is the same engagement run two ways:
| What you need | Scattered stack | One client board |
|---|---|---|
| The brief | A doc someone has to find | Pinned to b/acme |
| Deliverable status | A separate PM tool | Kanban on the board |
| Billable hours | Harvest / Toggl | Timer on the work surface |
| Invoices | FreshBooks | Invoice nodes on the board |
| Client visibility | Status emails | Free guest seat, live |
| Finding it all | Bookmarks and memory | One slug: b/acme |
None of this means ripping out tooling you love. It means the account’s center of gravity is one slug instead of a folder of bookmarks — and onboarding the next client is stamping a copy of the board, not rebuilding a workflow from scratch.
Putting the process to work
A client onboarding process is only as good as how repeatably you run it. Turn this playbook into a board template — brief, deliverables, timer, invoice ledger — and spin up a copy for each new client behind its own slug: b/acme, b/globex, one per account. The intake checklist and kickoff agenda above become two pinned notes on that board, so every account starts the same way.
From there: claim a slug per client (see how slugs work), build the canvas (the boards tour shows every tool a board can hold), and read the full agency pattern on the client work page. If go links are new to your team, start here. The payoff is plain: account context that travels, and nothing anyone has to hunt for.