Walk into a machine shop, a plastics plant, a commercial bakery, or a metal fab shop that has been running since the Clinton administration, and somewhere in the back office there is a monitor showing amber or white text on a black field. A green screen. The ERP behind it might be AS/400 lineage, an old MRP package, something a vendor stopped supporting a decade ago. The owner usually apologizes for it. He shouldn't. That box has been quietly writing down everything that happens on his floor for twenty or thirty years, and almost nobody has read a word of it.
That is the part worth sitting with. The system already knows.
What the old system has been writing down
These systems were built to run production, and to run production they had to record it. Every job has a router. Every operation on that router has a standard time and an actual time. The system stamps when a job started and when it closed. It tracks the estimate the shop quoted against the hours the job actually ate. It logs changeovers, scrap, rework, machine downtime, and who was on the clock. Thirty years of that is a ledger of exactly where time and money leak out of the building.
Here is the catch. The reports come out as fixed-width text, printed to a spool file or dumped somewhere nobody opens. A job quoted at 40 hours comes in at 62, and that variance sits in a column on page nine of a Monday printout that goes straight to the recycling bin. The knowledge is in the building. It is just locked inside a format from 1994.
The trap is thinking you have to replace it
When an owner finally decides to do something about the old system, the first pitch he hears is rip-and-replace. New ERP. Cloud platform. An eighteen-month implementation, a systems integrator on retainer, and a number that starts around $200,000 per site and climbs from there. A fair number of those projects run long. Some never fully land, and the shop ends up running the old green screen in parallel anyway, because that is the system people actually trust.
We are not in that business, and most shops don't need to be either. The move that pays off first is smaller and far less violent: leave the ERP exactly where it is, and start reading what it already produces.
Read the exports, not the whole system
Almost every one of these systems can write a file. A nightly export. A scheduled report to a folder. A flat extract of jobs, times, and materials. That file is the doorway. You never touch the ERP's database, its screens, or its logic. You take the copy it is willing to hand out, and you turn it into three things that change how the shop makes money:
- A real baseline, built from your own history instead of a gut feel. Not "we're usually pretty good on brackets," but the actual spread: how long that part number has really taken across the last few hundred runs, and how wide the variation is.
- Honest estimates. When a quote comes in, you price it against what similar work has actually cost you, not against the optimistic standard someone typed in years ago and never revisited.
- A schedule that pivots. When a machine goes down or a rush job lands, the plan re-sequences against real run times and real due dates and hands the floor a new order of operations, instead of a foreman guessing under pressure.
None of that requires a new ERP. It requires reading the one you already own.
The captive pattern: nothing leaves, a human signs off
Shops are right to be nervous about bolting anything onto a system that has run the business for decades. So the safe version of this work has a shape, and we hold to it.
Nothing gets installed on the old system. It keeps doing its one job. We read a read-only export, a copy, so there is no path for our code to write back, corrupt, or slow down production. The data does not touch the public internet unless you decide it should; the whole thing can run on a box inside your own network. When the data legally or contractually can never leave the building, it doesn't. A captive, on-premise setup keeps every byte behind your own door.
And the software does not run the shop. It produces a recommendation, a schedule, a quote, a flag on a job that is trending over, and a person approves it before anyone acts. The logic that orders your jobs is deterministic code you could print out and read, not a black box making calls on the floor. No AI model has to live inside your building for any of this to work.
The point is boring on purpose: a read-only copy, deterministic logic, a person who signs off. If a pitch requires ripping out the system that runs your business, or shipping thirty years of job data to someone's cloud before it does anything useful, that's a much bigger swing than the problem usually calls for.
Measured against your own baseline, not a slide
Starting from the exports is what makes the proof honest. Because the history is right there, you can measure the new way against the old one on the same jobs. Run the estimator in shadow for a month: let it price quotes alongside your current method, and compare both against what the jobs actually cost. Put the new schedule next to the foreman's and see which one predicted reality.
Before-and-after against your own numbers beats any projection on a sales deck. You are not being asked to believe a percentage. You are watching the shop's own record settle the argument.
This is the work we do, and there is no price list for it because every plant's data is a little different. We're a small shop based in Sioux Falls, South Dakota, and for automation work we travel for the right price, so the plant doesn't have to be down the road. We start with a free discovery conversation to see what your system already exports and where the money is actually leaking. If it's worth doing, we prove it with a small pilot scoped to one real problem and measured in dollars, your baseline before and after, before anyone talks about a bigger build. Your thirty-year-old system already knows where the money is. The only open question is whether anyone is reading it.