Does your ERP purchasing module handle quoting? Almost — and the gap is the item master

The objection comes up in almost every conversation: “but our ERP already has a purchasing module.” It does. And it solves a big chunk of the process — purchase orders, approvals, inventory, finance, history. What it doesn't solve is the step that comes before all of that: turning five supplier replies, each in its own format, into a comparison you can trust. This piece explains exactly where the purchasing module stalls, why, and why the answer isn't switching ERPs.

What the ERP purchasing module does well

Let's play fair, because there's no strawman here. The ERP is the company's system of record, and at that it's irreplaceable:

• Formal purchase orders. Numbering, approval thresholds, tracking, an auditable trail.
• Inventory and replenishment. Stock on hand, reorder points, consumption curves, goods receipt.
• Finance and tax. Accounts payable, payment terms, invoice entry, tax treatment.
• Supplier records. Contracts, commercial terms, lead times, purchase history.
• One source of truth. In the end everything has to land there — and it will keep landing there.

None of that is in dispute. OrbitQuote does none of those things and has no intention to. The question is a different one: how the data gets there.

Why the ERP's comparison sheet is static

The purchasing module builds the comparison sheet from the item master. It assumes the product already exists in your database, with an internal code, and that the supplier's part number is already mapped to that internal code in a cross-reference. Given that assumption, comparing is easy: it's a lookup.

The problem is that the assumption is almost never true when quotes come in. Here's where it breaks:

• The item isn't registered. A one-off purchase, a maintenance part, jobsite material, a brand-new line. No code, so no row on the sheet. Someone has to open a record before anyone can compare.
• The supplier doesn't use your naming. What's “Hex bolt 1/2 x 2 ZN” in your database arrives as “HEX BLT 1/2X2 ZINC” from one and “M12 bolt 2in galv.” from another. Without the cross-reference in place, the ERP has no idea it's the same thing.
• The pack size changes. One quotes per piece, another per box of 50, another per thousand. The ERP compares the number it received; it doesn't normalize the unit on its own.
• The supplier is new. A supplier with no record doesn't make it onto the sheet — even though, quite often, that's exactly the one you want to discover.
• Equivalents go unrecognized. They offered another brand that works fine. To the ERP that's a different product, or no product at all.
• The channel doesn't cooperate. The module works best when the supplier answers inside the portal, in the expected layout. In real life they answer with a PDF, a spreadsheet laid out their way, a photo of a notepad and a WhatsApp voice message.

Add it all up and you get what we call a static sheet: it only compares what was registered beforehand, exactly the way it was registered. Anything outside that turns into manual work — typing, registering, mapping cross-references — done by a person, before the system starts helping at all. The purchasing module doesn't remove the work; it requires the work as a precondition.

What changes when the sheet builds itself

OrbitQuote flips the order. It doesn't ask for registration first: it reads what the supplier sent and identifies the products inside it. You upload each supplier's PDF, spreadsheet, photo or WhatsApp screenshot, and the comparison sheet is generated from that.

The part that makes the difference isn't reading the document — it's what comes next: recognizing that the item in quote A and the item in quote B are the same product, even written in completely different ways, and lining them up on the same row. Recognition is based on what the item is — description, specification, size, unit, pack — not on a code somebody mapped weeks ago. In practice:

• A new item makes the sheet. No prior registration, no internal code, no precondition.
• A new supplier makes the sheet. All they had to do was answer something.
• Units and pack sizes get reconciled. Piece, box, meter, thousand: the comparison happens on the same basis, not on the loose number that came on the page.
• The comparison is by total cost. Not by the lowest unit price in isolation, which is the classic trap — see how to compare quotes from multiple suppliers.
• The final word is yours. The result lands in a table for you to review, fix a description, merge two items, adjust a quantity. Reviewing is far faster than typing.

If you want to see the shape of the sheet itself, it's worth reading what a price comparison sheet is and how to build one. The difference here isn't the design of the table: it's who builds the table.

In the ERP, the sheet is a lookup against what you already registered. Here, the sheet is the result of reading what the supplier sent. The first depends on work done beforehand; the second doesn't.

Export: the data leaves in the format of whoever will use it

Identifying and comparing only pays off if the result can leave the tool. That's the second half of the problem — and it's where the ERP tends to lock things in: the data is born in there and comes out formatted the way the module allows.

In OrbitQuote the quote already comes out structured, with the products identified, and you pick the destination:

