Skip to content
← TaskDrain Blog

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:

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:

  1. Trigger arrives.
  2. Person A opens system X.
  3. Person A checks field Y.
  4. If condition A is true, do step 5. If not, do step 8.
  5. Send item to Person B for approval.
  6. Person B approves or rejects.
  7. If approved, continue. If rejected, stop and notify requester.
  8. 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:

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:

Judgment calls are the parts that depend on context or experience. Examples:

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:

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:

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:

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

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.