Automates business document verification — combining GPT-4.1 Vision OCR, LLM-powered structured extraction, fraud signal detection, and risk scoring with a human-in-the-loop review workflow that keeps reviewers in control of every final decision.
Business document verification is a fundamentally manual process. A reviewer receives a document, reads it in full, extracts relevant information, checks for inconsistencies, assesses completeness, and makes an approval decision. For organizations processing significant document volumes, this creates real operational problems: time-intensive review cycles, inconsistent decisions across reviewers, and no standardized way to surface potential issues before human judgment is applied.
The problem isn't that humans make bad decisions. It's that humans are doing work that should be automated — and when reviewers are spending the majority of their time manually reading and extracting information, they have less capacity for the judgment-intensive work that actually requires human intelligence.
The goal wasn't to replace human judgment — it was to eliminate the manual work that precedes it. ProofPilot automates document reading, information extraction, and inconsistency detection so that reviewers arrive at the decision stage with structured information already in front of them, not a raw document they have to interpret from scratch.
ProofPilot is an AI document intelligence platform designed for business document verification. It processes uploaded documents through a multi-stage AI pipeline — OCR, structured extraction, fraud signal detection, risk scoring, and AI-generated review recommendations — before presenting structured findings to a human reviewer.
The platform supports a wide range of business document types: registration documents, identity verification, certificates, compliance documents, and financial supporting materials. It is document-type agnostic — the extraction workflow is configurable, meaning new document categories can be supported without rebuilding the core system.
Every decision remains with the reviewer. ProofPilot accelerates and standardizes the path to that decision — it does not replace it.
ProofPilot was designed and built by me, solo, for BuildFlow — from the first architecture decision to the production deployment. No handoffs, no separate design team. Here's what that covered:
Every stage is independently replaceable, allowing OCR models, extraction strategies, and validation logic to evolve without redesigning the overall pipeline.
Before the stage-by-stage breakdown, here's the system at a glance — a single upload traveling through nine architectural layers before it reaches an auditable decision.
Every document uploaded to ProofPilot moves through a structured AI processing pipeline before a reviewer sees it. Each stage has a specific function — and each feeds structured data into the next. The result is that by the time a document reaches a human reviewer, the raw document has been transformed into an organized, queryable set of findings.
ProofPilot's fraud signal system is deliberately designed as an alerting layer, not a decision layer. It identifies and surfaces potential inconsistencies that warrant human attention — it does not approve or reject documents. Every signal is a flag for a reviewer, not an automated verdict.
Fields expected for the document type are absent or empty in extraction output. Reviewer is prompted to verify whether the field exists in the source document or is genuinely absent.
Confidence scores below threshold on specific field extractions — indicating unclear scan quality, damaged content, or unusual formatting that reduced AI extraction reliability.
Expected page count for a document type is not met. The system flags incomplete document submissions so reviewers can request complete documentation before proceeding.
Values extracted from different parts of the same document contradict each other — dates that don't align, names that differ across sections, or numbers that don't reconcile.
Document does not match the expected structural pattern for its declared type. Headers, sections, or formatting conventions that differ significantly from expected patterns.
AI identifies patterns or content that fall outside expected norms for the document type — flagged for human review without categorical classification as fraudulent.
The AI Copilot is the interface between the AI pipeline and the human reviewer. Instead of reading a raw document, the reviewer receives a structured review brief — synthesized by AI from all pipeline findings — that tells them exactly what the document contains, what needs attention, and what to verify.
A concise, AI-generated summary of what the document is, what it contains, and its overall completeness — written for a reviewer who needs context in seconds, not minutes.
All extracted fields presented in structured format — with values, confidence levels, and extraction quality indicators — so reviewers see organized data rather than raw document text.
Explicit listing of fields that could not be extracted, fields with low confidence, and information that appears to be absent from the document — prioritized for reviewer attention.
AI-identified contradictions, mismatches, and anomalies presented clearly — with specific references to which fields or sections triggered the signal and why.
Per-field and overall confidence scores so reviewers understand which extractions the AI is certain about and which warrant manual verification against the source document.
Suggested areas for the reviewer to focus their manual review, and recommended next actions — not as binding instructions, but as AI-assisted guidance to accelerate decision-making.
ProofPilot was designed with a non-negotiable principle: the final approval or rejection of any document is always made by a human reviewer. The AI Copilot is an intelligence layer — it surfaces information, flags concerns, and structures findings. It does not approve, reject, or automate decisions. This design ensures accountability, accuracy, and the ability to catch cases where AI extraction or signal detection may be incorrect. The human reviewer sees all AI findings and can always verify against the source document before deciding.
Most portfolios show screenshots. Very few explain why the system is built the way it is. Building a production AI document intelligence system requires solving problems that don't appear in tutorials — these are the six that defined how ProofPilot was engineered.
The core engineering challenge. Business documents vary enormously in formatting, scan quality, completeness, and layout. A registration document from one jurisdiction looks nothing like one from another. Getting GPT-4.1 Vision to return consistent, structured JSON — with the same field names, same value formats, and same confidence indicators — regardless of what the input document looks like required careful prompt engineering, extensive schema validation, and fallback handling for extraction failures. The extraction prompt was iteratively developed and tested across document variations until output consistency reached production reliability.
Not all extraction failures look the same. A field that was clearly absent from a document is different from a field that was present but illegible. Designing a confidence scoring system that meaningfully distinguished between "field not found", "field found but low quality", and "field found and high confidence" required defining confidence tiers, deciding how they propagated to fraud signals, and ensuring the reviewer UI communicated the distinction clearly without overwhelming them with granular scores on every field.
AI responses in development look different from AI responses in production. With variable document types, variable scan quality, and variable content, prompts that worked in testing could produce unexpected output formats, hallucinated values, or missing keys in production. The extraction and Copilot prompts were engineered with explicit output constraints, example structures, fallback instructions for edge cases, and validation rules applied post-response. The goal was AI output that behaved predictably, not just impressively.
Documents processed by ProofPilot are sensitive business materials. Every document stored in Supabase Storage is accessed exclusively through time-limited signed URLs generated per request — never through public URLs or persistent access tokens. This meant designing the entire document retrieval flow around signed URL generation, ensuring the OpenAI Vision API could access documents during processing without storing or logging access credentials, and building reviewer-facing document display that worked within the same secure access model.
There was a design temptation to make fraud signal detection feel decisive — using language like "fraud detected" or "document rejected." This was deliberately avoided. Every signal in ProofPilot is framed as information that requires human interpretation, not a system conclusion. Engineering this required designing the signal schema, the UI language, the Copilot output, and the risk scoring to consistently communicate "this warrants attention" rather than "this is fraudulent" — which also has legal and liability implications in a real business document review context.
For a document review system to be usable in a real business context, every action must be auditable — not just the final decision. ProofPilot logs each pipeline stage completion, the full AI output at extraction and Copilot stages, reviewer identity, review timestamp, and final decision with reason. The audit trail is immutable and queryable, designed so that any decision made in the system can be fully reconstructed from the log — including the AI findings that were presented to the reviewer at the time of decision.
Key screens from ProofPilot AI. Click any image to expand.
ProofPilot replaced a largely manual document review process with an AI-assisted workflow. The outcomes are operational, not just technical.
Reviewers no longer read documents from scratch. AI extraction and the Copilot brief mean the information is already structured and waiting — the reviewer's job is to assess findings, not gather them.
Every document goes through the same AI extraction and signal detection pipeline. Review decisions are now made against consistent, structured information — not varying levels of manually extracted detail.
When reviewers receive the same structured information format on every document, their decisions become more consistent. AI-assisted extraction reduces the variance that comes from different reviewers noticing different things in raw documents.
Fraud signals and inconsistencies are surfaced before human review begins — not discovered mid-review or missed entirely. Reviewers arrive at the decision stage already knowing where to focus their attention.
Every review has a full, immutable audit trail. What AI findings were presented, who reviewed, what decision was made, when — all queryable. No review decision exists without a complete record of how it was reached.
ProofPilot was built to extend human reviewers, not replace them. Every decision remains with a human. AI handles the information gathering — humans handle the judgment. That distinction is a deliberate product decision, not a limitation.
ProofPilot was built with a technology-agnostic product mindset. The stack was chosen to solve the problem, not to showcase technologies. Next.js provided the flexibility to handle both the frontend review interface and the server-side AI processing pipeline in a single deployable system. Supabase provided auth, database, and storage with a security model appropriate for sensitive business documents. OpenAI provided the AI capabilities — and prompt engineering determined how reliably those capabilities performed in production. Every technology choice was a product decision.