The Challenge
Deals were being lost not on price, but on speed. A competitor's quote often reached the customer's desk first, and for the most complex, multi-division bids, matching it could take three to four weeks. Thousands of SKUs lived across catalogs that didn't share item numbers, naming conventions, or units of measure, forcing manual re-keying and cross-referencing on every bid, with accuracy hovering around 70-80%. The result: customer frustration, growing backlog, and a real disadvantage on exactly the deals that mattered most.
Why We Didn't Replace the ERP
The tempting answer to "our system is old and slow" is a multi-year replatforming program. We deliberately did the opposite. The legacy ERP is imperfect, but it is the system of record: every customer, contract, price level, and purchase history lives in it, and it is not going anywhere. Ripping it out would have meant years of risk before a single salesperson got faster.
Instead, we built a focused speed layer on top: a modern web application that reads from and writes back to the existing landscape, and gives the sales representative everything on one screen, catalog, pricing strategies, contract terms, live prices, alternatives, attachments. The ERP keeps doing what it does; the people who race competitors every day got a tool built for racing.
This pattern, wrap the legacy core, attack the highest-value workflow first, delivered value in months instead of years, contained the risk, and, just as important, built the client's trust incrementally. Every release made someone measurably faster, which is what earned us the mandate for the more ambitious parts described below.
How It's Built
The platform is a .NET Core modular monolith with a React + TypeScript frontend, structured as vertical slices: each business module owns its full stack, from API and domain logic to its own frontend package that plugs into a shared application shell. Long-running work runs as background jobs, real-time events are pushed straight into the browser, and one codebase supports multiple database engines.
None of this is exotic, and that is the point. The stack is deliberately boring so that the complexity budget could be spent where it actually pays off for the client: the quoting workspace and the cross-reference engine.
A Quoting Workspace Built for Speed
The heart of the application is the quote detail screen, the place where a sales representative finally has everything on the table. One editable grid holds the quote items; around it sit pricing breakdowns, costing strategies, related-quote groupings, promotions, attachments, and a full integration log for transparency.
- Bulk item entry from anywhere. Items can be pasted straight from the clipboard, imported from spreadsheets, multi-selected from the catalog, or added as placeholders to be resolved later, with instant, server-paged catalog search.
- Adaptive grids. The item grid assembles its columns from distinct sets (own items, alternatives, competitor data) and hides whole column groups until the data says they are relevant.
- Inline editing everywhere. Prices, price levels, overrides, and alternative items are edited directly in the grid, with no dialogs between the rep and the number.
- Long-running work as jobs, not spinners. Heavy operations run as backend jobs; the UI polls resiliently, survives a page reload, and delivers the result when it is ready.
Individual page sections are isolated behind error boundaries, so a failure in one panel degrades that panel, not the rep's entire quote. Small decisions like this are what "production-grade" actually means.
The Real Bottleneck: Competitor Quotes
Once quoting itself was fast, the true constraint became visible, and it was exactly the one the client had learned to live with. Deals in this market frequently start with a competitor's quote in the customer's hand: "Here is what they offered me. Can you beat it?" For the most complex, multi-division competitive bids, that used to mean three to four weeks of back-and-forth before a number went back to the customer.
Those quotes arrive through a large number of channels and in every imaginable shape: PDFs, scanned images, spreadsheets, email attachments. Turning one into a counter-offer used to mean manually re-keying hundreds of line items and then finding the matching or equivalent product for each one, across catalogs that do not share item numbers, naming conventions, or units of measure. The result was predictable: the competitive cross-reference was rarely done at all. It was the highest-value activity in the sales process, and it was the one the old system made effectively impossible.
This became the flagship feature of the platform: the cross-reference engine.
Ingesting Anything: The AI Extraction Pipeline
For document ingestion we made a deliberate buy-over-build decision, and it turned out to be one of the best calls of the project. Rather than building our own OCR and layout-understanding stack, we integrated a specialized AI document-extraction service and spent our engineering budget on the domain logic no vendor could give us.
The pipeline: a rep drags competitor files (PDF, image, or spreadsheet) onto the import screen and tags the session. Documents are processed asynchronously by the extraction service, which calls back into our API through a signature-validated webhook; the backend maps the extracted fields (item number, description, quantity, price, manufacturer, unit of measure) into session items, and the rep gets a real-time notification: "extraction complete". No polling, no babysitting.
The lesson we would give any CTO evaluating AI features today: buy the commodity capability, build the domain moat. Document extraction is a solved, competitive market. What happened next is not.
The Matching Engine: Deterministic First, AI Second
Extraction gives you clean competitor line items. The hard question remains: "which of our products is this?" Our matching engine answers it in two passes, and the ordering is a design principle, not an accident.
Pass one is deterministic. Every extracted item is checked against the distributor's accumulated cross-reference knowledge: known competitor item numbers, industry code tables, and manufacturer numbers. An exact hit is labeled as such and traced to its source, so the rep can always see why the system matched something.
Pass two handles everything the tables don't know. Competitor descriptions are cleaned, normalized, and scored against the catalog using an approach we developed specifically for this domain, backed by a hand-built dictionary of industry vocabulary that grew with the project. The strongest candidates are presented as ranked suggestions with confidence scores. We will keep the exact recipe to ourselves, but the part worth sharing is this: the real intelligence is accumulated domain knowledge, not a generic algorithm, and that is exactly why it cannot be bought off the shelf. It is the moat.
A human stays in the loop. Matches are reviewed in an editable grid; a match popup shows the competitor's line next to the proposed item, the ranked candidates, alternative options, and the history of how this manufacturer number was matched before. Rejected and corrected matches feed a curation flow, so the engine's knowledge base improves with every session it processes.
Push to Quote, and Making the Engine Accountable
The payoff moment is deliberately anticlimactic: one click pushes the entire reviewed session, hundreds of matched line items, into an existing quote or a brand-new one, and the rep lands on the quote screen with the counter-offer already built. Work that used to take days, when it happened at all, now takes minutes.
A matching engine that management cannot inspect is a demo, not a product. The cross-reference dashboard tracks the funnel in plain numbers: files processed and converted, exact matches vs. AI matches vs. no matches, and approval rates, filterable by period and exportable to a spreadsheet for the Monday meeting.
The Results, By the Numbers
The numbers below reflect the same engagement described throughout this post, measured after the platform went into production.
| Metric | Before | After |
|---|---|---|
| Quote turnaround | 4 business days | Under 2 days |
| Quotes processed / month | ~200 | ~400 |
| Match accuracy | 70-80% | 90%+ |
| Team size for the desk | 9 | 5 |
The clearest proof point came under pressure, not in a demo: during a backlog spike shortly after launch, the team cleared hundreds of stuck bids in two weeks, work that would have taken months at the old pace.
Where This Lands
The project started as "make our salespeople faster" and ended as something the client did not believe was on the table: a workflow where a competitor's scanned quote becomes a fully priced, fully matched counter-offer in one sitting. The trust built along the way is why the platform keeps growing on the same modular foundation.
And none of it is specific to one industry. Any distribution business with a legacy ERP, a large sales force, and competitors' documents landing in inboxes (medical, industrial, electrical, food service) has this exact shape of problem. The architecture, the ingestion pipeline, and the deterministic-then-fuzzy matching pattern transfer directly.
Dragiša Đulić