How to Document a Manual Workflow Before Automating It
Published
TL;DR: Document one recurring workflow by writing its trigger, goal, steps, systems, exceptions, inputs, outputs, dependencies, and human judgment points, then compress that into a short brief a builder can use to compare automation options.
Start with one recurring workflow
Pick one recurring workflow. Keep it boring on purpose.
Write the workflow in plain language with three parts:
- Trigger: what starts the work
- Goal: what the team is trying to finish
- Final output: what “done” looks like
Example: “When a customer order is marked paid, the operations lead checks stock, sends a confirmation email, and logs the order in the tracking sheet.” Trigger, goal, final output. No mystery sauce needed.
If you need help deciding which recurring tasks are worth documenting first, the automation scorecard is useful because it gives you a quick screen before you spend time mapping the work.
Map the workflow step by step
Write the process from start to finish, in order. Assume the reader knows nothing. Assume no tribal knowledge. Assume the person who usually does the task is on vacation and only reachable through one vague Slack emoji.
Include the steps, systems, exceptions, inputs, outputs, dependencies, and human judgment points. If the workflow has a branch, note the branch. If someone waits for a reply, note the wait. If a file gets renamed, note that too.
A useful format is:
- Trigger arrives.
- Person A opens system X.
- Person A checks field Y.
- If condition A is true, do step 5. If not, do step 8.
- Send item to Person B for approval.
- Person B approves or rejects.
- If approved, continue. If rejected, stop and notify requester.
- Log exception and close out.
The goal is simple. A stranger should be able to follow the workflow without asking where the file comes from.
Capture the details automation needs
Once the skeleton is there, add the details a builder would need to understand the workflow properly.
Record:
- Who does each step
- Which systems they use
- What data they read or enter
- What decisions they make
- Which parts still need human judgment
This is where documentation stops being a note to self and starts being something an automation builder can use. “Someone checks the order” is too vague. “The operations lead checks whether the order contains a backordered item in the inventory system and whether the customer is marked priority” is useful.
TaskDrain says, “Tell TaskDrain what tools you run and what you do by hand every week. It maps your workflows, scores each one for automatability, ranks them by hours saved vs. effort, and sketches the exact n8n/Make/Zapier recipe for your top opportunities.” That is the level of detail your notes should support, even if you are only documenting for now.
Separate mechanical steps from judgment calls
Document the workflow with its steps, systems, exceptions, inputs, outputs, dependencies, and human judgment points.
Mechanical steps are the ones a system could repeat exactly. Examples:
- Copy data from one place to another
- Check whether a field is blank
- Send a standard message
- Create a ticket or file a record
Judgment calls are the parts that depend on context or experience. Examples:
- Deciding whether a customer exception is safe to approve
- Interpreting a messy email
- Choosing between two contradictory records
- Handling a one-off case that breaks the normal rules
This split matters because only the repeatable portion belongs in the automation target. If a workflow still needs a human in the loop for judgment calls, document that boundary clearly. TaskDrain says it counts the mechanical portion as saved when a human is still required.
Note inputs, outputs, and dependencies
A workflow does not live alone. It starts somewhere, consumes something, produces something, and usually depends on other work happening before or after it.
Document three things:
- Inputs: what enters the process, such as forms, emails, spreadsheet rows, tickets, or exported files
- Outputs: what comes out, such as confirmation emails, updated records, reports, or tasks for another team
- Dependencies: what must happen upstream or downstream for the workflow to work
Also note where the work starts. Is it triggered by an email, a calendar event, a CRM status change, or a human checking a queue? That detail matters because it tells you what can be monitored later.
If the workflow depends on another manual step, write that down too. Automation breaks in the boring places first, usually because nobody documented the handoff.
Record frequency, volume, and pain points
Add the operational details that help with prioritization.
Capture:
- How often the workflow happens
- Roughly how many items go through it each time or each week
- Where delays usually happen
- Where errors usually happen
- What part slows the team down the most
You do not need fancy measurement to make this useful. Even simple notes like “happens daily,” “gets stuck waiting for approval,” or “errors appear when the email subject line is inconsistent” help a lot.
TaskDrain says its rankings are based on hours saved versus effort. That is a good reminder to document what actually consumes time, not just what feels annoying at 4:55 p.m.
Worked example: document a manual order-confirmation workflow
Here is a simple example you can copy and adapt.
A small team receives paid orders by email, checks stock, confirms the order, and updates a tracking sheet.
| Trigger | Steps | Systems used | Exceptions | Human-only judgment point |
|---|---|---|---|---|
| Order marked paid in the storefront | 1. Operations lead opens the new order. 2. Checks the item against inventory. 3. If stock is available, prepares confirmation. 4. If stock is missing, flags the order for review. 5. Sends confirmation email. 6. Updates the tracking sheet. | Storefront admin, inventory system, email, spreadsheet | Backordered item, missing customer address, duplicate order | Decide whether a stock mismatch can be resolved by splitting the order or needs a manual customer reply |
Notice what the table does. It makes the workflow readable without the backstory. It also shows the boundary between repeatable work and judgment. That is the part builders need most.
Turn the notes into an automation-ready handoff
Once you have the notes, compress them into a short process brief or process map.
A good handoff usually includes:
- Workflow name
- Trigger
- Goal
- Final output
- Step-by-step map
- Systems involved
- Inputs and outputs
- Exceptions
- Human decision points
- Frequency and pain points
- Anything that blocks automation today
Keep it short enough that someone can scan it, but complete enough that they can compare options and sketch an automation. If you later want to compare documented tasks and decide which ones deserve attention first, the automation scorecard helps because it gives you a quick screening pass before you spend time building anything.
If you want a practical shortcut, TaskDrain’s free tools follow the same logic: describe the manual work, score the opportunity, and separate the part a system can repeat from the part a human still has to touch. That is the right shape for handoff notes, too.
A simple final format looks like this:
Workflow brief
- Name: Paid order confirmation
- Trigger: Order status changes to paid
- Goal: Confirm the order and log it
- Systems: Storefront, inventory system, email, spreadsheet
- Inputs: Order details, stock status, customer email
- Outputs: Confirmation email, updated log
- Exceptions: Out-of-stock, missing address, duplicate order
- Human judgment: Resolve stock mismatches and customer-specific edge cases
- Frequency: Daily
- Pain points: Waiting on stock checks and manual logging
That is enough for a builder to compare approaches and sketch a first automation without guessing what the workflow actually does. Which is the whole point. Less guessing, fewer broken automations, fewer “why did this send twice?” moments.