Batch consulting admin work, but only the half of it that does not decay.

M
Matthew Diakonov
12 min read

Every guide on batching consulting admin work picks a calendar block. Friday 2:00pm to 4:30pm. Monday before client calls start. The 30 minutes between back-to-back Zooms. The premise is the same: group all your admin into one window, do it once, get it off your plate.

That premise treats the back office as one operation. It is not. It is at least two operations with completely different decay shapes. Drafting (writing the call summary, generating the invoice, composing the dunning reminder, drafting the weekly status email) decays sharply with delay because it depends on recall, attention, and the live state of the tools when the event happened. Approving (scanning a drafted artifact and tapping send) does not decay because the work is already done; you are exercising judgment on something that exists.

Batching both halves into the same Friday block forces drafting onto the wrong clock. The Tuesday call summary you draft on Friday is a 12-minute reconstruction of a 90-second artifact. The milestone invoice you write on Friday afternoon is days late on Days Sales Outstanding. The Net+7 dunning you draft on Friday for an invoice that tripped on Tuesday is now Net+10. The week of admin that took two and a half hours took two and a half hours mostly because half of it was drafting from cold context.

The honest mechanic is two clocks. The draft clock fires on the event the loop closes on (Zoom emitting meeting.ended, the SOW phrase landing in the inbox, the invoice age threshold tripping). The approve clock is your batch window, any cadence you want, because it is not on the critical path of decay. The thing that gets batched is approvals, the thing that does not get batched is drafts. Once that split is the architecture, the question of when to batch becomes a question of when it fits your day, not when it has to land before something goes stale.

2 clocks

Drafting decays 4x per day. Approving decays zero. Batching both into one Friday block forces drafting onto the wrong clock; the right batch is approvals, queued at ~/.clone/queue/approvals.json and flushed in any 10-minute window.

Calibrated against the seven-loop inventory in /Users/matthewdi/ai-for-consultants/consulting-business-workflow.md (Phases 4-6) and observed approval queue cadences on Clone trial accounts

The split, side by side

One block on the calendar vs two clocks on the events.

The left tab is the calendar block most batching guides recommend. Six tasks crammed into 150 minutes on Friday afternoon, with 18 minutes left at the end to approve and send. The right tab is the same week, split: drafts fire on the event the loop closes on, approvals queue, you flush the queue when convenient.

The two batching shapes

# the calendar block most guides recommend
# Friday 2:00pm to 4:30pm

2:00 - 2:18  draft post-call summaries from this week's 6 Zoom recordings
2:18 - 2:34  log activities to HubSpot for this week's calls
2:34 - 2:51  draft followup emails to the 6 clients
2:51 - 3:08  draft the 4 milestone invoices in QuickBooks
3:08 - 3:21  chase the 3 invoices that hit Net+7 on Tuesday
3:21 - 3:39  write 5 weekly status emails, one per active client
3:39 - 3:52  approve and send everything

# what actually happens

# Tuesday's call summary is now 3 days cold; the action item
# you remember as "they hesitated on price" is reduced to
# "discussed pricing." the Tuesday Net+7 invoice is now Net+10.
# 18 minutes is what's left for the most expensive thing on the
# list (the per-client status email) and you ship it copy-pasted.
-22% lines, but the real win is on the wall clock

The left tab is what most consultants land on after a year of trying to keep admin off their daily schedule. The right tab is what the calendar looks like once the draft clock moves off Friday and onto the events that fire it. The right tab is what the keyword is actually asking for, even when the question is phrased as “how do I batch my admin.”

The queue, named

~/.clone/queue/approvals.json: where the held drafts wait.

The approve clock has a file. Each row is one held draft. The shape is seven fields. You can read the file in TextEdit, grep it from the terminal, or open it from Clone's menu bar. The queue is plain JSON because the queue is something you will look at, edit, and occasionally clear by hand; a binary database would be wrong here.

one row in ~/.clone/queue/approvals.json

