Consumer, travel and closing documents
Vehicle titles, folios, itineraries and mortgage closing statements — where a named form has numbered lines that must reconcile.
The documents in this cluster arrive one at a time, from a person, in whatever condition a person keeps paper in. A photographed title with a thumb over the corner, a hotel folio slid under a door at 6am, a confirmation email forwarded three times. None of them is an API, and none of them was designed to be read by a machine. What they do have — and what a generic extraction pipeline throws away — is that each one is a named form with an internal arithmetic or an external standard behind it. A VIN carries a check digit. A folio carries a running balance. An auction receipt carries a premium that is a stated function of the hammer price. A manifest states its own total.
So these pages are about the invariant rather than the schema. The schema is the easy half and it is covered elsewhere; the useful half is knowing which field can be checked against which other field, which disagreement is a real error, and which disagreement is the document being correct in a way your validator did not anticipate. Where a page does the arithmetic, the inputs are labelled as assumptions in the sentence that uses them.
Extracting Structured Fields From a Vehicle Registration Document
How to validate an extracted VIN arithmetically using the published check-digit formula, and what the check digit still cannot catch.
10 min read
Extracting Structured Fields From a Vehicle Title Document
Why title brands, odometer disclosure status and lien release each need a tri-state field rather than a string, and why absence is not a negative.
10 min read
Extracting Structured Data From an Auction Sale Receipt
Why the check that buyer's premium equals a stated percentage of hammer price fails on almost every real receipt, and what to check instead.
10 min read
Extracting Structured Data From a Pawn Shop or Consignment Receipt
Why the first extracted field must be whether the document is a loan or an agency agreement, and why the redemption deadline should be read rather than computed.
10 min read
Extracting Structured Fields From a Moving Company Bill of Lading
Why the condition-code legend printed on the mover's own form must be extracted before the inventory rows, and why origin and destination notes are one paired record.
11 min read
Extracting Structured Fields From a Restaurant Reservation Confirmation
Why a booking time must be stored as wall time plus a zone inferred from the venue address, and never normalised to UTC at extraction.
10 min read
Extracting Structured Fields From a Flight Itinerary Beyond Calendar Events
Fare class, baggage allowance and ticket number are three fields an itinerary states ambiguously, and each has a different resolution rule.
11 min read
Extracting Room Charges and Taxes From a Hotel Folio
Why nightly rate times nights almost never equals the room total, and what the running balance column lets you check instead.
10 min read
Extracting Structured Fields From a Car Rental Agreement
Why fuel policy needs an enumerated field, why a mileage cap needs a period, and why an unticked waiver box is not a decline.
10 min read
Extracting a Structured Route From a Delivery Manifest
Why the sum of per-stop package counts legitimately disagrees with the manifest total, and how to tell which disagreements are extraction errors.
10 min read
Extracting Structured Fields From a Proof of Delivery Document
Why a proof of delivery needs a delivery-status enum rather than a nullable signature field, and how exception notations and photo references change the schema.
9 min read
Extracting Structured Fields From a Building Permit Inspection Card
How to model the multi-row inspection log a permit card accumulates over a project, and the sequencing check that flags an inspection recorded before its prerequisite.
9 min read
Extracting Structured Data From a Zoning Compliance Letter
Parcel identifiers have no check digit, permitted use is a three-way distinction rather than a boolean, and the code citation is what makes the extraction worth anything.
9 min read
Extracting Structured Fields From a Purchase and Sale Agreement
Financing, inspection and appraisal contingencies each carry their own deadline computed from a defined basis date, and merging them into one text field destroys every one of those deadlines.
10 min read
Extracting Structured Fields From a Property Management Inspection Checklist
A room-by-room checklist is a table of tables, and the schema has to keep each room as its own record so a move-in form can be diffed against a move-out form.
9 min read
Extracting Structured Fields From a Home Warranty Claim Form
The coverage-relevant content of a home warranty claim is cause language inside a technician's free-text diagnosis, and the covered item must map to the specific contract's list rather than a generic taxonomy.
9 min read
Extracting a Structured Ingredient and Dosage Table From a Supplement Facts Panel
A blank percent Daily Value cell on a Supplement Facts panel is correct data, not a missing field, and proprietary blends withhold ingredient amounts by regulation rather than by accident.
9 min read
Extracting Structured Fields From an Employment Verification Letter
Why a letter stating a current annual salary is genuinely ambiguous between base and total compensation, and how to record that ambiguity instead of resolving it silently.
9 min read
Extracting Structured Fields From a Background Check Report
A background report is several independent searches bound into one PDF, each with its own status and scope, and a single overall-status field misrepresents every partial result.
10 min read
Extracting Structured Data From a Reference Check Form
A numeric rating and the comment qualifying it are one fact, and a rating stored without its scale definition and direction is not interpretable at all.
9 min read
Extracting Structured Fields From a Non-Profit Donation Receipt
Why the goods-or-services disclosure on a charitable receipt is a three-state field, and how its absence changes what the extracted record can be used for.
9 min read
Extracting the Payment Schedule From a Multi-Year Pledge Agreement
How to pull an installment table out of a multi-year pledge and check it against the stated total, including the two cases where an exact match is the wrong test.
9 min read
Extracting Structured Fields From a Membership Application Form
How to tell the tier somebody selected from the rate table printed next to it, and why the obvious cross-check between monthly and annual pricing is wrong.
9 min read
Extracting Structured Fields From a Conference Badge Scan Export
What to do when the QR payload and the printed name on a scanned badge disagree, and which of the two a schema should treat as authoritative.
9 min read
Extracting Structured Fields From a Warranty Claim Denial Letter
How to capture the exclusion a denial letter cites and the appeal window it grants, and why the deadline should be computed downstream rather than extracted.
9 min read
Extracting Structured Fields From a Loan Payoff Statement
How to read principal, accrued interest and per-diem off a payoff statement, and project the figure forward to a closing date that is not the good-through date.
10 min read
Extracting Structured Fields From a Mortgage Amortization Schedule
How to recompute an amortization schedule from principal, rate and term so that every extracted row can be checked, and which checks catch a row dropped at a page break.
10 min read
Extracting Structured Fields From a Closing Disclosure
Why a Closing Disclosure should be addressed by its prescribed section letters rather than by layout inference, and how the five money columns on page two destroy a naive extraction.
10 min read
Extracting Structured Fields From a HUD-1 Settlement Statement
How the HUD-1's numbered line series work as an addressing scheme, and the three footing identities that let an extracted statement check itself.
10 min read
Designing a Schema for a Document Type You Only See a Few Times a Year
An argument that bespoke schemas for rare document types fail on testability rather than on build cost, and that a general capture schema plus a human is the right default.
10 min read
Writing Regression Tests for an Extraction Prompt Before You Touch It
A worked golden-set harness that scores an extraction prompt per field rather than per document, so a fix for one field cannot silently break another.
11 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models