Inspiration

Construction procurement still runs on manual, document-by-document review - invoices checked against POs by hand, vendor bids compared with no historical context, and risk (overbilling, hidden penalty clauses, non-compliant vendors) only discovered weeks or months later, when the money is already gone. Industry research kept surfacing the same numbers : 5-10% of total project cost is lost to rework, $177B lost annually in the U.S. alone to non-optimal manual coordination, controllers spending 10–14 hours a week on reconciliation. We kept coming back to one observation: every document is evaluated once, alone, by an overworked human with no memory of past patterns. Nobody was building a system that accumulates knowledge across every PO, invoice, bid, and contract a company has ever processed — so we decided to build one.

What it does

ProcureIQ is an always-on AI analyst for construction procurement. It reads every contract, PO,invoice, and bid the moment it lands, cross-checks it against the entire order, contract, and delivery history behind it, and scores it for risk in real time- instead of the usual single-document, rule-based check. It combines structured cross-document verification with a learned anomaly score (a statistical profile of "normal" per vendor and material category), so it catches things fixed rules would miss, like a price that's technically within tolerance but statistically unusual for that vendor. Six core capabilities carry the daily workload — Contract Intelligence, Automated 3-Way Match, Bid Comparison & Scoring, Vendor Risk Radar, Anomaly & Fraud Detection, and Predictive Delay Alerts — with six more (change order intelligence, compliance tracking, spend forecasting, negotiation copilot, material price forecasting, ESG tracking) layered on top. It sits over existing ERP and accounting systems as a read-only layer, and every action is human-in-the-loop: it recommends and explains, but a person signs off before anything executes.

How we built it

We split the pipeline into three deterministic-to-statistical layers so the system never has to hallucinate a numeric comparison: Extraction (layout-aware OCR / document parsing normalizes messy, differently-formatted vendor documents into a common schema), Deterministic Verification (a rules engine checks quantities, prices, and duplicate invoice numbers against the linked PO and delivery record), and Statistical Anomaly Detection (rolling per-vendor, per-material profiles scored with z-score / isolation-forest-style outlier detection). A final Explanation & Action layer turns the structured findings into plain-English flags a non-technical procurement manager can act on immediately, and can auto-approve zero-flag invoices or auto-route flagged ones to a human with evidence attached. We deliberately avoided a "pure LLM reads PDF and compares" approach, since that has no memory across documents and can hallucinate on numbers.

Challenges we ran into

Getting the extraction layer to normalize documents was the hardest part — every vendor formats invoices differently, so the comparison logic is only as good as the schema underneath it. Balancing the anomaly-detection layer was tricky too: too sensitive and it floods controllers with false positives, too loose and it misses exactly the "technically in-tolerance but statistically weird" cases we built it to catch. We also had to be disciplined about scope — it was tempting to build every one of the twelve product capabilities at once, when the core loop (extraction → verification → anomaly scoring → explanation) needed to work reliably first.

Accomplishments that we're proud of

We built a system that goes beyond "does invoice X match PO X" to actually reasoning about a vendor's full history — catching a duplicate invoice like a $42,000 rebar delivery billed twice, flagged and resolved in under 10 minutes instead of surfacing at month-end reconciliation. We're proud that every flag comes with a plain-English, evidence-backed explanation rather than a black-box score, and that the whole system is designed read-only and human-in-the-loop from day one, so it's trustworthy enough to actually sit next to real payment decisions.

What we learned

We learned that "AI for procurement" is mostly about normalizing data before it becomes an intelligence issue. The challenge isn't just comparing two numbers; it's about making two differently formatted documents comparable. We also saw the importance of distinguishing between deterministic and statistical reasoning. Keeping the rule-based layer clear and using machine learning only when the rules can't identify the pattern made the system both reliable and efficient.

What's next for ProcureIQ

Next, we need to test the main loop on a real pilot project's document set. Then, we will connect the stack with live ERP and accounting integrations, along with vendor risk scoring. After that, we want to shift from detection to prediction. This includes forecasting delays and cost overruns, scoring bids across a full vendor pool, and providing a negotiation copilot. Eventually, we aim to scale to multi-project benchmarking. This will allow a general contractor to compare vendor performance across their entire portfolio, not just one job site.

Share this project:

Updates

Submission history