The people in this story are made up. The problems are the ones we hear most.
Flowchart
The workflow, from inbox to project software
- StartEmail with COI attached
- StepIngestion
- StepClassification (certificate of insurance / W-9 / other)
- StepExtraction (subcontractor, insurer, policy number, coverage type, effective date, expiry date)
- StepAPI call to project software + save to database
- DoneExpiry report
The certificate nobody checked
Before
- COI emailed
- Saved to a folder
- Dates typed into a spreadsheet when there's time
- Expiry missed
After
- COI emailed
- Fields extracted
- Project software updated
- 30-day expiry list
Dave's general contracting company runs a handful of commercial jobs at a time with a rotating crew of subcontractors: electricians, drywall, roofers, concrete. Every sub must send a certificate of insurance before stepping on site, and a new one when the old policy expires.
The certificates arrive as PDF attachments from insurance agents. The project coordinator saves them to a folder and types the expiry dates into a spreadsheet when she has time. Some never make it to the spreadsheet. One spring, a roofing sub's general liability policy had expired three weeks before an accident on site, and nobody knew until the claim.
That's the expensive version of a data-entry problem.
Why this paperwork is easy to get wrong
- Many agents, many layoutsTrained on your own certificates
- Several policies per certificateEach policy's dates extracted
- Dense tablesFields picked out
- Spreadsheet nobody opensData in the system people use
- Certificates come from many different agents, each with their own formatting.
- One certificate lists several policies, each with its own dates.
- The important date is buried in a dense table.
- The data has to reach the system people actually look at, not a spreadsheet nobody opens.
The workflow, from inbox to project software
- Email with COI
- Ingestion
- Classification
- Certificate of insurance
- Extraction
- Project software (API) + Database
- W-9 / lien waiver / other
- Separate handling
Built on the Document Processing Factory canvas:
- 01Ingestion. An ingestion widget picks up certificates from the email inbox they already arrive in.
- 02Classification. Trained on Dave's own past certificates, the classifier separates certificates of insurance from W-9s, lien waivers and everything else.
- 03Extraction. For each certificate it pulls: subcontractor name, insurer, policy numbers, coverage types (general liability, auto, workers' comp, umbrella), effective dates and expiry dates.
- 04API call. The fields go straight into the subcontractor's record in the project software through its API. No spreadsheet in between.
- 05Database. Every certificate is also saved to a database, so one query lists every policy expiring in the next 30 days.
What it changes, specifically
- Certificate arrives
- Data in project software same day
- 30 days before expiry: on the list
- Coordinator requests new certificate
- No lapse
- No retyping of policy numbers and dates from dense tables.
- Expiry dates in the system people use, not a side spreadsheet.
- A 30-day expiry list on demand, so the coordinator asks for a new certificate before the old one lapses.
- A record of what was on file and when, useful for owners, general contractors above you and your own insurer.
Why "send it to an API" matters
Export only
- Extracted fields
- Spreadsheet
- Someone copies them in
API call
- Extracted fields
- Your software, directly
Some document tools stop at "here are your extracted fields," which leaves someone copying them into another system. An API call closes that gap: the data lands in the software your team already opens every day. If a system has no API, saving to a database still gives you one searchable place instead of scattered PDFs.
What stays with people
Software can read a certificate. It can't judge whether the coverage meets the contract. Keep a person on checking limits and requirements against each job, and on following up with subs. Automation's job is making sure nobody has to discover an expired policy after the fact.