3business days
Document automation for a small office: why the date on the page is not the deadline
One invented roofing company has a duration read perfectly off a signed proposal and still lands on the wrong deadline. Which half of document automation is hard, what research measured on noisy scanned forms and on people, why a deadline is not printed on the page, what the mortgage rules mean by a business day, and what to keep after the fields are filled.
Document automation for a small office reads the signed paperwork your office receives and turns its values into fields your calendar and your CRM can use. We build it for small offices, and this page gives you the method free: what to set up before anything reads a page, the counting rules to write down, and a test you can run on ten of your own files. Reading the page is the easy half; the half that decides whether you can trust it is what each value means. Below, one invented roofing company has a duration read perfectly off a signed page and still lands on the wrong deadline. By the end you will know which half of document automation is hard, why a deadline is not printed on the page, what the software should do with a value it is unsure of, and what to keep after the fields are filled.
Dev's roofing company (invented). Dev owns a roofing and siding company with six people: himself, Carla in the office and two crews. Every job starts with a signed proposal: the price, the deposit, the materials, and a line that holds the price for a set number of days. Dev, Carla, their customers and every figure about them are made up; their paperwork runs through this page as one worked example of a real method.
Dev's roofing company (invented). The signed proposal for a roof replacement came in on a Sunday evening as a photograph. The homeowner had put the page on a kitchen table and held a phone over it, so the top edge of the paper is wider than the bottom edge. There is a shadow across the lower third, and the whole thing is very slightly out of focus in one corner. Two of the printed lines have been struck through and rewritten by hand, with initials in the margin beside each change. One of the changes is a deadline: the price hold, printed as ten business days, now reads fifteen.
Carla forwarded it. The reader pulled out every value on the page and wrote each one where it was supposed to go. The price-hold end date, counted from that duration, landed on the calendar with a reminder attached to order the shingles before it ran out. Everybody stopped thinking about it, which is exactly what the system is for.
In this invented example, the homeowner had signed on Sunday 1 March, and Dev countersigned on Monday 2 March. On Friday 20 March the supplier raised its prices, and the homeowner asked whether the price hold had expired. It turned out there were two defensible answers, and they were not the same day: one counted the Saturdays Dev's crews work and one did not, and one counted from the homeowner's signature on the Sunday and the other from Dev's on the Monday.
Nothing broke. The characters were read correctly. The handwriting was read correctly. The date on the calendar was the count the software made. What went wrong is not on the page at all, and that is what this page is about. In a real estate office the same thing happens to a rider on a purchase agreement and to the rows of a contract's deadline table, such as a new ILC or new survey deadline and its objection and resolution deadlines; that trade has its own section below, with the question of which AI tool to use for closing forms.
In short
- Turning ink into text is close to solved on a clean page, and it is not solved on a bad one. In the one published study of real scanned forms we could find, a commercial engine recovered the words almost exactly, once it knew where they were. It lost a quarter of them when it had to find them first.
- Knowing which value belongs to which label is a different and much harder problem. The same study measured it. Labelling a piece of text as a question or an answer scored a little over a half. Joining an answer to the question it belongs to scored four hundredths.
- And the expensive failure is not a misread character. It is a date that was read perfectly and counted from the wrong event, in the wrong kind of day. That is because none of that is printed anywhere on the page it came off.
Three things this is not
The paperwork is not the busywork.
Not the busywork
Wiring your systems together so that finishing one step starts the next is a real and valuable thing. It is a different product, and it is written up on its own. That question is about work that a person used to do by hand. This one is about a single value that a machine claims it found on a page, and whether that claim is true.
Not the duplicate
Deciding whether two contact records describe one person is a question about your own database. There is a published model for answering it. This one never leaves the document. There is one copy of the page. Nobody disputes whose it is, and everything difficult happens between the paper and the field.
Not the append
Filling in what a contact record is missing brings in a claim from a company you have never spoken to. Here the source is in your hand. You can put it next to the output and check, line by line. That is the whole reason this problem is a workable one, and the reason the fix is boring rather than clever.
What is document automation for a small office, and which half is hard?
Document automation for a small office turns a page into fields: a proposal, a contract, a form or an addendum goes in, and named values come out, the parties, the price, the dates, the empty signature block. The reading is the half every demonstration shows; deciding what each value is for, and what a date counts from, is the half that decides whether the output can be trusted.
The output is data rather than a document, which is the point of it: a date sitting in a field can be put on a calendar, and a date sitting in a PDF cannot.
That description makes it sound like one job. It is at least four. They fail differently, and only the first two are what anybody demonstrates.
The first is finding the writing. On a page, ink is just dark pixels. Before anything can be read, something has to decide which clumps of dark pixels are words, and where each one starts and stops.
The second is reading it, which means turning those pixels into characters.
The third is deciding what each piece of text is for. This string is a heading, this one is a label, this one is the value that belongs to that label. A form is not a paragraph, and the meaning is carried by the layout as much as by the words.
The fourth does not look like part of the job at all, and it is where this page ends up. A value can be correct, correctly labelled and correctly filed, and still be the wrong answer, because what it counts from is not printed anywhere on the page.
Dev's roofing company (invented). Dev's proposal has all four. The reader had to find the handwriting in the margin, read "15" over a struck-through "10", decide that the number belonged to the price-hold line and not the deposit line beside it, and then turn "fifteen business days" into a date. It did the first three correctly. The fourth was a rule nobody had written down.
Your turn. Take one signed document from last month and write the four steps beside one date on it: where it is on the page, what it says, which label it belongs to, and what it counts from.
Why is the original page the first problem?
The original page is the first problem for document automation because what arrives in a small office is often a photograph or a copy of a copy rather than a clean file: every pass through a printer, a pen and a phone camera takes something away before any software reads it.
A clean, born-digital PDF is the easy case, and the one a demonstration shows best. On a clean born-digital PDF the first two problems barely exist: the text is already text, so the software can simply ask for it. That is a real case. If all your paperwork is like that, what follows is easier for you than it is for other people.
A signed page in a small business is often not like that, because it has a long life outside computers before anybody asks software to read it. Four things happen to it on the way, and each one takes something away.
What actually arrives
Four things wrong with the page before anybody reads it.
It is often a photograph
Not a scan and not a file, and the difference is not just how it looks. A page held under a phone is captured at whatever angle and in whatever light happened to be available. That shape is baked in before any software sees it. Detail that was never captured cannot be got back further down the chain, however clever the thing at the end of it is.
The changes are handwritten
There is an unhelpful symmetry in a form. The printed body is easy to read and carries nothing specific to your job. That is because it is identical on every copy of the form. Everything that makes this job different from that one was added afterwards by a person with a pen. Which is to say that how readable a thing is and how much it matters run in opposite directions down the page.
It arrives in pieces
A file is a base document plus addenda plus riders plus a disclosure, signed at different moments. And a later page can change a term on an earlier one. Read as separate documents they all parse. Read as one job they contradict each other. And nothing in any single page tells a reader which version won.
It has been copied
Printed, signed, scanned, emailed, printed again, signed again, photographed. Each pass loses a little contrast and gains a little noise. The thing that degrades first is thin ink. A decimal point, a comma, the difference between a one and a seven in somebody's handwriting.
Dev's roofing company (invented). Carla went through the last thirty signed proposals in the office's files. In this invented example, nineteen came back as phone photographs, eight as scans of a printout and three as signed PDFs, and eleven of the thirty carried a handwritten change.
Your turn. Count your own last thirty signed documents the same way: photographs, scans, clean files, and how many carry a change in someone's hand.

