Procurement leakage,
caught before it leaves.
A Python-first procurement risk engine for the mid-market — deterministic detection, zero data retention, built to run entirely inside your own cloud.
Figures reflect a public US federal procurement dataset (USAspending / FPDS) used for methodology validation — not live customer results.
Mid-market procurement has a visibility gap.
Enterprise tools exist to catch this. They're priced and deployed for companies ten times your size.
Leakage that's easy to miss
Duplicate purchase orders, split invoices, price drift against SKU baselines — the kind of pattern that's invisible until someone compares thousands of rows at once.
Data that can't leave the building
GDPR, works-council rules, and internal governance policies mean many mid-market companies structurally can't send procurement data to a shared multi-tenant cloud tool.
Dashboards that report, not prevent
Most analytics tools tell you what already happened. By the time a report is read, the payment has already gone out.
The Trust Score engine
Every transaction is scored by deterministic Python logic before any action is taken. No model decides whether a payment is legitimate — the math does.
Intake & pre-check
Every record is checked for completeness, valid amounts, and plausible dates before any scoring begins. Incomplete records are flagged as data-quality issues, not anomalies.
Trust Score computation
Price deviation against SKU medians, vendor pricing consistency, and vendor transaction frequency combine into a single composite score — pure NumPy/Polars math, no LLM in the loop.
Deterministic routing
The score routes the transaction to one of three outcomes below. Thresholds are client-configurable, not fixed.
Decision matrix
| Trust Score | Condition | Routing |
|---|---|---|
| ≥ 85 | All signals clear | EXECUTE |
| 60–84 | Mixed signals | ESCALATE |
| < 60 | Signal failure or policy veto | BLOCK |
Where preQur sits
Not a claim that nothing else exists in this space — a claim about which combination of properties is hard to find together at mid-market pricing.
| System class | Zero data retention | Deterministic core | Mid-market priced |
|---|---|---|---|
| Legacy ERP suites (SAP Ariba, Oracle) | No — shared/hosted store | Partial — rule-based | No — enterprise pricing |
| Cloud P2P platforms (Coupa, Zip) | No — SaaS-hosted | Partial | No |
| Point analytics / dashboards | Partial | Retrospective only | Varies |
| preQur™ | Client-perimeter only | Python-first | $15K–$100K ACV target |
Competitor descriptions based on public information as of 2026 and may not reflect their current deployment options — verify directly before relying on this comparison.
Help us validate this on real data.
We're selecting a small number of mid-market companies to run a no-cost, read-only pilot. You get early access and direct input into the roadmap; we get the real-world test our public-dataset backtesting can't provide on its own.
Apply for PartnershipWhat we're looking for
150–500 employees
Manufacturing, logistics, or professional services
Existing cloud ERP
NetSuite, QuickBooks Enterprise, Sage, or similar
Data sovereignty requirements
GDPR or equivalent — this is exactly who we're built for
Python-first.
Deterministic by design.
Language models are used only where they belong: parsing unstructured input and generating explanations. Every decision that touches money is deterministic, auditable Python.
A strict separation of powers
The most common failure mode in AI procurement tools is letting a language model decide whether a transaction is legitimate. preQur draws a hard line: Python decides, the model only explains or extracts.
Multi-channel intake
Email, chat, and contract text arrive unstructured. An LLM call — schema-constrained and RAG-grounded against the client's own historical records — converts this into a fixed JSON structure. It cannot return free text, and it cannot trigger any action directly.
Deterministic core
Pre-checks, Trust Score computation, pattern anomaly detection, and compliance hierarchy — all pure Python/NumPy/Polars. No model input, no probabilistic reasoning. Same input always produces the same output.
Narrative generation
Once Python has computed the score and action, the model receives only the pre-computed summary — never raw transaction data — and writes a plain-English explanation. This output is terminal: it's displayed, never fed back into any decision.
RAG grounding and schema-constrained output reduce hallucination risk — we're not aware of a credible source claiming either technique eliminates it. Layer 0 output is treated as one bounded signal into the Trust Score, never as an independent authority.
Zero Data Retention architecture
Procurement data is processed inside the client's own cloud perimeter. Nothing is retained by preQur outside that boundary.
At no point does raw financial transaction data leave the client's own cloud perimeter. The model layer receives only pre-computed numerical summaries.
What ZDR means here
- No raw data to the modelOnly structured, pre-computed summaries are ever passed to the LLM layer.
- No training on client dataModel providers contractually confirm inputs aren't used for foundational model training.
- Isolated per clientNo shared database. Each deployment is architecturally separated.
Shadow Mode
Before any autonomous execution, the engine runs read-only. It scores every transaction, logs what it would have done, and is compared against what actually happened — no write access, no risk.
Read-only connect
API credentials, read-only. No write access granted.
Silent scoring
Every transaction scored and logged. Nothing acted on.
Comparative review
What the engine would have done vs. what your team did.
Execution granted
Per-category, per-threshold — never all at once.
Backtesting methodology
We validate against public procurement data before approaching any customer. This is what that actually looks like — including the parts still being refined.
We're deliberately not publishing specific dollar-figure or percentage results here. Several detection modules are still being validated for accuracy against messy, real-world data, and we'd rather show you the real process than a number we can't yet stand behind.
Public datasets used
- USAspending / FPDS — US federal procurement transactions, publicly available via API.
- Open Contracting Data Standard — international standardized procurement registries.
This is genuine, real-world messy data — not synthetic test cases. Government contract structures differ from mid-market commercial procurement in some ways, so results here are a validation of detection logic, not a direct preview of customer outcomes.
Detection modules — current status
The tools that catch procurement leakage weren't built for the mid-market.
We're building the version that is: deterministic where it counts, private by architecture, and priced for a 250-person company, not a Fortune 500.
The origin
The instinct behind preQur came from watching how large organizations manage procurement and operational reporting internally — and how differently mid-market companies are served by comparison. Enterprise-grade tools for catching anomalies and enforcing compliance exist, but they're priced, integrated, and architected for companies far larger than a 250-person manufacturer.
The second observation was architectural: many AI procurement tools built recently make the same mistake — letting a language model influence financial decisions directly. That's an acceptable risk for a chatbot. It isn't for something that decides whether a payment goes out. preQur is built the other way around: Python decides, the model explains.
Background
Experience across BMW Group's Digital Hub (Digital Channels, Digital Commerce), Knauf Digital, and COMECO, working on cross-market reporting standardization, data migration, and digital operations. At BMW, this included designing reporting intended to standardize KPI comparison across the company's European regions, including a Regional Performance Report used for cross-market website and channel comparison.
The throughline across these roles: treating fragmented, inconsistent operational data as a problem to be mapped and standardized, not a constraint to route around. preQur applies the same approach to procurement data.
Where things stand
Targets, not commitments. Published for transparency with prospective design partners.
Prototype 1 : Basic Trust Score engine + backtesting pipeline
Core deterministic scoring built and tested against public FPDS data.
Detection module refinement
Peer pricing, tail-spend, and risk modifiers being corrected against real-world data edge cases.
First design partner Shadow Mode deployment
Read-only pilot with a real mid-market procurement environment.
SOC 2 Type I & ISO 27001
Targeted after first commercial deployment — not yet certified.
Apply as a design partner
No cost, no obligation to proceed to a paid arrangement. A 45-day read-only Shadow Mode pilot on your own procurement data.