• Excel. The full list — code, description, quantity, unit, price — for the spreadsheet you always use. And if you adjust that Excel, you can send it back for a fresh extraction without throwing the work away. More on that in quote spreadsheet vs. AI tool.
• PDF. A comparison sheet ready to attach to a case file, send for approval or archive.
• WhatsApp-ready text, split by supplier. Because the reply goes back through the same channel the quote arrived on.
• Purchase order. Once the decision is made, the order goes out to the supplier, line by line, with whatever was picked from each one.

It's worth stating the boundary plainly, because that's what separates the two tools: OrbitQuote ends at generating the purchase order. Goods receipt, invoice entry, accounts payable and inventory stay with the ERP. We don't want that piece.

Public API and MCP: plug into what you already run

Here's the part that changes the ERP conversation. For a long time the question was “do you integrate with my system?”, and the honest answer is that dedicated integrations, built customer by customer, scale for nobody — least of all for you, waiting in line. So we went the other way: instead of integrating, expose.

There are two routes, and you pick based on what you already run in-house:

• Public API. Everything the platform does is available over the API: upload a document, follow the extraction, read the structured quote, pull the comparison sheet, fetch the purchase order. Whoever maintains your ERP consumes that data directly, in the shape your system expects, with no re-typing and no manual export-import.
• MCP server. MCP is the open standard AI assistants use to talk to external tools. With the OrbitQuote MCP server, the assistant your team already uses can see your quotes: you can ask in plain language which supplier came out ahead, request the comparison for a specific item, cross-check against a spreadsheet of yours or against your ERP — without anyone writing a line of dedicated integration code.

The practical effect is the same either way: OrbitQuote stops being one more system open in a tab and becomes a component of your operation. The quote comes in chaotic, goes out structured, and continues to wherever you actually work — the ERP, the spreadsheet, the assistant. You don't need to ask our permission or wait your turn on a roadmap: the door is open, and the last mile is however it makes sense at your place.

Head-to-head comparison

No make-up on either side — and remember, the two coexist:

Criterion	ERP purchasing module	OrbitQuote
How the sheet is born	A lookup in the item master; item and cross-reference must exist first	Generated from the document the supplier sent
Supplier format accepted	Portal, import layout or manual data entry	PDF, Excel, photo, scan, WhatsApp screenshot
Item outside the master	Doesn't make it in until someone registers it	Makes it in; identified by what the item is
Same product, different names	Depends on the cross-reference being ready	Lined up across suppliers with no prior mapping
Different units and pack sizes	Compares the number it received	Normalizes so the comparison sits on one basis
Output	The module's report, in the module's format	Excel, PDF, per-supplier text and purchase order
Connecting to the rest	Integration as a project, when it exists at all	Public API and MCP server, available
Orders, inventory, tax	Exactly what it's built for	Doesn't do it — ends at the purchase order

Note that the last row isn't a weakness hidden away: it's the division of labor. The ERP is good at record-keeping. Quoting is a decision step, with messy data, unpredictable formats and products nobody registered. Those are different problems, and a tool built for one is rarely good at the other.

If you're building the process from scratch, it's worth reading the procurement quotation process step by step first, to see where this stage fits. And the help center shows how to upload your first file.

Frequently asked questions

Doesn't the ERP purchasing module already build a quote comparison sheet?

It does, but starting from the item master. The ERP compares items that already exist in your database, with the supplier's part number already mapped to your internal code. If the item isn't registered, or the supplier sent it with a different description, pack size or brand, the line doesn't make it onto the sheet by itself — someone has to register or type it in first.

Do I have to replace my ERP to use OrbitQuote?

No. OrbitQuote is not an ERP and doesn't replace purchase orders, inventory, finance or tax. OrbitQuote is a process accelerator. It covers the step before: taking in the quote exactly as the supplier sent it, identifying the products, comparing by total cost and generating the purchase order. What comes out of it goes into your ERP.

How does OrbitQuote build the sheet with no prior item registration?

It identifies the product by what the item is — description, specification, unit, pack size — not by a code someone mapped weeks earlier. That lets it line up the same product across suppliers even when each one names it their own way, and put a brand-new item on the sheet without opening a record.

Can I connect OrbitQuote to my ERP or my spreadsheet?

Yes. Beyond Excel, PDF and text export, there is a public API and an MCP server. Through the API your ERP consumes the structured quote directly; through MCP, an AI assistant your team already uses can query and act on your quotes without anyone writing a dedicated integration.

When is the ERP purchasing module enough?

When the catalog is stable, the suppliers are fixed and everyone answers in the format the ERP expects. In that scenario the item master is always current and the sheet comes out clean. The trouble starts with a new item, a new supplier, or an answer that arrives as a PDF or on WhatsApp.