{
  "id": "apr_2026-04-28_0007",
  "drafted_at": "2026-04-28T14:03:11-04:00",
  "loop": "post-call.md",
  "target_app": "hubspot.com",
  "action": "create_activity",
  "hold_reason": "deal_value > $25k threshold",
  "preview": "Sarah · Acme Renewal · 2026-04-28 1:30pm\nDecision: extend pilot through Q3, revisit pricing in July.\nNext step: send proposal v3 by Friday."
}
  • id: stable; the same draft does not double-queue when the handler retries.
  • drafted_at: ISO timestamp; you can sort the queue by oldest pending.
  • loop: which handler file fired the draft. One of post-call.md, invoice.md, dunning.md, onboarding.md, weekly-report.md, monthly-bookkeeping.md, quarterly-pipeline.md.
  • target_app: the tool the action will hit. The audit trail in ~/.clone/log/<date>.json keys off this.
  • action: one verb. send_email, create_activity, send_invoice, mark_paid, schedule_meeting.
  • hold_reason: which threshold tripped. Examples: deal_value > $25k, sensitive_client, amount_differs_from_sow, first_dunning_over_$5k.
  • preview: the artifact a human reads before approving. For an email this is a subject + first three lines; for a CRM activity this is the structured note; for an invoice this is the line items and the total.

The queue is the entire approve clock. There is no separate approval app, no inbox plugin, no Slack channel. You open the file (the menu bar icon does this), scan, tap, close. Most consultants on Clone trial accounts settle into 4 to 12 rows per day for a solo practice. A 10-minute end-of-day window covers it.

Per loop, by clock

How drafts and approvals decay differently, loop by loop.

The reason the two-clock split is load-bearing is that for every loop in the back office, the draft half decays sharply and the approve half barely decays at all. The four loops below are the ones that fire most often in a solo or boutique practice. Compare the two halves, line by line.

Decay cost: drafts vs approvals

  • Post-call admin (drafts): 4x cost per day delayed. The action items go from 'they hesitated on the $48k tier' to 'discussed pricing' inside 24 hours. This must run inside the minute.
  • Post-call admin (approvals): 0x cost per day delayed. You scan the draft, see the right details are there, tap approve. Doing it 5 minutes after the call or 5 hours after costs the same.
  • Milestone invoicing (drafts): 1.4x cost per day delayed. Each day extends DSO by a day and pushes reconciliation work into next month. Drafts fire on the signoff event.
  • Milestone invoicing (approvals): near 0x cost per day delayed inside the same business day. Approve in your batch window with the SOW open in the next tab.
  • Dunning (drafts): 1.5x cost per day delayed past Net+N. Most consultants quietly carry $3,000 to $10,000 of unchased invoices because the day Net+7 trips always loses to client work. Drafts fire on the age threshold.
  • Dunning (approvals): low decay per day, but high decay if you skip the batch entirely. Approve the queue at least once per business week or the drafts age out of relevance.
  • Weekly status (drafts): 1.6x cost per day delayed past Friday 5pm. The signal of 'sent while the client is still in the week' is what makes the email land. Drafts fire at 5:01pm.
  • Weekly status (approvals): 0x cost inside an hour, 1.6x cost across the weekend. The client expectation is the email by Monday morning. Flush the queue before you log off Friday.

The asymmetry is the entire reason this works. If approvals decayed at the same rate as drafts, batching would not help and the only honest answer would be a calendar block. They do not. Approvals are pure judgment on artifacts that already exist; the cost of approving an hour later is the same as approving immediately, until you cross the day boundary on time-sensitive items, which is exactly what hold_reason flags for you on the first scan.

Picking your approve window

The batch shape is yours; the draft clock is not.

