Why Your Team Retypes the Same Data Twice

An order arrives. Somebody enters it into the system that takes orders. Then somebody enters the same information into the system that schedules the work, and later a version of it into the one that raises the invoice.

Nobody defends this. Everybody has stopped noticing it, which is worse.

The cost is not the typing

Ten minutes a day sounds trivial and the typing is the smallest part of it.

The real cost is that the two copies diverge. A change made in one place does not reach the other, so the schedule reflects an order that changed on Tuesday and the invoice reflects neither. Then a person has to work out which version is right, which takes far longer than the original entry, and happens at the worst moment, usually in front of a client.

Second cost: it happens last. Re-entry is nobody’s priority, so it slides to the end of the day and then to tomorrow. The second system is therefore always behind by an unknown amount, and every decision made from it is made on stale information.

Third: the person doing it is usually the person you would rather have doing something else.

Why it survived this long

Not because nobody noticed. Because the fix was disproportionate.

A proper integration between two systems is a real project: mapping fields, handling the cases where one system has a concept the other does not, deciding what wins when both change, and maintaining it when either vendor ships an update. For a task consuming forty minutes a day, that arithmetic rarely worked, particularly when one of the systems is old or has no usable interface.

So the sensible decision, repeated in thousands of businesses, was to leave a person doing it. That was correct at the time.

What changed the arithmetic

Two things, and one of them is measurable.

Stanford’s AI Index for 2025 reports that the inference cost for a system performing at the level of GPT-3.5 dropped over 280-fold between November 2022 and October 2024. That is the cost of asking a machine to make one small judgement, and it fell by more than two orders of magnitude in under two years.

That number matters here because it is exactly what re-entry consists of: thousands of tiny judgements. What field is this. Is this the same customer as that one. This says 15/03 and the other system wants a date, which format is it. This is written as “approx 40 units”, what number goes in the quantity box.

When each of those cost real money, automating a forty minute task made no sense. At current prices, the entire day’s re-entry costs less than the coffee, and the project that was disproportionate is now a week of work.

The second change is that AI does not need a clean interface. It can read the email, the PDF, the photograph of a delivery note or the message in a chat, and produce structured data from it. Half the integrations that were never built failed because the input was not structured, not because the systems could not talk.

What this looks like when it works

The order arrives in whatever form it arrives. It gets read, understood and written into every system that needs it, once, within seconds.

Where something is genuinely ambiguous, a person is asked one specific question rather than being handed the whole task. Where a change is made later, it propagates rather than requiring somebody to remember the second copy exists.

And there is a record of what was written where, so when a figure is disputed you can see what arrived and what each system did with it, instead of reconstructing it from memory.

The version that goes wrong

One failure mode is common enough to name, because it turns a good project into a worse situation than the manual one.

The system reads the input, is unsure, guesses anyway, and writes the guess into three places without telling anybody. The person who used to do the typing is no longer looking, so nothing catches it. Now you have wrong data moving at speed, which is considerably more expensive than right data moving slowly.

The fix is a rule, not a technology: anything below a confidence threshold stops and asks. A system permitted to say it is unsure can be trusted with the rest. One that always produces an answer cannot be trusted with any of it, because you have no way of knowing which answers were guesses.

Ask about this specifically before anybody builds you anything.

Where to start looking

Ask your team a single question: what do you type into more than one place. You will get a longer list than you expect, and it will include things nobody has ever mentioned because they assumed it was normal.

Then rank by frequency rather than by irritation. The daily one that annoys nobody is worth more than the monthly one everybody complains about, because the monthly one happens twelve times a year and the daily one happens two hundred and fifty.

The check that decides it

• Does it happen at least daily. Below that, the build outlives the benefit.

• Is the input consistent enough to describe. Not identical, describable.

• Is there one obvious answer most of the time. If half the cases need a decision, automate the other half and route those.

• Would being wrong be visible. If a mistake would surface immediately, you can move faster; if it would sit undetected in an invoice, build the check first.

Most re-entry tasks pass all four, which is why they are usually the best first automation a business does. Small, daily, obviously worth it, and nobody in the building will defend the current arrangement.

Sources

• Stanford Institute for Human-Centered Artificial Intelligence, Artificial Intelligence Index Report 2025. “The inference cost for a system performing at the level of GPT-3.5 dropped over 280-fold between November 2022 and October 2024.”

AI Optimize reads what arrives in whatever form it arrives and writes it into every system that needs it, once, with a record of what happened. That work sits under Workflow Automation.