Skip to content
Hackathon project

NANO

Arabic documents that exist only as photographs are effectively unsearchable. NANO turns a phone photo into structured, usable text in real time.

The product interfaces on this page are compositions built from each platform’s real module structure. They are not screenshots of production systems — these are private client and commercial platforms.

Role
Team member · Extraction pipeline & web interface
Year
2025
Status
1st place · ITS Hackathon 2025
Category
AI

NANO is an AI-powered optical character recognition platform that extracts and digitises text from images in real time. Built as a team under hackathon constraints, it pairs machine-learning inference with a production-shaped web interface — and won first place at the ITS Hackathon 2025.

The problem

An enormous amount of administrative information in Iraq exists only as images: a photographed invoice, a scanned form, a picture of a printed record. It cannot be searched, filtered, summed or checked. Somebody has to retype it, and that person makes mistakes.

The outcome

A working end-to-end product: image in, structured text out, through an interface a non-technical judge could use unaided. First place at ITS Hackathon 2025.

Stack

  • Python
  • FastAPI
  • OCR
  • Machine learning inference
  • React
  • REST API

Services

Back to all work

The problem with a photograph

A photograph of a document looks like information. To software, it is a rectangle of pixels — and everything downstream that wants to search, total or verify it has to wait for a human.

The gap is not exotic. Invoices, forms, records and receipts are captured on phones every day and then re-entered by hand into a system that could have read them directly. The re-entry is slow, it is expensive, and it introduces errors precisely where accuracy matters most.

From photo to structured text

  1. 01

    Capture

    A photograph or scan arrives — uneven lighting, a slight angle, a phone camera rather than a flatbed.

  2. 02

    Preprocess

    The image is normalised before any model sees it. Most accuracy problems in real-world OCR are image problems, not model problems.

  3. 03

    Recognise

    Machine-learning inference reads the text regions and produces raw character output.

  4. 04

    Structure

    Raw output becomes ordered, usable text rather than a wall of characters — the step that decides whether the result is actually useful.

  5. 05

    Present

    The interface shows source and extraction together so a person can verify the result instead of trusting it blindly.

The extraction pipeline. Each stage is independently inspectable — which is what made debugging possible inside the time limit.
Interface concept — the extraction stages made visible. Composed for this case study; not a captured screenshot of the hackathon build.

Why the interface won it

Most hackathon AI projects are a model with a form bolted on. They demo badly, because a judge cannot tell whether the output is right. The decision that mattered most in NANO was spending scarce hours on the interface rather than on chasing a marginally better recognition result.

  • Source image and extracted text are shown side by side, so correctness is checkable at a glance.
  • Processing state is visible — the user always knows whether the system is working or has failed.
  • Output is copyable and usable immediately, because an extraction nobody can act on is not a result.
  • The product runs as a web application, so evaluating it needs no setup — a real constraint when judging is timed.
Interface concept — source and extraction shown together, the decision that made the result verifiable.

My contribution

NANO was a team award, and it matters to say clearly which part was mine. I worked on the extraction pipeline and the web interface — the path from an uploaded image through to a structured result a person can read, check and copy.

  • Extraction pipeline: the sequence from captured image through preprocessing and recognition to structured output.
  • Web interface: upload, processing state, side-by-side verification and copyable output.
  • Pairing machine-learning inference with a production-shaped product rather than a notebook demo.

Architecture under time pressure

  • Interface

    Upload, state, verification view

    • React
    • REST client

  • Service

    One endpoint per pipeline stage

    • FastAPI
    • Python

  • Inference

    Preprocessing and recognition

    • Image preprocessing
    • OCR model inference
A deliberately thin stack. Every layer that could be removed was removed.
  • Challenge

    A single opaque endpoint makes it impossible to tell which stage is producing a bad result.

    Decision

    Each pipeline stage stays inspectable in isolation, so a bad extraction can be traced to preprocessing or to recognition.

    Trade-off

    Slightly more surface area than a monolithic call, and dramatically faster debugging.

  • Challenge

    Real photographs are nothing like clean test images.

    Decision

    Preprocessing was treated as a first-class stage rather than an afterthought before inference.

    Trade-off

    Time spent on image handling instead of model tuning — the right trade for real inputs.

Result and recognition

  • Recognition

    1st place — ITS Hackathon 2025

  • Award type

    Team award

  • My contribution

    Extraction pipeline and web interface

  • Deliverable

    Working end-to-end product

NANO is the shortest project on this site and one of the most instructive. Under a hard deadline you cannot build everything, so you find out quickly what you actually believe matters. In our case it was this: a model nobody can verify is not a product, and a product that needs a setup guide will not survive a five-minute evaluation.

Next case study

Building something in this space?

I am available for a limited number of projects. Tell me what you are working on.

Start a project