← Blog
Automation
August 5, 2026 · 4 min read

Where to start with automation: finding the costliest link

Rather than automating everything at once, find the single step that eats the most hours each week and begin there.

Automation

Automation projects fail in two ways: they start too big and never finish, or they automate a task that wasn't costing anyone time. The cure for both is the same: count before you begin. Here is how we run that count, how we pick the first flow, and which tasks we leave alone.

A one-week tally

Ask your team to note repetitive tasks for a week: what was done, how often, how many minutes. The resulting list is usually surprising; the task that takes the most time may not be the one everyone complains about.

No special tool is needed. A shared table will do: the task, how often it was done, how many minutes each time, and who did it. Four columns, nothing more. The tally is there to show where the effort goes, not to monitor anyone; say so at the start and the table gets filled in far more honestly.

A practical note

Write each task down as you do it, not from memory at the end of the week. What sticks in the mind is the most irritating task, not the most frequent one. Pick an ordinary week, too: a campaign or holiday week misleads.

Working out the time you would save

The sum is simple: frequency times minutes. A three-minute task done twenty times a day adds up to an hour a day; a half-hour task done once a month drops to the bottom of the list. Take the figures from the table, not from guesswork.

Remember two corrections. First, add the time spent fixing mistakes; a wrongly typed address costs more than those three minutes. Second, don't assume automation hands all of that time back, because a person will still deal with the exceptions. In the first call we do this sum with you, and if the saving doesn't cover the effort of building the flow, we say so.

What a good first candidate looks like

  • Its rule is clear: it can be described as “when this happens, do that”.
  • It repeats often: at least several times a day.
  • Data gets copied from one system into another.
  • Mistakes take a while to notice.

Entering order details into accounting software, sending a welcome email to a new customer and compiling the weekly report are typical examples.

An example: from order to shipping

Picture a business that sells online. For every order, someone copies the details into the accounting software, issues the invoice, creates the shipping label on the courier's screen and sends the customer the tracking number. Four separate screens; the same name and address handled four times. Turned into a flow, meaning steps that trigger one another on their own, the job runs like this:

  1. 1

    A paid order starts the flow.

  2. 2

    The invoice is created in the accounting software from the order details.

  3. 3

    A shipping label is fetched from the courier, ready to print.

  4. 4

    The customer receives an email or message with the tracking number.

  5. 5

    Every step is logged; if one stalls, the flow's owner is notified.

We don't build all five steps at once. First only the order-to-invoice part runs; once that has settled we add shipping, then the customer notification. That way, when something goes wrong, nobody has to hunt for the link that caused it.

What not to automate

  • Rare tasks: a flow built for a job done a few times a year never repays the effort of building it.
  • Tasks that need judgement: accepting a refund request or granting a special discount doesn't fit into a single rule.
  • Processes that are still changing: automate a job whose steps are debated afresh every month and you will rebuild the flow every month.

Even where judgement is needed, a flow can do one thing: the preparation. It gathers the relevant details on a single screen and, if you wish, drafts a reply with AI; a person still makes the decision.

Build small, keep logs

Reduce the first flow to a single job and log every run. If a flow breaks silently and you notice days later, automation ends up costing more than doing it by hand.

One thing matters as much as logging: ownership. Every flow needs a single named owner. They needn't be technical; they know what the flow does, receive the error notification, and say when the flow must change because the process has.

A flow without an owner sooner or later becomes a mistake that nobody notices.

Once the first flow has run cleanly for two weeks, move to the next link. By cleanly we mean that nobody feels the need to check the result by hand, notifications are rare and understood, and the team has no thought of going back to the old way. Choosing the next candidate takes no new tally; the second row of that first week's table is waiting.

At that pace, a few months later your team has won back hours every week and everyone knows what each flow is for. Our advice never changes: count first, then start with a single link.

Work with us

Have a project in mind?

Describe your idea in a few sentences. We'll review it and come back shortly with scope, timeline and budget.