An ERP configurator that automates 90% of custom orders.
Problem
Custom manufacturing orders were a manual bottleneck. Every bespoke configuration had to be interpreted, priced, and entered by hand into the ERP: slow, error-prone, and entirely dependent on a handful of people who knew the rules in their heads.
The fix had to live inside a production Epicor ERP that the whole company already ran on. There was no room for "rip it out and start over." It had to extend the system in place, safely.
What I built
- A rules-driven product configurator. The logic that lived in experts' heads (valid options, dependencies, pricing) became an explicit, maintainable configurator inside the ERP.
- C# business process methods. Custom BPMs extend Epicor's order flow directly, validating and generating configurations as part of the real process rather than bolted on beside it.
- Automated order generation. A valid configuration flows straight through to a correctly-structured manufacturing order, removing the hand-entry step entirely.
- Built for a live system. Shipped into production carefully, alongside the operations that depend on the ERP every day.
The next bottleneck
The configurator solved order entry. It did not solve configurator creation. Every new product still had to be built by hand inside Epicor: inputs added one at a time, UD methods typed into the rule editor, material rules attached row by row, then the method of manufacture and bill of materials keyed into Engineering Workbench. Days of clicking, and the kind of work where one mistyped input name fails silently at runtime.
The spec already existed on paper. Product engineers fill in an intake document with the inputs, dropdown options, part number structure, part swaps, operations, and materials. The whole gap was between that document and the ERP.
What I built, part two
A Claude Skill that reads a filled-in intake document and emits a complete, importable configurator.
- Intake document in, configurator out. One intake workbook produces the full configurator XML: inputs, page layout, UD methods, dropdown lists, and material rules.
- Straight into Epicor. The XML imports through Configurator Entry, Actions, Import. Nothing is built by hand in the rule editor.
- MoM and BOM ready to paste. The same run emits an Engineering Workbench workbook with Operations and Materials sheets per assembly, plus a lookup table CSV when the product needs dropdown or compatibility data.
- Generated C#, not templated C#. Part number concatenation, keep-when conditions, quantity formulas, and whole-part swaps are translated from plain-language intake entries into the C# the configurator actually runs.
- Deterministic where it has to be. The model writes a JSON spec; Python builders emit the XML from it, so GUIDs, escaping, and sixty-odd fields per row are machine-generated. A validator checks every cross-reference before anything reaches Epicor.
Why it holds up
Generating XML is not the hard part. The hard part is knowing the rules that make an imported configurator actually work: which event a numeric input can use without firing on every keystroke, why a blocking validator has to throw instead of showing a message box, how a lookup query has to self-join to return its own values.
Those rules live in a reference the skill reads before it writes anything: about 2,000 lines of format rules, C# patterns, and known Epicor gotchas, sitting on top of 1,750 lines of Python that build and validate the output. Every failure found in a real import gets written back as a rule, and an audit step re-checks existing specs against the current version.
Stack
Working inside an enterprise ERP means the constraints are the work: existing data, existing process, zero tolerance for breaking live operations.
The AI layer sits outside the ERP, not inside it. Claude reads the intake and writes a spec; deterministic code turns that spec into the artifacts Epicor imports. Nothing reaches production that a validator has not checked first.
Outcome
The configurator automates roughly 90% of custom manufacturing orders, converting a manual, expert-dependent bottleneck into a consistent, rules-driven flow inside the system the business already trusted.
The skill removes the step behind that one. A new product goes from intake document to an importable configurator, method of manufacture, and bill of materials in a single pass, instead of days of manual build inside Epicor.