friends's prescription said 0-1-0, so I built a local Gemma app that turns it into a medicine card

khush chaudhari — Sun, 04 Oct 2026 17:59:40 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

DoseCard turns a doctor's prescription (a photo or typed text) into a large-print daily medicine card in Hindi and English that you can print or send on WhatsApp.

I built it for a friend, my neighbour's wife. She manages her prescriptions, and the instructions are often written in doctor's shorthand: 1-0-1, 0-1-0, HS. If nobody has taught you the code, 0-1-0 means one tablet in the afternoon and HS means at bedtime. It's easy to get wrong, and a wrong guess means taking a medicine at the wrong time.

DoseCard does three things:

Reads the prescription with Gemma, running on the laptop.
Shows her what it read and makes her check every medicine against the paper before anything goes on the card.
Makes the card: सुबह / दोपहर / शाम / रात (morning / afternoon / evening / night), before or after food, with a separate box for "only when needed" medicines.

It doesn't give medical advice. It only organises what the doctor wrote.

Demo

Live: https://dosecard.onrender.com/

The page is hosted on Render, but the AI isn't. Your browser sends the prescription to Ollama on your own computer (localhost:11434). So the live link only works if you have Ollama and the model installed, and the page walks you through that one-time setup. The video shows it running on my 8 GB MacBook.

Code

khushthecoder / cheetah_26

DoseCard

Photograph a doctor's prescription. Get a large-print, Hindi + English daily medicine card for the fridge — read by Gemma running on your own laptop.

Built for the Hacktoberfest 2026 Weekend Challenge: Build for a Friend.

Live: https://dosecard.onrender.com — the page is hosted; the AI runs on your own computer (see Deployment).

Why I built this

The problem

Indian prescriptions are written in shorthand: 1-0-1, BD, TDS, HS, OD, SOS, AC/PC, often by hand. Someone in the family has to translate that into "which pill, when, before or after food, until when" — and then re-explain it over the phone, or write it out again on paper, every time the prescription changes.

What DoseCard does

Add the prescription — a photo (up to 3 pages) or typed / pasted text.
Gemma reads it on-device — an open-weight model running in…

View on GitHub

How I Built It

Stack: Gemma 4 E2B (gemma4:e2b-it-qat, a 4.3 GB download) running locally in Ollama · React + TypeScript + Vite · Zod · Vitest · GitHub Actions · Render

My laptop is an 8 GB M3. That ruled out bigger models (the 6 GB E4B would push it into swap), so the whole design had to assume a small model.

Rule one: the model reads, code decides

My first version asked Gemma for each medicine and when to take it. I wrote a small eval (made-up prescriptions in different styles: GP shorthand, Latin codes, a Hinglish WhatsApp message) and measured it.

Gemma found all 23 medicines. But its own answer for when to take them was right only 9 times out of 23. It read HS (bedtime) as morning and 0-0-1 as evening.

The same model copying the dosing text exactly as written got all 23 right. So I split the job. Gemma only transcribes (1-0-1, BD, only if fever), and a deterministic, unit-tested decoder turns that into a schedule. If the decoder can't read something, the row is left blank for a person to fill in. The model is never asked to guess.

The eval caught my bugs too:

My decoder read Glimisave M1 1-0-1 as three times a day, and would have read Telma 40 1-0-0 as 40 tablets in the morning.
OD (once a day) was silently turned into "morning". The doctor never wrote a time, so now the app asks.
"Cetirizine at bedtime if itching" landed on the daily schedule. Any written condition now keeps a medicine in the "only when needed" box.

Then I tried my friend's real prescription

Typed test cases are one thing. Her prescription is handwritten, crumpled, in two columns, and the photo I got was sideways.

Attempt 1, the photo as it was: it ran for 98 seconds, got stuck repeating "T. Vit", and invented a medicine: "Telma 40, 1-0-1, after food, 5 days, with warm water". None of that is on her prescription. It was the example line from my own prompt.

Attempt 2, rotated upright, straight to JSON: most names came back, but none of the doses, and the header scribbles became "medicines".

Attempt 3, two passes. First I asked Gemma for a plain transcription, one medicine per line with its dose on the same line. About 6 seconds later:

T. Vite 0-1-0
T. zul (ad) 1-0-0
Butonim 0.05 ointment
BPO 2.5% gel.

Both doses were right. But when the second pass turned that text into medicines, it gave Vit C the dose 1-0-0, which is Zinc's dose from the next line. None of my checks caught it, because "1-0-0" really is on the page.

The fix that made it safe

Now code decides which dose belongs to which medicine. It finds the medicine's own line and takes the dose written on it, or on a dose-only line right below it. If the model paired them differently, the written position wins and the row is flagged.

The other fixes from that night:

A ↻ button, so the photo is upright before the model sees it
No real medicine names in the prompts (a test checks this)
A cap on output length, so a repetition loop fails in seconds, not minutes
She sees and can edit the transcription before anything else happens
Any name, strength or dose that isn't actually in the text gets flagged

The result on her prescription: Vit C → afternoon, Zinc → morning, matching the paper, with no wrong doses. It still misread names ("Vite" for Vit C, "Butonim" for Tretinoin) and missed the face wash entirely. That's exactly why the app won't make a card until every row has been ticked by a human.

Results

Typed eval: 8 prescriptions, 34 medicines. 3 of the prescriptions were written after the fixes as a held-out check.


Medicines found	34 / 34
Invented medicines	0
Schedule correct	32 / 34
Schedule wrong	0
Left for the person (`OD` with no time written)	2
Average time per prescription	7.2 s

98 unit tests run in GitHub Actions on every push, and Render only deploys after they pass.

What friends said

The first real-world test showed that DoseCard was useful, but it was not a magic one-click solution.

The biggest point of friction was the handwritten prescription itself. The AI could identify most of the medicines and correctly read the written dosing patterns, but some medicine names were unclear and needed to be corrected by the user.

The most useful part of the experience was the review step: instead of silently trusting the AI, the user could see what had been read, correct anything that was wrong, and only then generate the final daily schedule card.

That test changed the product in an important way. We stopped treating AI output as the final answer and designed DoseCard around AI transcription + human verification.

Why Does Open Innovation Matter?

Because this is a photo of someone's prescription.

With a closed API, step one would be uploading her health record (her name, her doctor, her medicines) to a company's server. With an open-weight model, it never leaves the laptop. That's not a privacy setting; there is simply no server in the path. Even the deployed site is just static files. Render serves the page, the browser talks to Gemma on your own machine, and the site's Content-Security-Policy only lets the page connect to itself and localhost.

Open weights also made the engineering possible:

I could measure the model honestly. I ran the eval and her prescription again and again while fixing things, at temperature 0, for free. That's how I found the model's timing guesses were right only 9 times out of 23, and designed around it instead of trusting it.
I could constrain it. Ollama's structured output forces Gemma to answer in my JSON schema, with limits on list length and output tokens.
It runs on what people actually have. A 4.3 GB model on an 8 GB laptop, offline, with no API key and no bill per prescription.
It can be swapped. One environment variable changes the model, and the eval tells me whether a new one is actually better.

Prize Categories

Gemma: DoseCard runs Gemma 4 E2B (open weights, QAT) locally through Ollama, both to read the photo and to structure the text.
Render: deployed as a Render static site from a Blueprint (render.yaml) with security headers, auto-deploying only after GitHub Actions CI passes.

DEV Community: khush chaudhari