You fixed one bottleneck. Five more are waiting.
Say you automated purchase order intake. POs that used to take fifteen minutes to key in now land in the ERP in seconds, errors are down, and the order desk isn't the ceiling on how much you can sell anymore.
That's a real win. The mistake most operations teams make next is treating it as a one-off — closing the ticket and moving on to whatever complaint is loudest this month.
But the knowledge baked into that first automation didn't just solve PO intake. It proved a pattern. Manufacturing has at least five more processes built from the exact same bones: a document arrives in some inconsistent format, someone extracts data from it by hand, keys it into a system, and occasionally gets it wrong. Accounts payable. Inventory reordering. Quality records. Shipping paperwork. Quoting. The documents differ. The shape of the problem doesn't.
The job now isn't to invent a new solution for each one — it's to stamp out the pattern that already worked.
What actually transfers from the first win
Don't assume the next automation needs a new design from scratch. Most of what made the first one work is reusable:
- The extraction step. However you taught the system to read a messy PO — layout-agnostic document processing — reads invoices, packing slips, and material certs the same way.
- The validation rules. Checking a PO against your catalog and a customer's contract price is structurally the same move as three-way matching an invoice against a PO and a receiving record.
- The exception path. The rule that routes an unknown part number or an impossible date to a person instead of failing silently is the same rule that should catch a quantity mismatch on an invoice or an out-of-spec reading on a quality record.
- The sign-off. Someone still approves the output. Who signs, and on what, changes. The fact that a human closes the loop doesn't.
What changes between processes is the data fields, the source system, and who sits in the exception queue. What doesn't change is the architecture. Rebuild that architecture from zero every time, and you're paying full price for the one thing you already own: the pattern.
- 1Document arrives (PO, invoice, cert, packing slip)
- 2Extraction reads it regardless of format
- 3Validation checks it against the system of record
- !Mismatch found — old process: buried in someone's inbox
- 5Clean match flows straight through
- 6Exception routes to a named person with the issue flagged
That flagged step is the one worth studying hardest. In the old manual process, exceptions were invisible — just more paper in a pile. In a well-built automation, they're visible, assigned, and fast to resolve. If your first automation got that part right, you've already solved the hardest design problem for every process after it.
Turn the win into a template, not a memory
Before you touch the next process, write down what made the first one work — while the team that built it still remembers the decisions, not just the outcome.
This isn't bureaucracy for its own sake. It's the difference between a second automation that takes six weeks because someone's rediscovering lessons from the first, and one that takes two because the template's already written.
If you haven't settled on the right vehicle for locking in a win — SOP, template, or full automation — that choice deserves its own pass. See SOP, Template, or Automation: The Right Way to Lock In a Win for how to pick.
Pick the next target with the same discipline, not momentum
A common failure mode: the team that just won on PO intake gets asked "what's next?" and answers with whatever's top of mind, not whatever scores best. Don't let the first win set the agenda by accident.
Re-run the same scoring you used the first time — volume times time times error cost, against how standardized the process is and how accessible the systems are. Accounts payable usually scores high on both axes for the same reason order intake did: it's high-volume, painfully manual, and the systems it touches (your ERP, your AP ledger) are ones you already integrated for the first automation. That's often the fastest second win, because half the plumbing already exists.
Inventory replenishment and quality documentation tend to score lower on feasibility at first — not because they're less valuable, but because the underlying process is messier and needs trimming before it's ready to automate. That's a different problem, worth its own planning pass. If you're weighing which method actually fits each candidate — document extraction, system integration, rules-based automation, or something that needs AI judgment — RPA, Integrations, IDP, or AI Agents: Picking the Right Method walks through the decision.
| Lock-in | Choose it when | Watch out for |
|---|---|---|
| SOP | The win depends on people following steps and making judgment calls. | A document nobody opens — keep it to one page with a named owner. |
| Template | The work repeats with small variations: emails, quotes, checklists, reports. | Copies drifting apart — keep one master and retire old versions. |
| Automation | The steps are stable, rules-based, and frequent enough to pay back the setup. | Automating before the process is settled, and no one watching for failures. |
What the cycle looks like in practice
Picture a plant that automated PO intake first — illustrative, not a specific client. The second round isn't a repeat of the first project; it's a shorter version of it, because the pattern is already proven.
Notice the loop doesn't end at "it worked." Each round should leave the template a little better — a validation rule that was too strict, an exception category nobody anticipated, a handoff that took longer than planned. That's the information that makes round three faster than round two.
Scale the pattern, then close the loop
One more place teams leave value on the table: they build the second automation for one line or one plant, confirm it works, and stop — instead of asking whether the same template now belongs on every line that runs the same process.
If three plants all process supplier invoices the same way, the AP automation you just proved at one of them is very likely a fit for the other two with minor configuration, not a rebuild. Scaling a working automation across more of the business without forking it into five slightly different versions is its own discipline — worth a careful look before you duplicate effort by accident.
A single successful automation is a data point. A documented pattern, reused deliberately across the next process and the one after that, is a system — and systems compound. Every round should leave you with a faster playbook for the next one, not just a working tool and a blank page.
Once you've got two or three automations running on the same pattern, it's worth stepping back and sequencing what's left deliberately rather than picking the next one by instinct. The 90-Day Plan: Turning Your Tech Wish List Into Progress is a reasonable place to do that sequencing before you commit to round three.
The paperwork factory inside your plant isn't one problem — it's the same problem showing up six times. Solve it once, write down how, and the rest gets cheaper every time.
