Where Do Small Agencies Break at Scale?
Contents
- The first thing that fails is rarely the client relationship
- Legal clients create a different kind of approval drag
- The point where Slack and email stop working
- What people standardise first, and get wrong
- A status model that actually works for legal approvals
- Revision pile-up: what actually slips first
- One approval object, one owner, one current version
- The awkward legal reality: email approval is not signature approval
- What experienced agencies do on the second try
- A simple operating model for agencies handling multiple legal approvals
- Weekly rules
- Required fields on every retainer record
- Escalation rules
- If you are still running this from inboxes, fix the system before hiring more people
- The next move
A five-client agency can run on memory, goodwill, and a heroic account manager.
At eight or ten active clients, that same setup starts dropping work in places nobody sees at first. Not in the strategy. Not even in the writing or design. It breaks in the handoffs, the approvals, and the quiet assumptions between people.
For agencies serving legal clients, that break happens faster.
A law firm can say “approved” in an email and still not be ready to start. A partner can verbally greenlight a matter while billing still needs the signed retainer loaded into the right system. An engagement letter can be attached in three different versions across Outlook, SharePoint, and a practice management platform, with nobody fully sure which one the client actually received.
That is where trust gets lost. Not because the work is poor, but because the process feels unreliable.
#The first thing that fails is rarely the client relationship
Most small agencies assume scale breaks delivery capacity first. In practice, approval workflow breaks first.
When you are handling three matters, one person can remember:
- which retainer was sent
- who has authority to sign
- whether billing has opened the matter
- whether the partner wants changes
- whether the client has actually signed, or just “approved in principle”
When you are handling fifteen at once, memory stops being a system.
The common failure pattern looks like this:
| Stage | What happens at low volume | What happens at scale |
|---|---|---|
| Internal handoff | Someone pings billing or ops manually | Nobody knows who owns the next step |
| Client follow-up | Account lead sends a reminder from memory | Duplicate reminders, or no reminder at all |
| Version control | Latest doc is “probably in email” | Wrong version gets resent or signed |
| Approval status | Team assumes context is shared | Status means different things to different people |
| Start trigger | Work starts when “everyone seems aligned” | Work starts before retainer is executable, or stalls after verbal approval |
For legal clients, internal handoff usually fails first.
That surprises people. They expect client follow-up to be the problem. Sometimes it is. But the bigger issue is that agencies often do not define the exact moment ownership moves from account lead to billing, from billing to legal admin, or from “approved” to “signed and startable”.
If you do not define those transitions, your team invents them on the fly.
#Legal clients create a different kind of approval drag
Law firm retainer approval bottlenecks are not just slower versions of normal client approvals. They are structurally different.
A retail client might approve a proposal and pay the invoice in one motion. A law firm often has at least four separate gates:
- Commercial approval, usually by a partner or practice lead
- Engagement terms review, often by ops, practice management, or risk
- Signature collection from the right party
- Billing or matter-opening trigger in the firm’s system
Those are not interchangeable.
A partner saying “looks fine” does not mean the retainer can be issued. A signed PDF does not mean the matter is open in Clio, Actionstep, Smokeball, LEAP, or the firm’s billing workflow. An accounts team can have the signed document and still be waiting for trust account details, GST treatment, or a billing contact to be confirmed.
Agencies underestimate three things here:
- Sign-off authority is often fuzzy. The person giving feedback is not always the person authorised to bind the firm.
- Compliance matters. Firms care about engagement wording, privacy obligations, conflicts, and billing triggers in a way many other industries do not.
- Approval has downstream consequences. Once a retainer is signed, billing, onboarding, and matter setup need to happen in sequence, not eventually.
This is why generic “just automate reminders” advice falls flat. The reminder is not the process. It only helps if the workflow behind it is clean.
#The point where Slack and email stop working
Slack and email are fine until two people can plausibly believe the other person already followed up. That is the breaking point.
In most small teams, that happens sooner than they admit. Usually around:
- 6 to 8 active clients with overlapping deadlines
- 10 or more open approvals at any one time
- more than 2 people touching the same account
- more than 1 revision round per document on average
Once you hit that point, a few familiar messages start appearing:
- “Did anyone chase this?”
- “I thought billing had it.”
- “Can you resend the latest version?”
- “Client says they signed, but I can’t find it.”
- “We’re waiting on approval” when the real issue is waiting on the correct document
That is the moment manual reminders stop being “good enough”.
Not because reminders are bad, but because unowned reminders create false confidence. Everyone sees activity. Nobody sees accountability.
A workable rule is simple: if an approval can sit untouched for 48 hours because the team assumes someone else is on it, your workflow is already too loose.
#What people standardise first, and get wrong
The first process most agencies try to standardise is the reminder cadence. It is usually the wrong place to start.
They build a sequence:
- Day 0, send retainer
- Day 2, reminder
- Day 5, reminder
- Day 7, escalate
That sounds tidy. It often creates more friction.
Why? Because it standardises the chase before standardising the states.
If “sent”, “under review”, “approved by email”, “awaiting signature”, and “signed but not loaded into billing” all live under one vague label like “pending”, your reminders become noisy and your reporting becomes useless.
Fix the status model first.
#A status model that actually works for legal approvals
Use statuses that reflect operational reality, not just client politeness:
Drafting
Retainer is being prepared. No client-facing document yet.Internal review
Waiting on partner, billing, legal admin, or ops review before send.Sent for review
Client has the document. No approval yet.Commercially approved
Client has agreed in principle, but no executable signature yet.Revision requested
Client or internal stakeholder requested changes.Sent for signature
Final version issued for execution.Signed by client
Signature complete, but downstream setup may still be pending.Billing cleared / matter open
The firm’s internal trigger is complete. Work can start.Active
Delivery underway.
That one change solves a surprising amount. It tells your team where the blockage actually is. It also exposes the difference between “good news” and “ready to begin”.
Approval chaos usually comes from collapsing five distinct states into one vague idea of “pending”.
#Revision pile-up: what actually slips first
When revision cycles pile up, version control usually fails before the deadline does. Then the deadline slips because nobody trusts the version in front of them.
This is the real failure mode in small agency scaling.
People talk about “too many revisions” as if the volume is the issue. It usually is not. Two rounds of revisions across ten clients is manageable. What kills the team is:
- feedback arriving in multiple channels
- comments applied to an outdated draft
- a PDF attached to email while the Word version lives somewhere else
- a partner approving version 3 while billing still has version 2
- nobody marking one version as final and executable
For law firm retainer approval bottlenecks, this gets expensive fast. The wrong version does not just create rework. It delays matter opening, invoicing, and revenue recognition.
If you want one practical rule, use this:
#One approval object, one owner, one current version
For every retainer or engagement document, define:
- one record where status lives
- one owner responsible for next action
- one current version that can be sent externally
Everything else is reference material.
If your current process relies on “latest attached in the thread”, you do not have version control. You have optimism.
Key takeaway: Small agencies do not break because they get busier. They break when nobody can answer, in under 30 seconds, what version is current, who owns the next step, and what exactly is blocking start.
#The awkward legal reality: email approval is not signature approval
A partner approving by email is useful, but it is not the same as an executed retainer. Treating those as equivalent creates avoidable delays.
This comes up constantly with legal clients.
A partner replies: “Approved, proceed.”
But your billing or engagement team still needs:
- the signed retainer in the proper system
- matter details entered correctly
- billing contact confirmed
- trust or fee arrangement recorded
- the final document stored against the right client record
Experienced agencies do not argue with the partner. They translate the approval into the next required action immediately.
A workable response looks like this:
- Acknowledge the approval quickly.
- Restate what is still needed.
- Send the executable version in the same thread or linked from the same record.
- Assign one person to monitor completion.
- Do not mark the matter “approved” in your tracker. Mark it “commercially approved, awaiting signature”.
That wording matters. It prevents the team from starting work on a technicality.
#What experienced agencies do on the second try
If a retainer sits for days, the best agencies do not just send another reminder. They change the path.
A stalled approval usually points to one of four issues:
| Stuck reason | What weak agencies do | What experienced agencies do |
|---|---|---|
| Wrong approver | Send another generic chase | Confirm sign-off authority directly |
| Friction in document | Ask “any update?” | Offer a redline or summary of changed clauses |
| Signature gap | Resend same PDF | Send executable version with exact signer named |
| Internal bottleneck | Wait for client | Trigger billing or admin follow-up internally first |
The second attempt should be more precise than the first.
For example:
- Not “following up on the retainer”
- But “we have partner approval, we now need execution by [name/role] so billing can open the matter”
Or:
- Not “checking if you saw this”
- But “clause 7 was the point flagged last round, attached is the clean version with only that amendment”
Specificity gets movement. Generic follow-ups get ignored because they force the recipient to reconstruct the context.
#A simple operating model for agencies handling multiple legal approvals
If you want to stop recurring approval bottlenecks, build around ownership and exception handling, not reminders.
Here is a lean model that works well for small teams.
#Weekly rules
- Every open retainer has one named owner
- Every open retainer has a next action date
- No status can remain unchanged for more than 48 hours without a note
- “Approved” is never a final state unless signature and billing trigger are complete
#Required fields on every retainer record
- Client / matter name
- Current status
- Current version link
- Approver name and role
- Authorised signer name and role
- Billing trigger required
- Last outbound contact date
- Next action date
- Owner
#Escalation rules
- 48 hours stuck in Sent for review: owner follows up with context
- 72 hours stuck after commercial approval: confirm signer and send executable version
- 5 business days with no movement: escalate internally to partner, billing lead, or legal admin contact
- Second revision request: switch from email thread to tracked redline or single-source document review
That is enough structure for most boutique teams. You do not need enterprise process theatre. You need visible ownership.
#If you are still running this from inboxes, fix the system before hiring more people
A lot of agencies try to solve workflow failure with headcount. That usually means hiring someone into a broken process.
If your team is juggling overlapping deadlines, revision process issues, and law firm retainer approval bottlenecks across email, spreadsheets, Slack, and shared drives, another coordinator will help for about six weeks. Then they become the human patch holding the mess together.
Better to fix the workflow first:
- define statuses
- define owners
- define the start trigger
- define where the current version lives
- define when an approval is truly complete
The same logic applies to your broader agency workflow and client management at scale. Trust is operational. Clients feel it when your team knows exactly what is waiting, who is responsible, and what happens next.
If trust-building is part of your growth plan, it is worth reading How Do I Start Creating Trust-Building Content? and How to Collect Customer Testimonials That Convert. The firms that look organised in public usually have cleaner internal systems too.
#The next move
This week, pull your last ten delayed retainers and audit them against five questions:
- Was there one clear owner?
- Was the current version obvious?
- Did “approved” mean the same thing to everyone?
- Was the authorised signer identified early?
- Did billing have a defined trigger to start?
If you cannot answer those quickly, that is your bottleneck. Not workload. Not client responsiveness. Process clarity.
If you want the faster path, look at Client Management. It gives you one record per client across lead, prospect, active, and archived stages, with the work, billing context, and client history in one place. If your approvals are currently scattered across inboxes and memory, start there and give your team a workflow they can actually trust.



