Saving $400K and four QA hires in a two-week build

Replacing the workbook that ran the quality department

How a family-owned precision machining company moved from four duct-taped tools to one system for turning customer prints into control plans — a two-week build that saved roughly $400K and the four QA hires the shop would have needed to grow.

The customer

A precision turned-parts manufacturer in Texas. Family-owned, in business for decades, machining small components for OEMs across defense and commercial markets. ITAR environment: prints can be export-controlled technical data, vendor-facing copies must be sanitized, and the company is on a path to CMMC Level 2.

Their quality department carries the kind of knowledge that does not exist in any textbook. How plating shifts a dimension. When the shop chooses to run tighter than the customer requires, and how that gets documented so good parts do not get scrapped. Which gage note tells an operator exactly how many turns a thread gage must go.

The problem

Before the shop can machine a part, a quality engineer must convert the customer's engineering print into a control plan: the document that tells the floor what to inspect, with which gage, how often, against what limits.

That conversion ran through four tools. A ballooning system to letter the print. An Excel workbook, thick with VBA, to do the tolerance math. A PDF editor to redact prints for vendors. A legacy ERP to receive the output.

The workbook was the real system. It encoded decades of shop practice, and it was fragile: fourteen saved versions in circulation, formats two people could maintain, and at least one live math bug that silently applied the wrong branch of a calculation. Every print cost a quality engineer hours. Mistakes reached the floor as wrong limits or missing inspections.

The company had tried to fix this internally. That effort produced a thorough requirements document and no software.

The build

We built the domain engine before we built the application. Week one was not spent on screens. It was spent reverse-engineering the workbook, the shop's printed control plans, and the quality engineer's worked examples into a reference implementation with roughly one hundred tests. The tests are the contract, down to exact error messages. The application renders state and calls the engine. It does not do math.

Three rules fell out of that work and became the architecture.

Units convert once. Metric prints compute entirely in native millimeters; conversion to inches happens at one point in the code, followed by one directional rounding. The most expensive legacy failure mode was a double conversion worth a ten-thousandth of an inch of silent error.

The document is the test. The shop's real printed control plan is checked into the repository as a golden fixture, and an automated diff compares the system's output against it character for character. "Looks close" is not an available claim.

AI proposes, humans decide. Machine vision finds candidate callouts on the print and a language model transcribes them verbatim, with a hard rule that it never computes, never converts, and never invents a value. A quality engineer curates every extraction. Nothing reaches the document of record without a person and a passing verification.

What it does

One application covers the path from print to package. A customer print comes in. The system produces the sanitized, export-marked print package, the lettered drawing, a control plan for each machining operation in the shop's exact printed format, the gage order with its four-gage pre-control sets, and an Excel handoff. Every derived value carries provenance: which rule produced it, from which printed tolerance. Every edit is re-verified live, and errors block approval.

Delivery

Version one went live in four days, built onsite next to the people who would use it. The lead quality engineer ran real parts through the system during the visit and worked the punch list with us in the room, line by line, against real prints.

His first reaction, watching a plan come together:

"That's a lot nicer than what we're currently dealing with."

Iteration now runs remotely against an agreed set of representative parts, with every delivery measured by the golden-fixture diffs.

The result

The whole thing was a two-week build, for roughly $400K. The shop was growing, and the plan had been to hire four more QA people to keep up with the volume of prints. Instead, one system now does the conversion the workbook used to, so those four hires never had to happen — and the quality engineers the shop already has spend their time on judgment, not data entry.

The pattern

Every shop has a workbook like this one. Somewhere in the building there is a spreadsheet, a binder, or one irreplaceable person holding the math that the whole operation quietly depends on.

The workbook was never the problem. It was the only place the knowledge lived. The work is extracting that knowledge into an engine that is tested, versioned, and owned by the customer, and then keeping people in charge of every decision that matters.

That is what we build.