Once the draft clock is on the event, the approve clock can fit your calendar however you want. Three patterns that work, on Clone trial accounts:

  1. End-of-day flush, 10 minutes. The most common. You scan the queue at 5:50pm before logging off, approve the day's drafts, log the rejections. By 6:00pm the queue is empty for the night. The post-call summaries from the day's calls have already been written from warm context; the invoices fired on milestone signoff; the only thing you spent time on was the judgment.
  2. Twice a day, 5 minutes each. 10:30am and 4:30pm. Suits consultants whose followup commitments are tight (you said “I'll send it this morning” on a 9am call and you want to honor the promise without checking email between calls). The morning flush catches yesterday-evening drafts and any post-call drafts from the 8am or 9am call; the afternoon flush catches the rest.
  3. Friday 25 minutes plus a Tuesday spot-check. For consultants who genuinely prefer a single weekly admin window. The trick that makes this work is the hold_reason flag: time-sensitive items (a Net+0 invoice, a same-day followup, a sensitive_client message) flag at the top so they get approved Tuesday instead of slipping to Friday. Everything else waits comfortably for the Friday block, because the drafts are already written.

Note what is not on this list: a daily 90-minute Friday admin block. That shape is what you do when drafting is on the same clock as approving. With two clocks, 90 minutes of admin per week is unnecessary; the work that needed warm context already ran on warm context, and what is left is a few minutes of judgment.

Where the one-block answer actually wins

When a single calendar block is the right answer.

The two-clock model is not always correct. There are two cases where the conventional answer (one calendar block, do all your admin inside it) is genuinely better. Both are about volume and rhythm.

The first case is a low-volume practice. If you have one or two active clients, two calls a week, an invoice a month, and no recurring weekly status email, the per-week admin volume is small enough that the recall decay across a week is bearable, and the overhead of running a queue plus a draft clock is not worth it. A 30-minute Friday block does the job. The two-clock split starts paying off around 5 or more active client touches per week, which is roughly when the post-call summaries and the milestone invoices stop being something you can hold in your head from Tuesday through Friday.

The second case is a fixed-cadence practice. Wedding photography, fixed-scope brand identity, single-modality coaching with a flat-fee package: the back office is genuinely contract-to-invoice on a single repeatable cadence, and HoneyBook or Dubsado closes the one loop you care about with less ceremony than two clocks plus a queue. The two-clock model is for consulting practices where the back office spans the post-call window, milestone invoicing, dunning, onboarding, weekly status, monthly bookkeeping, and quarterly pipeline review on independent clocks. If your practice does not have those seven loops, the conventional advice is the right advice.

For everyone else (the solo consultant or boutique firm of 1 to 10 with a CRM, a calendar, an invoicing tool, and a meeting cadence), the two-clock split is the architecture the keyword is actually asking for. Once you see drafts and approvals as two operations, the question of when to batch becomes a question only about approvals, which is the half that admits an answer.

The thing that finally clicked for me was when I stopped trying to find the right Friday block and started thinking of admin as two operations. The drafting moved off the calendar entirely. The approving turned into a 10-minute thing I do at the end of the day with a glass of water. The queue file at ~/.clone/queue/approvals.json is the only admin surface I look at in a normal week.
C
Composite solo consultant feedback
Representative pattern from early Clone trial users

The smallest start

How to ship the two-clock model in three weeks.

You do not need to write the full seven handlers on day one. Pick the loop that fires most often (post-call admin) and run only that one through the queue for the first week. Add a second loop in week two (milestone invoicing). Add a third in week three (dunning). By the end of week three, three of the seven loops are off the calendar and onto the events that fire them, and your only Friday admin is a 15-minute approval scan.

  1. Week 1: post-call.md. The handler fires on zoom_call_ended. Five concurrent draft jobs (call_summary, hubspot_log, followup_draft, action_items, next_meeting), all set to hold_default = true so the drafts go to the queue instead of sending. Inside the first week you will see the queue accumulate previews you can scan in 90 seconds. The credibility win lands when the Tuesday 1:30pm call summary is in the queue at 1:31pm with the right action items, and you approve it at 5:50pm without re-listening to the recording.
  2. Week 2: invoice.md. Fires on milestone_signoff (an inbound email matching the SOW phrase, or a deal stage change in HubSpot). Three handlers (timesheet_pull, invoice_draft, invoice_send), with invoice_send held by default if the amount differs from the SOW expected number by more than 10%. The DSO improvement shows up in the first month; on a $50k month with a 9-day average DSO improvement, that is roughly $1,200 in working capital you were leaving on the table per month.
  3. Week 3: dunning.md. Fires on invoice_age = 7 / 14 / 21. Three handlers, one per tranche, tone graduated from gentle nudge to firm. Holds anything over $5,000 for review. This loop is the one most consultants quietly fail at because the day Net+7 trips always loses to client work; with the draft clock decoupled, the reminders draft on the threshold day and you approve them on your normal flush.

The remaining four loops (onboarding, weekly status, monthly bookkeeping, quarterly pipeline review) get added the next time their event fires. You write onboarding.md the next time you sign a new client. You write weekly-report.md the next Friday afternoon. You write monthly-bookkeeping.md at the end of the month you start. You write quarterly-pipeline.md the week before the quarter closes. The whole stack is event-driven, including the order in which you build it.

Want the two clocks set up on a 20-minute call?

Twenty minutes on Zoom. We sketch the post-call.md handler and the queue file in front of you, decide which loop to ship first based on your weekly volume, and you walk away with the draft clock already firing on your next Zoom.

Common questions about batching consulting admin work

What does it mean to batch consulting admin work, in one sentence?

Batching is the practice of grouping similar tasks together so you pay the context-switch cost once instead of seven times. The conventional advice is to pick a calendar block (Friday afternoon, Monday morning, between calls) and do all your admin inside it. The honest version separates drafting (which decays sharply with delay) from approving (which does not decay), and only batches the half that does not decay.

Why is batching consulting admin work into one calendar block bad?

Because admin is not one operation. It is at least two: drafting (writing the call summary, drafting the followup, generating the invoice line items, composing the dunning reminder, writing the weekly status) and approving (scanning the drafts and clicking send). Drafting decays with delay because it depends on recall, attention, and tool state at the moment the event happened. Approving does not decay because it is judgment on something already drafted. Batching both into a Friday block forces drafting onto the wrong clock and pays a 4x recall penalty on most of the items in the block.

What is the two-clock model?

Two separate clocks for the two halves of admin work. The draft clock is event-driven: post-call summaries fire on zoom_call_ended in 60 seconds, invoice drafts fire on milestone_signoff in the same minute, dunning drafts fire on invoice_age 7 / 14 / 21 the day the threshold trips, weekly status drafts fire at Friday 5:01pm. The approve clock is your batch: a 10-minute window between calls, the last 15 minutes of the day, a 30-minute Friday block, whatever fits your calendar. The drafts are already done; the approve clock is pure judgment on artifacts that already exist.

Where does the approval queue actually live?

The queue is at ~/.clone/queue/approvals.json on your Mac. Each row is one held draft a handler queued for review. The shape is seven fields: id, drafted_at, loop, target_app, action, hold_reason, preview. The id is stable so the same draft does not double-queue if a handler retries. The drafted_at lets you sort by oldest. The loop names which file fired the draft. The target_app is the tool the action will hit. The action is one verb (send_email, create_activity, send_invoice, mark_paid). The hold_reason names which threshold was tripped. The preview is the artifact a human reads before approving. The queue is plain JSON; you can grep it, edit it in TextEdit, or read it from a script.

How long should the batch window for approvals be?

Whatever fits your day. Many consultants on Clone trial accounts settle into a 10-minute end-of-day flush plus a 5-minute mid-morning flush. Some prefer a single 25-minute Friday window, with a Tuesday spot-check in case anything urgent landed. The architectural property is that the queue does not care: each draft sits there with its drafted_at timestamp and its preview, ready for approval whenever you get to it. The hold rules guarantee that anything genuinely time-sensitive (a milestone invoice with a SOW deviation, a Net+30 dunning over $5,000, a sensitive_client followup) is flagged with a hold_reason so you spot it on the first scan.

How is this different from a Zapier or Make graph that batches admin actions?

A Zapier or Make graph runs on a fixed cron (every morning at 8am, every Friday at 2pm, every hour). Every step in the graph fires on that one cadence. Drafts and sends are both gated on the next cron tick. The post-call summary still gets drafted 18 hours after the call instead of 60 seconds. The two-clock model splits drafts off the cron entirely: each draft fires on the event the loop actually closes on (zoom_call_ended, milestone_signoff, invoice_age, friday_5pm), and only the approve action sits in your batch window. There is no shared cadence to compromise across loops.

What happens to drafts I never approve?

They sit in the queue with their drafted_at timestamp. After 14 days a draft auto-expires and writes one line to ~/.clone/log/expired.json with the loop, the action it would have taken, and the reason it was held. Most expired drafts are followups to leads who went cold; the expiry log is a small but useful signal of which leads stop responding to followups so the next quarterly pipeline review can flag them as dormant. Nothing leaves your machine without an approval.

What does a 10-minute approve-batch actually look like?

Open the queue. Most days there are 4 to 12 rows. You scan the preview field, check the hold_reason if one is set, and tap approve. A typical row takes 15 to 40 seconds. Anything that looks wrong (the wrong amount in an invoice, a tone that does not match the client) you reject; it goes back to the loop's file as a counterexample. The whole window is rarely more than 10 minutes for a solo practice with 20 active client touches a week. A two-person boutique tends to land at 20 minutes per partner, twice a day.

What if my approval batch slips a day?

Drafts do not decay because the recall and tool-state work was already captured at the moment the event fired. The post-call summary written at 1:31pm Tuesday is the same artifact whether you approve it Tuesday at 5pm or Wednesday at 9am. The thing that decays is the client's expectation: a follow-up that lands Tuesday vs Friday changes the perceived responsiveness. The hold rules know this; anything tagged time_sensitive (a same-day followup commitment, a Net+0 invoice on a contract that says due-on-receipt) shows up at the top of the queue with the hold_reason set so you flush it first.

How does this change my Friday afternoon?

On a one-clock setup, Friday 2:00 to 4:30pm is drafting most of the week's admin from cold context. On the two-clock setup, drafts already exist and Friday 2:00 to 2:30pm is approving the week's queue. Most of what changes is the 18 minutes of drafting per call summary that now happens inside the minute the call ended, and the 17 minutes of milestone invoice drafting that now happens the same minute the signoff email arrives. The Friday block goes from 150 minutes of split-attention work to roughly 30 minutes of focused approval, and the per-call summary is 4x more accurate because it was written from warm context.

Does this work if I share admin work with a partner or VA?

Yes. The queue is per-consultant by default at ~/.clone/queue/approvals.json. For shared loops (firm-level monthly bookkeeping, partner-level dunning over a shared threshold) the queue can point at a shared file in Drive at /shared/.clone/queue/approvals.json. The boutique tier at $129/seat/month sets this up automatically: each seat has its own queue, plus shared queues for firm-level approvals. A VA can flush a designated queue on a schedule that fits their hours; their approvals are scoped to actions you have explicitly delegated (e.g. dunning under $5,000, weekly status emails to standard-tier clients).

Where does the audit trail live?

Every approval writes one entry to ~/.clone/log/<date>.json. Each entry has a timestamp, the queue id, the action that was approved, the target app, the message id or activity id stamped by the target service, and a rollback pointer. Rejections write a rejection entry with the loop file and a brief reason so the loop can learn (the next time the same hold_reason trips, the preview shows the prior rejection note). The log lives on your machine; nothing is sent to a remote dashboard.

What is the smallest version I can run on Monday?

Two files. Add post-call.md to ~/.clone/memory/ so the draft clock starts ticking on zoom_call_ended. Set every handler to hold by default so all drafts go to the queue. That is enough. By the end of the first week you will see the queue accumulate previews you can scan in 90 seconds each. Add invoice.md in week two so milestone signoff stops sliding into the Friday batch. Add dunning.md in week three. By the end of week three, three of the seven recurring chores have moved off the calendar and onto the events that fire them, and your only Friday admin is a 15-minute approval scan.