How to Tell If a Process Is Ready to Automate
Not every process should be automated. The signs a process is ready: it is documented, stable, high-volume, and rule-based. Automating a broken one just breaks faster.
A process is ready to automate when it is documented, stable, repetitive, and mostly rule-based. It is not ready when it changes every week, lives only in one person's head, or is really a series of judgment calls wearing a process costume. The most expensive automation mistake is not picking the wrong tool. It is automating a process that was not ready, because automating a broken process does not fix it, it just lets it break faster and at greater scale. Before you automate anything, run it through a readiness check.
Sign one: it is actually documented
If you cannot write down the process step by step, you cannot automate it, because you do not truly understand it yet. The test is simple: can someone who does not do this job follow your written steps and get the right result?
Most processes fail this test on the first try, and that is useful information. The gaps you find when you try to document it are exactly the exceptions and unspoken rules that would have broken the automation. Do the documentation first. If the process only exists as "Sarah knows how to do it," you are not automating a process, you are trying to automate Sarah, and that never works. This is why mapping the real process eats most of an automation timeline: the writing-down is the hard part.
Sign two: it is stable
Automate processes that hold still. If the steps change every few weeks because the business is still figuring out how the work should go, automating it means rebuilding the automation every few weeks, which costs more than doing it by hand.
Stability does not mean frozen forever. It means the core steps have settled and you are not actively redesigning them. A brand-new process nobody has run twice is not ready. A process the team has run the same way for months is. When you do automate a changing process, you at least need to version it and roll back cleanly, but the better move is usually to let it stabilize first.
Sign three: it is high-volume and repetitive
Automation earns its keep on repetition. A task done fifty times a day is worth automating even if each instance is small, because the savings compound. A task done twice a year almost never is, no matter how tedious each instance feels.
Count the volume honestly before you build. The math has to work: time saved per run times runs per month has to beat the cost of building and maintaining the automation. This is the same discipline as picking which process to put AI in first: follow the volume, because that is where the return lives. Low-volume, high-annoyance tasks feel like great automation candidates and usually are not.
Sign four: it is rule-based, with judgment at the edges
The best automation candidates are mostly rules with a little judgment, not mostly judgment with a little process. If a task is 90 percent "apply the known rule" and 10 percent "escalate the weird case," it is ready: the agent handles the 90 and hands the 10 to a person.
If it inverts, if the task is mostly judgment calls that happen to have some steps around them, it is not ready, and forcing it produces confident wrong answers. The honest split matters. Automate the rule-based bulk and keep a human in the loop for the judgment at the edges. Deciding where that line sits is itself delegating decisions, not just tasks, and getting it wrong is how automation projects lose trust fast.
Run the check before you build
Four questions, in order. Is it documented well enough that a stranger could follow it? Is it stable, or still changing weekly? Is it high-volume enough that the math works? Is it mostly rules with judgment at the edges, not the reverse? Four yeses means build it. A no means fix that first, or leave the process to a human.
I run every automation decision across my portfolio through this check before writing a line of it, with agents from Girard AI. It saves me from the most common and most expensive failure in this whole field: pouring effort into automating something that was never ready, and ending up with a faster version of a mess.