Companion Worksheet

The Automation Checklist for Independent Operators

Four pillars, twenty-four checks, and one worksheet for finding the repetitive work inside your operation and handing it to a machine. None of it is industry-specific — the same sequence applies whether you run a studio, a clinic, an agency, a workshop, or a one-person shop.

Companion to From Manual Grind to Automated Scale Black Marker Media Rev. August 2026

Use it in this order

The pillars are sequential, not a menu. Each depends on the one before it — you cannot standardize work you have never inventoried, and you cannot hand a machine a process nobody has written down. Skipping ahead is the most common reason automation projects stall and get quietly abandoned.

Work one pillar at a time. Most operators find that the first pillar alone changes what they thought their problem was.

PILLAR01

Inventory — find the repetition

You cannot automate what you have not written down. Almost everyone starts with the task that annoys them most, which is rarely the task costing them most. This pillar replaces that instinct with a number.

Log every task you touch for one full week — as you do it, not from memory afterward
Record two figures per task: minutes it takes, and times per month it happens
Convert both into a single number — hours per year — using the worksheet below
Flag every task where you move information from one place to another by hand
Flag every task you have explained to another person more than twice
Rank by hours per year, commit to the top three, and ignore everything below them

Why this comes first A task taking four minutes that happens twice a day costs about 35 hours a year. A miserable two-hour task that happens twice a year costs four. Frequency beats duration nearly every time — and frequency is almost never what feels urgent.

PILLAR02

Standardize — make it identical every time

Automation multiplies whatever you feed it. Variation is what breaks it — not complexity. Before any tool enters the picture, the work has to happen the same way twice in a row.

Write the task as numbered steps a competent stranger could follow without asking you anything
Replace every "it depends" with a written rule: if this, then that; otherwise, this
Fix one naming convention for files, folders and records — and apply it to what already exists
Turn anything you rewrite regularly into a template with fixed fields
Delete any step whose only justification is that it has always been done
Run your own written version once, exactly as written, and fix everything that breaks

The expensive mistake Never automate a broken process. You do not get a fixed process — you get the wrong result faster, more often, and with less chance of noticing. If the manual version produces inconsistent output, automating it makes that worse.

PILLAR03

Systemize — hand it to a machine

Only now does tooling matter, and it matters far less than people expect. The winning choice is almost always the smallest thing that removes the work — not the most capable platform you could eventually grow into.

Start with the highest-frequency, lowest-judgment task on your ranked list
Choose the smallest tool that finishes the job — a scheduled reminder beats an unfinished app
Automate the decision rules, not just the clicking — the rules are what cost you attention
Connect the systems already holding your data before buying anything new
Finish one task end to end before extending the approach to another five
Time the result and confirm it genuinely beat doing it by hand — some will not

Scope discipline One task automated completely teaches you more than six automated halfway. Half-automated work is often worse than manual work, because now you also have to remember which half still needs you.

PILLAR04

Govern — make failure loud

The dangerous automation is not the one that breaks. It is the one that breaks quietly and keeps reporting success, so nobody looks until a client, a patient, or an audience finds it for you.

Define in writing what "failed" looks like for each automation, before you depend on it
Make failures actively notify a person — silence must never be read as success
Name one owner per automation; their job is handling exceptions, not doing the task
Write the manual fallback: what you do if this is down on your busiest day of the year
Set a review date — automations rot as the work around them changes
Document it well enough that it survives you being unavailable for two weeks

The test that matters A system is finished when your team runs it without you — not when it works while you are watching. If it needs you, a consultant, or an AI in the loop every day just to keep operating, you have not built an automation. You have built a dependency — which is the thing you were trying to escape.

The repetition audit

Fill this in from your week of logging. Enter how long a task takes and how often it happens per month; the annual cost calculates itself. Rank by the right-hand column rather than by instinct — this is Pillar 01, done properly.

Task	Minutes each	Times / month	Hours / year
			0.0
			0.0
			0.0
			0.0
			0.0
			0.0

Total recoverable time 0.0 hours / year

minutes × times per month × 12 ÷ 60 = hours per year

Where this actually goes

Automation is not the goal. Ownership is.

Every hour this recovers is an hour you were renting back from your own operation. The operators who compound are the ones who reinvest that time into what they own outright — their systems, their audience, their infrastructure — instead of into more manual throughput on someone else's platform.

That argument holds in any discipline: the work that repeats should run itself, so the work only you can do gets the hours it deserves.