Most automations that go wrong didn't fail because the technology broke. They failed because the process underneath was never clear in the first place. Someone automated what they assumed the workflow was, and the gap between the assumption and the reality showed up later — as an email sent to the wrong person, a step that quietly got skipped, an exception nobody planned for.
The fix is unglamorous and it works: map the process before you build anything. Not a forty-page document — a clear, one-page picture of what actually happens. This is the lightweight framework we use, and you can run it yourself on any messy process in an afternoon. You'll learn things about your own operation that surprise you, whether or not you automate a single step afterward.
Step 1: Identify the trigger
Every process starts with something. A form gets submitted. A deal is marked won. A client sends a document. The month ends. Find the one event that kicks the whole thing off and write it at the top of the page.
This sounds obvious, but it's where a lot of clarity comes from. Sometimes you discover there isn't one clean trigger — the process starts in three different ways depending on the source, and each path is handled a little differently. That's not a problem; it's exactly the kind of thing you want to know before you build, not after.
Ask: what has to be true for this process to begin? If you can't name it precisely, you've found your first leak.
Step 2: List the steps
Walk the process from trigger to finish and write down every step, in order, in plain language. One line each. Don't editorialize, don't optimize yet — just capture what happens.
Two rules make this useful:
- Be honest about reality, not the ideal. Write down what actually happens, including the workaround someone does every time because the official way is broken.
- Name who does each step. "Sarah checks the inbox." "The account manager updates the sheet." Steps that don't have an owner are steps that fall through.
When you're done, you'll often have more steps than you expected. That's normal. The act of listing them is the first time most teams see the whole thing in one place.
Step 3: Mark the decision points
Go back through your list and mark every place where the path forks — anywhere the next step depends on a condition. If the client is on a retainer, skip billing. If the form is incomplete, send a reminder. If the deal is over a certain size, route it to a senior person.
Decision points are the heart of a process. They're also where automations most often go wrong, because the person who runs the process knows the rules instinctively and never says them out loud. Writing them down forces the unspoken logic into the open.
For each decision point, get specific about the rule. "We handle big deals differently" isn't a rule a machine — or a new hire — can follow. "Deals over a certain value go to the senior team" is.
Step 4: Mark where a human must stay in control
This is the step that separates good automation from reckless automation. Go through the map again and mark every point where a person must make the call. These are the checkpoints you'll protect, never bypass.
Some reliable signs a step needs a human:
- It's client-facing in a way that affects the relationship — a sensitive message, a tricky conversation, anything where tone matters.
- It involves money, legal commitments, or anything hard to undo.
- It requires judgment — weighing factors a rule can't fully capture.
- The cost of getting it wrong is high even if it's rare.
Marking these now means you design your automation around them on purpose. The machine handles the repetitive work and hands off cleanly to a person at the checkpoints. That's the whole idea — automation removes the busywork so your people spend their attention where judgment and relationships actually live.
Step 5: Find the leaks
Now look at the finished map and hunt for the weak spots. They tend to hide in predictable places:
- Manual handoffs. Anywhere work waits for a person to notice it — an inbox that gets checked twice a day, a "let me know when you're done" that depends on memory.
- Duplicate data entry. The same information typed into two or three systems. Every retype is a chance to introduce an error.
- Undefined branches. A decision point with no clear rule, handled by gut feel each time.
- Single points of failure. A step only one person knows how to do.
- Dead waiting time. Stretches where nothing happens because the process is stalled on a form, an approval, or a reply.
These leaks are your automation roadmap. They're where the time is lost and the errors creep in, and they're usually the highest-value places to start.
What you do with the map
Once you can see the whole process on one page — trigger, steps, decisions, human checkpoints, and leaks — three things become possible. You can delete steps that no longer earn their place. You can automate the repetitive ones with confidence. And you can protect the human judgment by design instead of by accident.
This is exactly how we begin every engagement: Scope before we build, the map agreed and written down, so what we automate is the real process and not a guess. The document is yours to keep.
If you've got a process that feels messier than it should, try running these five steps on it. And if you'd rather not map it alone — or you want a read on which leaks are worth fixing first — bring us the mess and we'll draw it up with you.