The goal: stop guessing which fixes deserve automation
You've got a list of things that bug you — manual invoicing, scheduling back-and-forth, a report nobody reads. The instinct is to throw software at all of it. That's a mistake. Some of these problems need automation. Some need a cleaner process first. Some just need to die.
This week, run every item on your list through a simple triage: Automate, Improve, or Ignore. By Friday you'll know exactly what to build or buy, what to fix by hand first, and what to consciously drop. No new tools required for this part — just a notebook and honest answers.
List and score every friction point (Monday)
Start by writing down every recurring task or process that causes delay, error, or groaning. Don't filter yet. Examples:
- Copying form submissions into a spreadsheet
- Chasing overdue invoices by memory
- A weekly report that takes two hours to assemble
- Onboarding a new client (five emails, three approvals)
- Scheduling client calls over email tag
Aim for 10–15 items. If you've already done a self-assessment exercise, pull straight from those notes.
Now score each one with two questions:
- Is it repetitive and rules-based? Same steps every time, no judgment calls?
- Is the process itself solid? If a new hire followed the current steps exactly, would it work — or is it already a mess?
These two questions do most of the sorting:
- Repetitive + solid process → Automate
- Not repetitive, or process is broken → Improve first
- Low value either way → Ignore
Mark each item "A," "I," or "X." Don't overthink it — first instinct is usually right.
Pick your pilot and check it's ready
Look at your "A" list. Rank it by time spent per week and how simple the fix looks. A task that eats three hours weekly and has an obvious off-the-shelf tool (a scheduling app, an invoice reminder) goes to the top. A task that needs custom integration work goes to the bottom, even if it's tempting.
This week's pilot: pick exactly one item from the top of that list. Not three. One. This is the same discipline behind starting with a single automation instead of five — a narrow pilot gets you a real result instead of five half-finished ones.
Example pilot: automated invoice reminders. If a client hasn't paid in 15 days, a tool sends a polite nudge automatically.
Before you touch any tool, confirm the process underneath your pilot is actually clean:
- Does this task follow the exact same steps every single time?
- Is there a clear trigger and a clear end state?
- Would two different employees currently do it the same way?
If the answer to any of these is no, move that item to "Improve" instead — automating a messy process just makes the mess faster. A readiness check walks through this in more detail if you're unsure.
For the invoice example: is "overdue" defined consistently (15 days past due, always)? Does every invoice live in the same system? If yes, you're ready.
Build the automation, then clean up the rest
Keep the pilot's scope small and use what you already have where possible:
- Accounting software with built-in reminders (QuickBooks, FreshBooks, Xero) — usually a toggle, not a project.
- No-code connectors (Zapier, Make) if your invoicing tool doesn't have native reminders — trigger on "invoice overdue," action "send email."
- A simple autoresponder if you're duct-taping this together with Gmail or Outlook rules as an interim step.
Set it up for one segment first — one client list, one invoice type — rather than flipping the switch for your entire book of business on day one. Test with a dummy or low-stakes case before trusting it with a real client relationship.
For items marked "Improve," resist the urge to shop for software yet. Instead:
- Map the current process on one page — every step, in order.
- Cut anything unnecessary. If onboarding has five forms, ask which three actually matter.
- Standardize: write a one-page checklist so everyone does it the same way.
- Decide who owns it — sometimes "improve" just means handing a messy task to someone (or a contractor) who's already good at it.
Mapping the process before automating is worth the extra hour here — it prevents you from digitizing chaos later. Only after the process is clean should these items move back into the "Automate" column for a future week.
Don't drop your "Ignore" items silently, either. Write the reason next to each:
- "Weekly competitor report — nobody reads it. Cutting it, not automating it."
- "Custom mobile app — clients aren't asking for it. Revisit if that changes."
- "CRM integration with our old ticketing tool — high complexity, low payoff right now."
This turns vague guilt ("I should really get to that") into a deliberate decision with a stated reason. That's the difference between neglect and triage.
Measure the pilot and avoid common traps
Before you call the pilot done, check:
- Did the automation actually fire correctly on a real case?
- How much time did it save this week, even roughly?
- Did it introduce any new errors (wrong client, wrong timing)?
If it worked, expand it to the next segment next week. If it didn't, figure out whether the tool was wrong or the process underneath still had a gap — don't scrap the whole idea over one bad test.
Watch for these traps along the way:
- Automating a broken process. If your readiness check flagged inconsistency and you skip it, you'll just get errors faster.
- Trying to automate everything in your "A" column at once. One pilot, one week. Sequencing matters — see this guide to running multiple automations without collision once you're past your first win.
- Treating "Ignore" as failure. It's not. Saying no to low-value work on purpose is what frees you up to do the high-value work well.
- Skipping the reason. An undocumented "ignore" decision quietly turns into a nagging task you revisit every quarter without resolving.
By the end of the week, you won't have automated everything — you'll have automated the right thing, cleaned up one messy process, and consciously benched the rest. That's more progress than most businesses make in a quarter of scattered effort.