Handwritten Registers Turned Into Verified Rows
An academic olympiad receives registrations on paper: a row per student, a tick per subject, a handwritten total at the bottom. Thousands of sheets a season, every one typed up and checked by hand, because the data becomes a child’s exam entry.
This is real personal information about children. The system is invite-only, source documents are stored separately from results, and deletion of stored documents is a deliberate, restricted action.
The Doctrine Underneath
Look at the page. Read what is written in each cell. Report the marks, the names, the numbers as they appear. That is all it is asked to do.
Every sum, every reconciliation, every comparison against the sheet's own totals, every verdict. Deterministic, repeatable, inspectable.
The split exists because the two failure modes are different. Misreading a smudged digit is a perception error a human would also make. Adding up wrongly is not something software should ever do, so software that can reason its way to a wrong sum is not given the job.
The Rule That Makes Verification Mean Something
The trap is easy to miss. If the same reading pass produces both the individual marks and the handwritten total, and they agree, that agreement proves nothing: a single confused reading of the page can produce a consistent, wrong answer that verifies itself.
So evidence that confirms a reading has to come from somewhere independent of it. A total read in the same pass may contradict the marks, which is useful. It may never confirm them.
Every sheet typed up by one person, then checked by a second, because the data becomes a child’s exam entry.
A model reads the page and code does every sum. Anything it cannot verify comes back marked unverified, never marked correct.
One pass reads the marks and the total together, they agree, the row is called verified. A coordinated misreading passes.
The total is read again separately, several times, and the readings are voted on. Once settled it is pinned, and later corrections are not permitted to rewrite it.
Agreement from an independent source is a match. No independent source is not a match; it is reported as unverified.
No checksum does not mean verified. A sheet with no usable checksum and nothing to corroborate it comes back marked unverified, not marked correct. This single rule is the difference between a system that reports what it knows and one that flatters itself.
What Happens to One Sheet
- 1
Prepare the page
The scan is straightened using the table's own printed gridlines as the reference, then reduced to a working copy. The original is kept exactly as received, byte for byte, so the source of truth is never the processed version.
- 2
Read it
Every row, every subject column, the names, and the handwritten total. The total gets its own separate reading and a vote across attempts.
- 3
Reconcile
Code recomputes each class from the marks and compares against the independently read total. Registers that continue across sheets are handled by subtracting the running figures rather than assuming each page stands alone.
- 4
Target repairs
Where a class does not reconcile, only the disputed part is re-read. The pinned total is not up for revision, so a repair cannot quietly move the goalposts to make itself agree.
- 5
Deliver with verdicts
Spreadsheet and data files out, every group carrying its verdict. Matches are usable immediately; anything flagged or unverified arrives with the reason attached.
Step 4 is the one most systems get wrong. If a correction pass is allowed to rewrite the number it is being measured against, every sheet eventually reconciles and the reconciliation is meaningless.
Three Verdicts, One of Them Silent
The rows add up to a total that was read independently. Usable straight away, and nobody needs to look at the paper again.
The sheet contradicts itself, or a class will not reconcile however it is read. Comes back with the specific disagreement described.
Nothing independent to check the reading against. The figures are there and are probably right, and the system refuses to say so.
The third verdict is the one that makes the other two worth anything. A system without it reports everything it managed to read as correct, and the school finds out at the exam hall. Roughly speaking, the work left for a person is the second and third piles, which is a short list rather than every sheet that arrived.
Proportions vary by batch and by how the school filled the sheet in. The shape is what matters: most of a batch clears on its own, and the part that does not arrives already sorted into "we found a problem" and "we could not check".
Conflicts Are Reported, Never Repaired
Sometimes the paper contradicts itself: a free entry credited in one place and written somewhere else, a total that cannot be produced from any reading of the rows. The system does not choose the interpretation that makes the sheet balance. It flags the conflict and describes it, because a school's paperwork is evidence and the software is not entitled to overrule it.
The Promise We Make
Not that the reading is perfect. Handwriting on a photocopied grid does not permit that promise, and any vendor who makes it is describing a demo.
The promise is that nothing wrong ships silently. Every uncertain row arrives flagged, with a reason a person can act on in seconds. The work that remains for a human is triage of a short list, instead of re-typing and re-checking every sheet that came in.
The Ontology, in One Sentence
Pages belong to sheets, sheets belong to register runs that can continue across pages, rows group into classes, and every group carries a verdict with the evidence behind it. Once that structure is written down, verification stops being a judgement call and becomes arithmetic, which is the only kind of check that holds up when the volume is thousands of sheets a season.