The OCR Rabbit Hole

Andrew Judd — Thu, 21 May 2026 15:44:33 +0000

Long weekend. Pile of handwritten documents on the desk. They need to become structured data - searchable fields in an app, not just scanned images.

OCR's been around forever. This should take a couple of hours.

The Documents

They're handwritten. Different people, different paper, different decades. Faded ink on some. Crossed-out words on others. Notes crammed into margins where there wasn't really room.

Any person can read these in about five seconds. Remember that.

Tesseract

Saturday morning. Tesseract is free, it's open source, I can run it on my own machine. Good enough to start.

import pytesseract
from PIL import Image
from pathlib import Path

def extract_document(image_path):
    img = Image.open(image_path)
    text = pytesseract.image_to_string(img)
    return text

if __name__ == "__main__":
    for image_file in sorted(Path("images").glob("*")):
        print(f"\n--- {image_file.name} ---")
        print(extract_document(image_file))

Printed text? Fine. Handwriting? "2 1/4 cups flour" comes back as "2 114 cps flcar."

I try different config options. Page segmentation modes. OCR engine modes. Character allowlists. Each one helps somewhere and breaks something else.

Pre-Processing

Maybe the images are the problem.

import pytesseract
from PIL import Image, ImageFilter, ImageEnhance, ImageOps
import numpy as np
from pathlib import Path

def preprocess_document(image_path):
    img = Image.open(image_path)
    img = img.convert('L')
    img = ImageOps.autocontrast(img, cutoff=2)
    img = img.filter(ImageFilter.SHARPEN)
    img = ImageEnhance.Contrast(img).enhance(1.8)

    img_array = np.array(img)
    threshold = np.mean(img_array)
    img_array = ((img_array > threshold) * 255).astype(np.uint8)

    return Image.fromarray(img_array)

if __name__ == "__main__":
    for image_file in sorted(Path("images").glob("*")):
        print(f"\n--- {image_file.name} ---")
        img = preprocess_document(image_file)
        print(pytesseract.image_to_string(img))

Contrast boosting helps the faded ones. Hurts the clear ones. Binarization destroys the subtle parts of the handwriting. Sharpening makes some letters readable and others bleed together.

Every fix is a trade-off. I'm tuning parameters per document. That's not automation.

30-40% accuracy on the handwriting. Saturday morning gone.

Tesseract is great at printed text. That's not what I have.

Mistakes Happen

Andrew Judd — Tue, 19 Oct 2021 13:15:05 +0000

Software development is a mostly “behind the scenes” operation. This is great because we don’t need to be in the limelight to do our job, nor to be good at it. But, this also opens up the door for other possibilities as well.

We have a lot of different tools at our disposal for the code that we write, and with those tools, we also have a responsibility to use for good. And guess what, we are also human. So, we make mistakes!

When doing anything in life, mistakes are inevitable. They are made in every occupation, it’s how we react to them that matters. Unfortunately I’ve seen countless times people trying to “protect themselves” by covering up the mistake. We have the tools available to us to do some of this. But I have to ask why is it necessary? Just because we are sitting behind a screen and can slave away for a few extra hours to remedy it, doesn’t make it right. Sure, admitting that you made a mistake is a bit of a slap to the ego, it should be! It further proves that you are not infallible. On the flip side, if you don’t admit it to yourself or just try to cover it up, and you are able to repair it it may end up actually inflating your ego. Telling yourself, “See, I messed up and was able to power through and fix it, I’m an amazing developer.” This however, is missing the point. It’s a learning experience for you.

The bigger issue that I find when people try to cover up mistakes is the fact that, it gets the problem solved today, but:

What happens if you make bigger mistakes when covering up this one?
What happens if you don’t even realize you are missing one piece of the puzzle? (i.e. if you are restoring data in a database, and return data to 2 out of the 3 required tables)

Problem solving is part of our job, and these issues could just be looked at as another problem to solve, which is fair however, not favourable.

What happens if you make a mistake that you can’t cover up? What happens if one of your co-workers find out that you covered something else up? That’s when things start to go downhill fast. Your reputation has been tarnished. The worst part about it is the fact people know you do this, so sometimes the unasked question (or asked question) is “what else did you cover up?”. This of course will instill doubt within your co-workers. They also will lose faith in you, and at this point it’s difficult to rebuild this trust. You built part of the working relationship on lies, and betrayed your fellow developers, how can they trust you?

When you do make a mistake that you are not a fan of, instead of covering it up, do the following:

Get a good understanding of the mistake that was made, so you are able to explain it
Come up with possible solutions on how to resolve it
Mention to your team that you made this mistake, and have come up with a few options and ask colleagues for their opinions
Work with your colleagues to resolve the issue
Come up with an action plan to prevent this from happening in the future

Yes, doing this may add a scratch on your reputation but it will also help to add a feather into your cap. You have shown your co-workers a vulnerable side, and that you are fallible. Because of that, they will, over time, trust you more. They will know you tell the truth and aren’t trying to save face. You may also become one of the people that they go to when they inevitably make a mistake.

Mistakes suck, but are inevitable as humans. It’s how we choose to react and grow from them which shows a level of maturity and integrity that you have. The initial ego hit sucks, but the trust that you develop as a team member will help to reduce the overall burn from this mistake.

DEV Community: Andrew Judd

The OCR Rabbit Hole

The Documents

Tesseract

Pre-Processing

Mistakes Happen