QuoteGuard

Inspiration

A buyer emails a metals distributor "20 pcs 304 SS sheet, 16ga, 4x8" and they think this is a foreign language. Any assumptions and wrong guesses can cost a business real money. We decided to build a tool that not only interprets this information for a user, but it is not afraid to say "I'm not sure" and show exactly why. Our tool is always 100% honest with the user and shows them what it is thinking, and several components are used to make the whole experience seamless.

What it does

QuoteGuard takes a messy RFQ and turns it into a quote a person can understand. You paste text or upload a file and each line is pulled out, matched against a catalog, priced and checked for requirements like an MTR or US origin.

Anything uncertain gets flagged. Say a buyer writes a line with shorthand like a gauge number and no units. QuoteGuard leaves that line unpriced, says what is missing and keeps it out of the quote total, with a note that the total excludes unresolved lines. Lines that match cleanly get priced right away, and lines that match but still need supplier paperwork are flagged until the evidence is attached.

Spec HUD is our flagship feature where that uncertainty becomes visible. For each line, it draws a labeled schematic built only from what was extracted from the request. Every value the buyer didn't state shows up as a numbered pin marked unknown instead of a filled-in default. Next to the drawing, the closest catalog item sits beside the request, attribute by attribute, so you can see exactly where they differ.

Afterwards, you draft a clarification to the buyer, attach their reply and evidence and review each line. Once everything is resolved, a reviewer can approve the quote. The app also covers supplier comparison, market benchmarks and competitive pricing.

How we built it

QuoteGuard is a Next.js App Router and TypeScript app with Prisma and PostgreSQL on Vercel. The domain logic is plain modules that don't touch React or the database, which made them easy to test and Playwright covers the end-to-end flow.

An indisputable rule we followed was that the model reads but code decides. A language model extracts the data while matching, unit conversion and pricing are deterministic. Spec HUD follows the same rule: the drawing is generated directly from the extracted spec, so it can't show a value the request didn't contain.

For the sponsor tools, model calls go through an adapter for Nicrron's OpenAI-compatible endpoint, with a strict output schema, a timeout and source checks on whatever comes back. We built an adapter for Block Convey PRISM tracing, with a stable agent identity and a session per RFQ.

Challenges we ran into

We chose not to invent endpoints. If a live policy check can't run, approval is blocked instead of passing quietly, and a configured API key alone never shows "Connected." We also had to think about hostile input. An RFQ is just text from a stranger so it can contain instructions. Our local input check is pattern-based so the actual protection is that strict schemas, deterministic math and approval gates don't follow instructions found in a document.

Accomplishments that we're proud of

• A quote total that visibly leaves out unresolved lines, instead of hiding the gap.
• Approved quotes are immutable snapshots and editing a quantity or markup creates a new draft that needs review again.
• Every value traces back to the original request and the original wording survives even after a clarification is applied.
• Spec HUD, which turns "what we don't know" into numbered pins on a drawing instead of a vague warning.
• Exact pricing with a full audit trail.
• An interface friendly for both web and mobile.
• Clear limits that are written down: a limitations doc lists what the prototype doesn't do and all of the data is labeled synthetic.

What we learned

Uncertainty is a feature you have to design, not an edge case you handle at the end. Putting the model in a small box (extracting data) made the whole system easier to test and easier to trust. We also learned how much a quoting workflow depends on boring things like revision checks and audit history, so it was crucial we implemented those features.

What's next for QuoteGuard

We aim to implement handwritten character recognition and table handling for PDFs, broader catalog and spec coverage, and real email handoff so clarifications actually reach the buyer. Long term, we'd want accounts, roles and verified reviewers, and ERP and distributor pricing connections.

Built With

• blockconvey
• javascript
• next.js
• nicrron
• node.js
• postgresql
• prisma
• react
• tailwind
• typescript
• vercel