How well does software read a scanned form?
In the one published study of real scanned forms this page found, document automation software read the words it found on a scanned form well and lost a large share by not finding the rest: on that dataset of 199 real scanned forms, one commercial engine's reading of the words it found scored about ninety-four percent by character similarity, and about seventy-six percent once every word on the forms, found or not, was counted.
In 2019 three researchers at EPFL and Istanbul Technical University published FUNSD, a dataset built to test form understanding on bad originals. Their description of it is one sentence: "The dataset comprises 199 real, fully annotated, scanned forms. The documents are noisy and vary widely in appearance." An older source, kept for the argument: engines have moved since, and what the paper shows is that on these pages finding the words cost more than reading them.
Where those forms came from matters more than the number 199. They are drawn from a large collection of business documents from the nineteen eighties and nineties. In the authors' own words, those documents "have a low resolution of around 100 dpi" and "are also of low quality with various types of noise added by successive scanning and printing procedures". So the corpus is not a stress test somebody built by degrading good scans. It is what happens to paperwork when it lives in the world.
There is a detail in how they built it that is worth having. According to the paper, they started from 25,000 images in the form category. Then, in their words: "We discarded unreadable and similar forms, resulting in 3,200 eligible documents, out of which we randomly sampled 199 to annotate." Two things were thrown out together there, the unreadable and the near duplicates, and the paper does not separate them. So it would be wrong to say that the bulk of the 25,000 could not be read. What can be said is this: a research team looking for scanned forms good enough to annotate by hand kept about one in eight of what they had.
The evidence
How much of the text came back, off 199 real scanned forms
Two measurements of the same commercial vision engine on the same 199 scanned forms, scored by Levenshtein similarity. That compares the characters produced against the characters that were really there. It does not count a word as simply right or wrong. The first row scores only the words the engine found itself. The second counts every word on the forms, so the words it never found count against it. Source: Guillaume Jaume, Hazim Kemal Ekenel and Jean-Philippe Thiran, FUNSD: A Dataset for Form Understanding in Noisy Scanned Documents, 2019.
Read this as the shape of the problem, rather than as a score for any product you would buy. The forms are from the nineteen eighties and nineties, at about a hundred dots per inch. The measurement is from 2019, and engines have moved since. The point is the eighteen point gap between the two bars: on these pages, the words the engine never found cost more than its misreading of the words it did. And finding the writing happens before anything clever gets a chance to help. The paper's other engine, an open source one, scored 7.3 and 3.4 on the same two rows. The authors explain why in the same paragraph. So it is quoted in the text above, rather than drawn here as though it were a fair comparison.
Most of the distance between the two bars is not a failure of reading. It is a failure of finding, and the finding happens first. So everything downstream works from a partial transcript without being told which parts are missing.
Be concrete about what that means on a contract, in an invented case. Suppose the printed clauses are located and read cleanly, and two lines written into a margin are not located at all. What comes out is not a document with two gaps in it. It is a document that looks complete, because those two lines never became text. And a value that never became text cannot be noticed as absent unless something further down checks for it: a list of the fields every document of this type must have, or a person looking at the page.
That is the difference between a file and a photograph, and it is why the first question to ask about any of this is what your originals really are.
Dev's roofing company (invented). On Dev's Sunday photograph the margin change was found. Carla tried the same reader on an older proposal photographed in worse light, and the initialled change in its margin did not come out at all: the price on the output was the printed one, with nothing to say that a hand had changed it.
Your turn. Find your worst photographed page and check, line by line, whether every handwritten mark on it appears anywhere in what the software produced.
Why is knowing what a value is for harder than reading it?
Knowing what a value on a document is for is harder than reading it because it depends on layout, the line between a label and its value, and in the same published study the step that joins an answer to its question scored far below the reading, even with the reading handed over already done perfectly.
The same paper measured two harder things, and they are the half that should change how you buy this.
One is labelling: given a piece of text on a form, is it a question, an answer, a header or none of those? The other is linking: given an answer, which question does it belong to? That second one is what produces a field. "Closing date" is a label and "March 14" is a value on an invented real estate contract; "Price held for" and "15 business days" are the same pair in an invented line from Dev's proposal. The only thing that makes them a fact is the line drawn between them.
The evidence
How much of the meaning came back, from the same 199 forms
Two F1 scores from the same paper and the same 199 forms. F1 runs from 0 for useless to 1 for perfect. It combines how often the system was right when it made a claim with how much of the truth it found. The bars are drawn on that scale. Both were measured with the reading step handed to the system already done correctly. Source: Jaume, Ekenel and Thiran, FUNSD, Table VI, baseline results for entity labeling and linking.
These are the authors' own simple baselines, published in 2019 to give the field something to beat. Do not read the second bar as what a system you could buy today would do. Read it as which half of the job was hard on these forms. The character recognition is the part that mostly works. The part that mostly does not is knowing that this number is the answer to that question. Note also what the second bar is made of. Recall was 99.2, so the method found nearly every real link. Precision was 2.1, so it claimed a great many that were not there. At that precision, roughly one claimed link in fifty is a real one. A system tuned that way has technically found your closing date, along with a great many things that are not it. And nothing in the output says which is which.
Read the condition the authors attach to both of them: "Note that we test the algorithms by assuming that we know the optimal word grouping, word location, and textual content. In this way, we only assess the specific task."
Both numbers were produced with the reading already done perfectly.
It is worth being precise about what that second task is in your own paperwork, because it is the thing you thought you were buying. A label sits somewhere on the page and a value sits somewhere else. Neither is a fact until something draws a line between the two. Think of an invented page where the label is three inches from the value, or one where a single label governs a column of four values, or one where a value sits in a box belonging to an addendum rather than to the paragraph above it. On those pages, that line is a judgement about layout. Layout is also what an angled photograph distorts, as Dev's Sunday photograph shows, so this step can go wrong on a photograph even when every word is read.
Dev's roofing company (invented). The deposit and the price hold sit side by side on Dev's proposal, each with its own label. On one older proposal, photographed with a shadow across the deposit box's label, the reader could not see that label, and in Carla's test it filed the deposit figure as the price hold.
Your turn. Mark on one of your forms every value whose label is more than a line away from it. Those are the values to check first.
How accurate is a person at reading documents?
A person reading documents is not perfect either: in a published set of 50,000 questions about images of industry documents, a few volunteers answered the 5,188 test questions correctly 94.36 percent of the time, so the comparison for any software is a person, not a perfect reader.
There is a person standing behind every argument about automating paperwork, on both sides of it. That person never misreads anything. Somebody has measured them.
DocVQA is a set of 50,000 questions asked about 12,767 document images. It was published by researchers at IIIT Hyderabad and the Computer Vision Center in Barcelona. The images are drawn from "6,071 industry documents" dating from as early as 1900 to as recent as 2018, and including "typewritten, printed, handwritten and born-digital text". The questions are the ordinary ones: what is the total, what is the date on this document, who is this letter addressed to. An older source, kept for the argument: the people in it have not changed, whatever the software has.
The evidence
The most anyone could get right, on 5,188 questions about document images
Three figures from one table in one paper, all on the same 5,188 test questions about images of industry documents. The first is what volunteers scored. The other two are not scores at all. They are the most any system could possibly get right if it is limited to the text the reading step managed to produce. They are computed two ways, the second stricter than the first. Source: Minesh Mathew, Dimosthenis Karatzas and C.V. Jawahar, DocVQA: A Dataset for VQA on Document Images, 2021.
Two things worth taking from this, and neither is the one people expect. The first is that a person reading a document and answering a question about it was right 94.36 percent of the time, not 100. The people in question were a few volunteers at the authors' institution. Any comparison that treats the human path as flawless is measuring against something that does not exist. The second is that the lower two bars are ceilings rather than results. Whatever sits on top of the reading step, however good it gets, it cannot answer from text the reading step did not produce. On this corpus that alone put the roof at 87 or at 77, depending on how strictly you count. The authors' own baselines came in well below both. Those figures are from 2020 and are not quoted here, because a stale model score would be the one number on this page that says something false.
Now read that first bar against the thing it is really competing with, because there are two candidates, and only one of them is honest. The first is a careful reading, done once, by somebody with the file open and nothing else on. The paper says only that the answers came from a few volunteers at the authors' institution. The second is the fourth read of the day, at ten past five, of a page two people have already looked at. An office's process runs on the second one.
So the useful question is never whether a document reader is right every time. It is which values it handles better than a tired person, which ones it handles worse, and what it does with the ones it cannot settle. Those are three different questions, and only the third is a build decision.
And it means something uncomfortable about the process you have now. Anything that depends on nobody ever misreading a date is already failing at some rate, today, with no software involved at all.
Dev's roofing company (invented). Before the reader, Carla typed every proposal into the CRM herself, at the end of the day. When Dev asked how often a typed date had been wrong, nobody could say, because nobody had ever checked one against its page.
Your turn. Take ten values your office typed in by hand last month and check each one against its page. That count is a first, small look at the rate any software has to beat.
Why is the date on the page not the deadline?
The date on a document's page is not the deadline because a deadline written as a number of days needs two things that page may not print: what the count starts from, and what kind of day counts. Software can read "fifteen business days" perfectly and still not know either.
Everything so far has been about getting a value off a page. This is the part where a value that came off the page perfectly turns out to be the wrong answer, and it is the part our own service page did not say enough about.
Take the plainest possible field, a deadline expressed as a number of days. A machine reads "fifteen business days" with complete accuracy. To put a date on a calendar it now needs two things that are not written next to those words: what the count starts from, and what a day is.
Neither of those is a trick question, and in Dev's paperwork both had been decided by habit rather than in writing. Does the count start on the day of signing, or the day after? On the first signature or the last? Is a Saturday a business day for a company that works Saturdays? Is a holiday a day? Whoever wrote the proposal had answers in mind, and none of them is on that page. In some contracts the answers sit in another clause, or in terms the contract brings in by reference; then the rule is on another page, and the system has to be told where.
Dev's roofing company (invented). Dev's two answers to the homeowner were five days apart. Counting from the day after the homeowner's Sunday signature, Monday to Saturday, the fifteenth business day is Wednesday 18 March; counting from the day after Dev's Monday countersignature, Monday to Friday only, it is Monday 23 March. The reader had used the first rule without anyone choosing it. Dev honoured the later date, and then wrote the rules down for the terms his own proposals set, the only terms that are his to choose: in his proposals a business day is Monday to Friday, not counting the federal public holidays, and a count starts the day after the last signature. The new proposal template prints both rules under the price-hold line.
Your turn. For the deadline your office uses most, write one sentence that says what the count starts from and what a day is. If two people in the office would write different sentences, that is the rule to settle first.
What does "business days" mean in a real estate closing?
In a real estate closing, "business days" in the federal mortgage disclosure rules, Regulation Z, counts the deadlines for the lender's disclosure documents back from consummation, the moment the buyer becomes obligated on the loan; these are the lender's duties, quoted here because they are the clearest published example of a document deadline whose meaning lives off the page.
There is one part of a real estate transaction where the federal government has written the rules down, and in that part both questions, what the count starts from and what a day is, have published answers that surprise people.
The mortgage disclosure rules in Regulation Z at 12 CFR 1026.19 run several deadlines through a real estate closing. The lender must "ensure that the consumer receives the disclosures required under paragraph (f)(1)(i) of this section no later than three business days before consummation". For certain transactions the creditor must deliver early estimates "not later than the seventh business day before consummation of the transaction". And where certain figures become inaccurate, in the circumstances the regulation lists, "the consumer must receive the corrected disclosures no later than three business days before consummation".
Those are the lender's duties rather than a real estate office's, and nothing here is advice about how to meet them. They are quoted because they are the clearest published example of the thing this whole topic turns on: a deadline written on a document whose meaning lives somewhere else.
Consummation means the time that a consumer becomes contractually obligated on a credit transaction.
Why can one regulation give "business day" two meanings?
One regulation gives "business day" two meanings, and a page that says "three business days" does not say which, because the mortgage rules define it once by the lender's opening hours and then, for a listed set of paragraphs, as every calendar day except Sundays and the federal public holidays; which meaning applies is decided by a paragraph number, not by anything on the page.
Here is the part that is startling the first time you read it. It is sitting in the definitions section, 12 CFR 1026.2.
"Business day means a day on which the creditor's offices are open to the public for carrying on substantially all of its business functions."
That is the general definition, and it depends on a fact about a particular company's opening hours. Then the same paragraph continues: "However, for purposes of rescission under 1026.15 and 1026.23, and for purposes of 1026.19(a)(1)(ii), 1026.19(a)(2), 1026.19(e)(1)(iii)(B), 1026.19(e)(1)(iv), 1026.19(e)(2)(i)(A), 1026.19(e)(4)(ii), 1026.19(f)(1)(ii), 1026.19(f)(1)(iii), 1026.20(e)(5), 1026.31, and 1026.46(d)(4), the term means all calendar days except Sundays and the legal public holidays specified in 5 U.S.C. 6103(a)".
One phrase, two meanings, and which one applies is decided by a list of paragraph numbers. Under the second definition a Saturday counts, Sunday does not, and the eleven days named in 5 U.S.C. 6103 do not. Under the first, whether a Saturday counts depends on whether the creditor's offices are open for substantially all of its business that day, and a company holiday might not count either.
Now put a document reader in front of a page that says "three business days". It can read those words at any accuracy you like. It cannot know which of those two definitions applies, because that is not on that page. Somebody has to establish, once, in writing, which definition applies to which deadline, and make the system apply it. For a federal rule that is a reading of the regulation, not a choice; Dev's case differs only in that the terms of his proposals are his to draft.
The same section carries a second one of these, and it is the reason for the line held on its own above. Consummation is not necessarily closing. It is defined as the moment the buyer becomes contractually obligated on the credit transaction, which can be a different moment from the day everybody signs the deed and gets the keys. When it happens is not settled by Regulation Z at all. The official commentary on that definition is headed "State law governs", and says that when the obligation is created "is a matter to be determined under applicable law". A reader that finds "closing date" on a page and treats it as consummation has made a swap nobody asked it to make, and nothing in its output says so.
Why is a wrong date worse than a missing one?
A wrong date from document automation is worse than a missing one because a missing value is noticed and a wrong one is believed: an empty field sends somebody back to the page, and a confident wrong date sits on the calendar with your system's authority until the day it matters.
A missing value is loud, as long as somebody works the queue. The field is empty, somebody notices, somebody opens the document. It costs a look at the page, at a moment when somebody is paying attention. An unworked queue is a pile of hidden blanks, which is why the queue has a named owner.
A wrong value is silent. It is worse than silent, because it is now wearing your system's authority. It is on the calendar. It has a reminder attached. Everybody downstream treats it as settled. And the specific thing that will not happen is anybody going back to the page, because the reason the system exists is so that nobody has to.
That has a direct consequence for how a document reader should behave, and the incentive runs against it. A reader that returns an answer for every field looks better in a demo and is worse in a business. What you want is a reader that abstains: one that says nothing rather than guessing, and that puts the abstentions somewhere a person will look. Our own service page has said for a while that anything it is not confident about goes to a person rather than being filed quietly. That is the right design, and the argument for it is arithmetic rather than caution: a blank costs a look at the page, and a confident wrong date can cost a job or a deal.
Dev's roofing company (invented). Dev had the reader set to leave a value blank whenever its confidence fell below the threshold, to send every handwritten change it found to Carla's queue, whatever its confidence, and to send every page that arrived as a photograph to the same queue for one look, because a handwritten change the reader never found cannot be routed anywhere. Carla works the queue each morning with the photograph open beside it.
Your turn. Ask whoever set up your reader, or would set it up, one question: when it is not sure of a value, does it write it anyway or leave it blank? Write the answer down.
The system
From a photograph of a page to a date somebody relies on.
Six hops, and the products in this category are sold on the first three. The fourth is where a correctly read value becomes a wrong answer. The fifth is the only one that catches it. Both of those are decisions about your business rather than settings in a piece of software. Neither of them is a question a demo answers.
Scroll to follow the chain
- The original: A photo of paper
- The characters: Ink read as text
- The fields: Which text is which
- The meaning: What it counts from
- The check: Somebody, or nobody
- The calendar: Where it becomes real
Is the extracted data the legal record?
A row of extracted data is not, on its own, the kind of record the ESIGN Act's retention rule describes: the federal ESIGN Act lets an electronic record meet a requirement to keep a contract only if it accurately reflects the information set forth in the contract and can be accurately reproduced later, and a row of extracted fields is a reading of the document, not the document.
American law is comfortable with electronic records. 15 U.S.C. 7001, the ESIGN Act, opens by saying that "a signature, contract, or other record relating to such transaction may not be denied legal effect, validity, or enforceability solely because it is in electronic form". That answers the old question of whether a contract can be refused effect only because it is electronic. It is not the half that decides what you have to keep.
The half worth knowing is the retention rule at 7001(d). Where a law requires that a contract be retained, the requirement is met by keeping an electronic record which "accurately reflects the information set forth in the contract or other record". It has to be a record which also "remains accessible to all persons who are entitled to access by statute, regulation, or rule of law, for the period required by such statute, regulation, or rule of law, in a form that is capable of being accurately reproduced for later reference, whether by transmission, printing, or otherwise".
Read what that asks for. Not the facts from the contract. The information as set forth in it, reproducible later.
A row of extracted fields is not that. It is a reading of the document, made by a particular system, on a particular day, and it drops everything the reader did not think to look for: the strike-through, the initials in the margin, the handwritten note at the bottom that changes what a printed clause means. Extraction is a handy layer over a document that has to keep existing. Any build that treats the fields as the record has quietly thrown away the thing the fields were about.
The practical version of this is plain. Keep the original, keep it findable, and store with every extracted value which document it came from and which page. That last habit is a small decision at build time, and it is the difference between a disagreement settled with the page on screen and one settled by searching for the paper.
Dev's roofing company (invented). Every value in Dev's CRM now carries a link to the photograph it came from and the page number. When the homeowner's question came back a second time, Carla had the struck-through line on screen within a minute.
Your turn. Pick one value in your CRM that came off a document and time how long it takes to find the page it came from.
In your numbers
How many values reach your calendar without anybody opening the page again?
Count the ones that fell apart after signing too, because those made paperwork as well.
The agreement, every change order, addendum and rider, and the forms that came with it. This is not worth guessing at. Open a file you closed last month and count.
Count what you would actually want in a system, not what is on the page. Names, prices, deposits, and every date.
Be honest rather than hopeful. If the point of the build was that somebody stops reading, this number is high by design.
Finding the line, reading it, agreeing with it. Seconds on a clean PDF and minutes on a photograph of a rider.
Values a year that nobody reads off the page
576unchecked
- Files in a yearyour 12
- 12files
- Documents to be readyour 8
- 96documents
- Values pulled out of themyour 8
- 768values
- Where nobody opens the page againyour 75%
- 576unchecked
- At your checking timeyour 2
- 1,152minutes
- In hours60 minutes in an hour
- 19hours a year
The headline is the fourth row rather than the hours. That is because the hours are the reassuring half, and the count is the one worth sitting with. Notice what the last row does. At the settings this opens with, checking every single value against its own page is a couple of days of work spread across a year. That is affordable, and it is not what happens. That is because the whole reason the system exists is so that nobody opens the page. Shares of values produce fractions, and a third of a date is not a thing. So read anything with a decimal in it as a rough count. Three things this deliberately refuses. There is no accuracy figure for our own extraction anywhere in it. That is because we have not measured one on your paperwork, and the published measurements above are on other people's documents. There is no hours-saved row. That is partly because saving hours is a different article on this site. It is also because this page found no published measurement of what re-keying a file costs. And there is no dollar figure for a missed deadline, which is the number this category invites you to imagine. That is because the honest version of it depends on the contract, the state, the other party and whether anybody was willing to be reasonable that week.

How do you set up document automation, step by step?
You set up document automation in an order that decides the meanings before any page is read: one document type first, the five values you want from it, the counting rules written down, what happens to a value the reader is unsure of, the original kept beside every value, a test on ten of your own files, and only then the connection to your calendar.
- Choose one document type. Not "our paperwork". One form: the signed proposal, the engagement letter, the purchase agreement. Each type is its own set of expectations about where things are.
- Write the five values you want from it. By name, before you look at any output. At least one of them will turn out not to be printed on the page at all.
- Write the counting rules. For every value that is a number of days: what the count starts from and what a day is. Where you draft the document, the rule is yours to choose and to print in the template; where a law or another party's contract sets it, it is yours to write down as that document says it, not to choose.
- Decide what happens to an unsure value. Left blank, and put in a named person's queue. Handwritten changes go to the same queue whatever the software thinks of them.
- Keep the original beside every value. The document and the page, linked from the field, kept for as long as any law or contract requires the document itself to be kept.
- Test on ten of your own files. The test is in its own section below.
- Only then connect it to the calendar and the CRM. A date that reaches a calendar is believed; it gets there last.
Dev's roofing company (invented). In April, rebuilding the setup after the price-hold question, Dev chose the signed proposal and nothing else. His five values: the customer's name, the price, the deposit, the date of the last signature and the price-hold end date. The fifth is not on the page: it is computed from the fourth by the rule he wrote. Unsure values and handwritten changes go to Carla. The photograph is linked from every field. The calendar connection came last, after the ten-file test.
Your turn. Fill in steps one to three for your own office on one sheet of paper: the document type, the five values, and the counting rule for every date among them.
What does document automation take, and what decides its size?
Document automation takes three kinds of work: the reading, whose size follows the number of pages; the setup, whose size follows the number of document types rather than documents; and deciding what the values mean, which is a conversation rather than a setting and takes longer than the build.
No price is given here; what decides the size of the work is below.
The first is the reading itself, and its size follows the number of pages. The second is the setup, and its size follows the number of DOCUMENT TYPES rather than documents. A proposal, a change order, a lease and an addendum are four different sets of expectations about where things are and what they mean, and adding the fourth one is not much less work than adding the first. The third does not look like work at all, which is why it is the one that gets left out. It is deciding what the values mean: what a deadline counts from, which calendar rule applies, which of two contradictory pages wins. Those are conversations rather than settings, the same kind of conversation that sits at the heart of an AI assessment. They are the ones that decide whether the output is trustworthy, and they take longer than the build.
Two things move the size more than anything else. One is whether your originals are files or photographs of paper, which is worth finding out before anybody quotes you rather than after. The other is how many document types you truly need, as opposed to how many you can name. It is worth writing the two lists down separately before anybody quotes.
On time, a single document type with clean originals and one place for the output to go is a short piece of work. What extends it has nothing to do with reading or with page counts. It is discovering, in week two, that there is nowhere for the output to land: no field in the CRM, no calendar anybody shares, no agreed owner for the exceptions. If those already exist, this moves quickly. If they do not, what you have bought is a systems project wearing a document reader's clothes. The pieces sit beside everything else we build, on the home page.
What does document automation not do?
Document automation does not guarantee a date, know what a value means, replace the document, give a legal opinion, fix a document, or measure its own reliability in a way you can bank on.
It does not guarantee a date, and no honest version of this ever will. Misreading a line on a photographed page is the failure mode of the whole category. That is why anything the system is not confident about should be flagged for a person rather than filed silently. It is a design choice you should confirm is being made, not something you get automatically.
It does not know what a value means. It reads what the page says. What the page says is a number of days. Turning that into a date on a calendar requires a rule about counting, and that rule may not be on that page: it can sit in another clause, in a regulation, or only in your office's habits. If nobody has written that rule down, the software has used one on your behalf.
It does not replace the document. The extracted fields are a reading, and the original is the record. The retention rule quoted above asks for something that accurately reflects the contract rather than a summary of it. Any build that deletes the source once the fields are populated has destroyed the only thing that can settle an argument.
It does not give a legal opinion, and it should not. It surfaces what a document says and what is missing from it, so that somebody qualified can act on that. The distance between "the page says thirty days" and "your deadline is the 14th" contains at least one judgement, and it is not the software's to make.
It does not fix a document. A missing signature is found, not solved. Chasing it is a person's work. The benefit is that a gap the reader does find is in a person's queue on the day the document arrives instead of the week it matters. That is a narrow claim, and it is the one this page makes.
And it does not measure its own reliability in any way you can bank. A tool of this kind may show you a confidence score. That number was produced by a model about its own output, on some set of documents. It is not a probability that the value is correct on your paperwork. Ask what it was measured on, and what threshold the build uses. A vendor who can answer that in two sentences is telling you something good about themselves.
Three ways a working build produces nothing
None of them are the reading.
Everything is flagged, so nothing is
A reader that marks a third of its output as uncertain has told you the truth. It has also handed you a queue somebody now has to work. Within a fortnight the flags are being cleared in batches without the pages being opened. That is worse than having no flags, because now there is a record saying somebody checked.
The output has nowhere to land
The extraction is correct, and it is sitting in a report. The calendar it should have written to belongs to somebody else. The CRM field it should have filled does not exist yet. So the values get retyped by hand from the report. The reading was never the bottleneck, and this is how you find that out.
Nobody owns the exceptions
Every document type eventually produces one the system has not seen. It might be an addendum from another state. It might be a form somebody rebuilt in a word processor, or a page that is truly unclear. If there is no named person whose job it is to look at those, they do not go into a queue. They go into the deal, quietly, as whatever the machine guessed.
The honest read
Send us one document you would want read automatically, with anything private crossed out. Tell us the five values you would want off it. We will tell you which of the five are printed in a fixed place. We will tell you which depend on handwriting. And we will tell you which one is not really on the page at all, and would have to come from a rule you decide.
It is a short reply from a person, and it costs nothing. We do not need access to your files, and one page is truly enough to answer it.
How do you test a document reader on ten of your own files?
You test a document reader on ten of your own files by scoring each value right, wrong or missing, counting the wrong ones nobody would have questioned, and then making the ugliest page uglier to see whether the reader goes quiet or keeps answering. It needs no subscription.
- Pull ten real files, not ten good ones. Run them through the reader you are considering, on a trial, or ask its seller to run them while you watch. Include the two that were a mess. Include the one where a page arrived as a photograph. A reader is only as useful as its behaviour on your worst week, and your worst week is not in anybody's sample pack.
- Write down the five values you want, and their right answers. Before you look at any output. Five, by name, with the correct value for each file written from the page by you. This is harder than it sounds, and it is the most valuable part of the exercise, because at least one of the five will turn out not to be printed on the page at all.
- For each of the five, write where it comes from. A fixed box on a standard form is one thing. A number written into a blank is another. A value that has to be derived from a date plus a counting rule is a third. That third kind is where Dev's expensive mistake lived.
- Run the ten and score by value, not by document. Fifty values. Mark each one right, wrong or missing. Keep wrong and missing in separate columns, because they are different failures and only one of them is dangerous.
- Count the wrongs that would have been believed. Of the ones it got wrong, how many looked plausible enough that nobody would have questioned them? That count is the one that matters for your purposes. It is a subset of the raw wrong count, so it is smaller. Whether it comes out at zero on fifty values is the thing you are really measuring, and fifty values is a pilot, not an error rate: it shows how the reader fails, not how often.
- Take the ugliest page and make it uglier. Photograph the printout at an angle, in poor light. Run it again. What you are looking at is not whether the score drops, because it will, but what the system does when it drops: does it go quiet, or does it keep answering?
- Ask what happens to a low-confidence value. Where does it go, who sees it, and what does the queue look like on a Friday? If the answer is that it gets written anyway with a flag, you have learned the most important thing about the build, before it is running your calendar.
Dev's roofing company (invented). In April Carla ran the test on ten proposals. In this invented example, of the fifty values, forty-one were right, six were missing and three were wrong. Of the three wrong ones, one would have been believed: a price-hold date counted from the first signature, because the rule Dev had written was not yet entered in the reader's settings. The six missing ones were all in Carla's queue the next morning. The angled photograph lost two more values to the queue and none to a wrong answer. Once the rule was entered, a rerun of the same ten gave no believable wrong values, a pilot result on fifty values, before anything was connected to the calendar.
How does document automation handle a real estate contract's deadlines?
Document automation handles a real estate contract's deadlines the same way as any other office's, with the same weak point: it can read every date in a contract's deadline table, and it cannot know what a count of days starts from unless your office has written that down.
Document processing in real estate reads a purchase agreement, its addenda and riders, the disclosures and the inspection paperwork, and writes the parties, the price, the deposits and the dates to a transaction folder, a CRM and a calendar. The weak points are the ones above: riders that arrive as photographs, handwritten changes initialled in a margin, and a later page that changes a term on an earlier one.
A real estate contract may set its deadlines in a table of named rows, with rows such as a new ILC or new survey deadline, then that item's objection deadline and its resolution deadline. A row that holds a written date can be read straight off the page. A row that holds a number of days, or a reference to another row, needs the same two answers as Dev's price hold: what the count starts from and what a day is. Whatever your state's form says about those, it is the rule to write into the system once, and check against the form itself, not against the software's guess. This page does not say what any state's form provides.
The mortgage side of a closing adds the federal deadlines quoted above, which are the lender's to meet and are counted from consummation, not from the closing date on the calendar.
And a document reader does not replace a transaction coordinator. It removes the re-keying, and it puts the deadlines and the gaps it finds in a person's queue on the day a document arrives. What it does not do is decide what a deadline counts from, chase a missing signature, or notice that the other side has gone quiet. The mechanical part of that job is what this touches; the part that is judgement, chasing and relationship is not.
Common questions about document automation
What is document processing, in plain terms?
Document processing is software that reads paperwork and turns it into fields: a contract, proposal, form or addendum goes in, and the parties, prices, dates and missing signatures come out as structured data that can be written to a CRM, a folder and a calendar, rather than staying inside a PDF somebody has to open. The reading is the visible half. The half that decides whether it is worth having is what happens to the values it is not sure about.
Can AI read a scanned contract, or a photograph of one?
Software reads the printed text of a scanned contract well once it has found the words; in the published measurement of real scanned forms above, finding them was where it lost ground. On that measurement, at around a hundred dots per inch with real scanning noise, a commercial engine's reading of the words it found scored about ninety-four percent, and about seventy-six percent once the words it never found were counted too. A born-digital PDF is a much easier case than either, because the text is already text.
Which AI tool should I use to process real estate closing forms?
The AI tool to use for real estate closing forms is the one that does best on ten of your own files, scored by the test above, and this page names no product. Ask each candidate the five questions in the next answer, run the same ten files through each, and compare the wrong values that would have been believed, not the demo.
What should I ask a vendor before I buy one?
Before buying a document reader, ask five short questions. What does the confidence score mean, and what was it measured on? What does the system do when a value falls below the threshold, and where does that value go? Does it store which document and which page each value came from? How many document types are included, and what does adding one involve? And what happens on a photograph of a page rather than a PDF? Somebody who answers all five in plain sentences is worth taking seriously. Somebody who offers to show you a demo instead has answered a sixth question you did not ask.
What happens when it gets something wrong?
What happens when a document reader gets something wrong depends entirely on how it was built, and it is the question to ask first. The behaviour you want is abstention: a value the system is not confident about is left blank and put in front of a person, not written with a flag that nobody reads. A blank field is noticed. A wrong date that looks right is not, and it inherits the authority of your calendar, which is what makes it the expensive failure rather than the annoying one.
How is this different from workflow automation?
Document automation is about one value on one page and whether the claim made about it is true; workflow automation is about steps of work a person used to do by hand, and its argument is what an interruption costs. The same engineers build both, using much the same parts, and they solve different problems. A document reader with nowhere to send its output is a common and expensive way to find out that you needed the other one first.
Can it read handwriting?
A document reader can read some handwriting, and the honest answer has a shape to it. Printed and typed text is the reliable case. Neat handwriting in a box designed for it is the next easiest. What is hard is exactly what carries the most meaning in a signed document: a figure written over a struck-through one, a date altered in a margin, initials that are not meant to be legible even to a person. Those are the marks a build should be designed to flag rather than to guess at.
Is the extracted data the legal record?
The extracted data is not the legal record. The retention rule in the ESIGN Act asks for a record that accurately reflects the information set forth in the contract and can be accurately reproduced later, and a row of fields is a reading of the document rather than the document. Keep the original, keep it findable, and store the source document and page number alongside every extracted value.
Do you work with businesses outside New York?
We are based in New York, and the call works for an owner anywhere. The federal rules quoted on this page are federal, and whether one applies depends on the transaction; the counting rules in the documents you draft are yours to choose, within the law that applies to them.
What to do first about the deadlines in your paperwork
Somewhere in your business there is a set of counting rules. Which day a period starts on. Whether Saturday counts. What happens when a deadline lands on a holiday. Which of two contradictory pages wins. Those rules are what turn an extracted value into a deadline, and the test of whether they exist is simple: can you point at where they are written down? If the answer is that a particular person knows, you cannot automate this and you also cannot train anybody into it, and those are the same problem.
Writing them down needs no software. It is worth doing whether or not you ever buy any of this.
The paperwork is not going to get cleaner. The rules about what its dates mean are the part you can fix this week.
Open the last file you closed and find the earliest deadline in it. Then answer two questions out loud. What event does that date count from, and where is that event written down. If the answer to the second one is that everybody just knew, you have found the thing a document reader cannot do for you. And you have also found the reason it is worth having one.
There is no price here, because three things move it and none of them is the reading. The first is how many document TYPES you want handled, because each type is its own set of expectations. The second is whether your originals are files or photographs of paper. The third is whether there is somewhere for the output to go when it arrives.
Start with the page on AI document processing: the fields it pulls, where it writes them, and what goes to a person.
Sources
- Guillaume Jaume, Hazim Kemal Ekenel and Jean-Philippe Thiran, FUNSD: A Dataset for Form Understanding in Noisy Scanned Documents, on arXiv. An older source, kept for the argument: the measurement is of 2019 engines, on forms from the 1980s and 1990s at about 100 dpi.
- Minesh Mathew, Dimosthenis Karatzas and C.V. Jawahar, DocVQA: A Dataset for VQA on Document Images, on arXiv. An older source, kept for the argument: its human figure is about people, not software.
- 12 CFR 1026.2 and 1026.19, Regulation Z, on Cornell Law School's Legal Information Institute: 1026.2, 1026.19. The regulation in force.
- Consumer Financial Protection Bureau, the official interpretation of 1026.2, comment 2(a)(13)-1 on consummation. The Bureau's own commentary.
- 5 U.S.C. 6103, the legal public holidays. The statute in force.
- 15 U.S.C. 7001, the ESIGN Act. The statute in force.
Keep reading
Invoice reminders: when to send one, what it should say, and the fee nobody invoiced 
August 25, 2026
Invoice reminders: when to send one, what it should say, and the fee nobody invoiced
Why emails go to spam: email deliverability for a small business 
August 25, 2026
Why emails go to spam: email deliverability for a small business
AI employees: what they do for a small business, and what supervising them costs 
August 25, 2026
AI employees: what they do for a small business, and what supervising them costs
