DEV Community: Utkarsh Singh

A private interview coach that runs in my friend's browser — no server ever saw their resume

Utkarsh Singh — Sun, 18 Oct 2026 12:19:19 +0000

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

Honest timing note: the weekend window closed on Oct 5 and this was built after. I'm publishing anyway, for the love of completing the arc — this week it earns no prize and no badge. It's just a gift with documentation.

What I Built

InterviewBuddy — a private AI mock-interview coach that runs entirely inside one browser tab. No server. No account. No install.

The friend: a college friend of mine, mid job-hunt. Their interview prep routine at 2 AM is: job description open in one window, their own resume in another, talking sections out loud to an empty room. Real feedback doesn't exist at that hour — every “AI interview coach” is a hosted service that wants their resume uploaded to someone's cloud first (and resumes are the single most personal document a candidate owns).

So I built the coach the shape of a browser tab instead:

paste the job description and their resume/notes (nothing uploads — there's no server to upload to),
Gemma generates five interview questions grounded in that exact role and that exact person,
they answer out loud and type the gist; each round gets Strength / Improve / Sharper answer feedback,
it ends with a debrief: two things done well, two to practise, and a confidence score.

Demo

Try it at https://4-thkind.github.io/interviewbuddy/ — click once and the browser downloads Gemma 3 1B (~0.5 GB) one time, then caches it. After that, unplug the network; it still works.

What a real session looks like — five questions pulled from the pasted JD + resume, and round-one coaching:

The final debrief, where it names what worked and what to practise before the real thing:

Code

The whole product is 4-thkind/interviewbuddy: eight files, and the app itself is exactly two of them — index.html and app.js. No bundler, no backend, no SDK key.

git clone https://github.com/4-thkind/interviewbuddy
npx serve .          # or python -m http.server
# open the tab, paste a JD + resume, click start

How I Built It

Model: onnx-community/gemma-3-1b-it-ONNX — Gemma 3 1B quantized to q4 (~0.5 GB), loaded straight into the tab with Transformers.js v4, GPU-accelerated by WebGPU, with a graceful WASM/CPU fallback (the UI badge tells you which one you're on). Streaming output lands token-by-token, which makes a 1B model feel alive.
I deliberately skipped Ollama. My previous Hacktoberfest build ran a 4B model through a local server — great for my RTX laptop, wrong for a friend who shouldn't have to install anything. The entire footprint here is: a webpage and one cached model file. Nothing installs, nothing persists, nothing runs when the tab closes.
Fresh short context per turn. Question generation and every feedback round get their own compact messages array instead of one long transcript — a 1B model stays sharp in small windows and drowns in long ones.
do_sample: false, after the model earned it. With sampling on, Gemma started inventing candidate background that wasn't in the resume. Temperature 0 keeps the coach honest: it may be dull, but it never lies about who the candidate is.
Prompt-compliance is enforced in code, not hoped for. “Exactly 5 questions, lines end with ?, no commentary” is backed by a parser that strips numbering, filters non-question lines, and falls back to a legal default. A 1B model will occasionally answer its own question — the app must survive that.

Why Does Open Innovation Matter?

The privacy argument collapses without open weights. If the model were closed, the only way to run it is the other company's server — the resume leaves the laptop, and my friend's leverage in a negotiation ends up in someone else's training pipeline. Open weights make “it never leaves this tab” physically true, not a policy promise.
A gift must be free to keep. A hosted interview coach costs a subscription for a friend who is, definitionally, broke. Gemma 1B local costs exactly nothing — per question, per session, ever — and that price is what makes “here, take this” a whole gift instead of a trial.
No internet, no problem. Campus Wi-Fi dies during every exam week at my college. After the one-time download, the browser has the model; InterviewBuddy is interview practice that survives the outage.
The friend can read and change their own coach. The prompt is 12 lines of plain English in app.js. If they want stricter cold-read questions or a softer tone, they edit one file. Try asking a closed API for that.

My Agent Session

This was built in one working session with an AI coding agent — I picked the friend, the constraints (“lighter than last time, no Ollama, no installs”) and reviewed everything. The honest build log, including the two bugs found while driving it live (a DOM-history bug and a question-parser failure), is in AGENT_NOTES.md.

Prize Categories

Best Use of Gemma — Gemma 3 1B runs entirely on-device in the browser (ONNX q4 via WebGPU), powers every part of the coach, and swapping to gemma-3-4b on a stronger laptop is a one-line change.

(Solo build — no teammates.)

The $0-per-report feature: a patient-friendly radiology explainer that runs on the clinic's own laptop

Utkarsh Singh — Sun, 18 Oct 2026 11:10:50 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

PlainRay turns radiology reports into plain-language patient explainers — on the clinic's own machine, with an open-weight model, for zero rupees per report.

It reads a report and produces, in one pass:

a plain-language summary of what the exam showed (under 150 words, roughly 8th-grade reading level),
a glossary of every term and abbreviation it used, translated to everyday words ("consolidation → cloudy areas in the lung"),
questions the patient can ask their doctor, and
a calm urgency note — only if the report itself flags something, in the report's own wording. The model is not allowed to invent findings, diagnose, or reassure.

Who would pay for this: the kind of clinic that runs two radiologists, one front desk, and a stack of reports whose first word is usually "IMPRESSION:". Behind that desk sits a person who answers "what does effusion mean?" eleven times a week. Every hosted "AI patient portal" wants a per-report meter and a copy of the report on someone else's server. PlainRay flips it: flat license, zero usage cost, nothing ever leaves the machine.

The side-hustle math that makes it a real product instead of a demo: the clinic already owns the laptop, and the model runs on an RTX 4060. So the unit economics are: model = free forever, electricity = what the lamp costs, product = one flat fee per workstation. There is no other version of this offer where the cost driver of the whole business is $0 — that's only possible because the model is an open-weight one you can download.

Demo

Three synthetic reports are in the repo (samples/sample_reports.json — no real PHI is ever committed). Here is the actual flow, captured locally while the machine was offline for everything else:

The second frame is the mammography screening sample — the star of the show, because screening reports are the least readable of all (see it here).

No login, no cloud, no network. Unplug the ethernet cable and it keeps working — that is the demo. Run it yourself:

git clone https://github.com/4-thkind/plainray
ollama pull gemma3:4b          # one time, ~3 GB
python -m plainray serve       # http://127.0.0.1:7860
python -m plainray explain --file report.txt   # JSON on stdout
python -m plainray selftest    # prompts + validator + readability, no model needed

Code

Everything lives in the 4-thkind/plainray repo:

plainray/llm.py — a minimal local Ollama client in stdlib urllib, ~40 lines. No pip, no SDK.
plainray/prompts.py — the patient-safety prompt, readable in plain text by whoever deploys it.
plainray/app.py — CLI (explain / serve / selftest) and a validator that enforces the JSON shape: caps list lengths, dedupes glossary terms, refuses an empty summary.
plainray/readability.py — a Flesch-Kincaid grader in stdlib. Numbers, not promises.
static/index.html — the UI; the server binds to 127.0.0.1 on purpose.

How I Built It

Model: Gemma 3 4B (open weights), served locally by Ollama on an RTX 4060 Laptop (8 GB VRAM). One-time ~3 GB pull; after that it runs offline. Generation takes ~30 s per report on this laptop.
The prompt is the product. Anti-diagnosis, no invented findings, glossary limited to terms that actually appear in the report, calm-not-reassuring urgency wording. That last rule came from watching Gemma happily soften "consolidation" into "all is well" — which is exactly wrong for a patient explainer.
Structured output enforced in code, not trusted from the model. _validate() rebuilds the JSON from scratch. A 4B model will slip a made-up term into the glossary now and then ("mets", when the report never said it) — the design answer is to show the glossary to a human for one click of review, not to pretend the model is a pharmacist.
Measured readability. The Flesch-Kincaid grade runs on the raw report and on the generated explainer, and both numbers show in the UI:

Sample report	Raw grade	PlainRay explainer
Chest X-ray, consolidation	10.4	7.6
Knee MRI, meniscus tear	10.0	7.6
Mammography screening	12.3	6.7

Zero dependencies: everything is stdlib (urllib, http.server). Clinic IT never touches a package manager.
Swapping the model is one variable (PLAINRAY_MODEL): gemma3:12b on a bigger box, or the medical-tuned sibling medgemma — same code, same prompt.

Why Does Open Innovation Matter?

PHI is the whole story. A radiology report is protected health information. A closed, hosted model requires sending that text to someone else's server before any feature can run — which is why most clinics simply don't have this feature. With Gemma running locally, that sentence disappears from the compliance conversation: the data physically cannot leave the laptop.
It fixes the cost basis of the product. A center reading ~120 reports a day on a hosted API pays a meter every month, forever, for a feature most clinics treat as nice-to-have. Local open weights move that cost to approximately zero — which is what makes the pitch survive an accountant.
Unplugged beats pretty. The internet does go down in small clinics. PlainRay doesn't care; the server is on the same machine.
Customize for a niche. A general-purpose closed API handles "ACR 2" the way a search engine does. Locally, a clinic can tune the prompt to their own reporting style, and the weights are there if they ever want to go further.
Fair for a two-doctor clinic. No usage meter, no lock-in, no per-seat squeeze. The feature that is free for a solo practitioner is the same for a hospital.

My Agent Session

This project was built in one working session with an AI coding agent — I set the problem, the constraints ("small, specific, useful, and it must actually run on this laptop") and reviewed everything it produced. The short form of that session — constraints discovered first, the decisions worth keeping, and what was hard — is checked into the repo as AGENT_NOTES.md. No DevRelay install for this build; the notes file is the session, honestly summarized.

My First User

Honest version: my first real user test hasn't happened yet. During this challenge window I built the product and ran it end-to-end on my own machine against three synthetic reports; nobody's real report went through it, because the right first user is a clinic that will trade one afternoon for a demo, and setting that up properly takes longer than the window. Rather than report a fake ten, here is the actual next step: one call to my cousin's ortho clinic, a printed example made from samples/, and two questions I'll log verbatim in the repo — would you pay, and how much per year?

If you're a radiologist or run a small clinic and want to be user #1: the demo runs from a fresh clone in under two minutes, and my contact is on my profile.

Prize Categories

Best Use of Gemma — Gemma 3 4B runs entirely on-device through Ollama, powers the whole product, and the architecture keeps gemma3:12b / medgemma as one-variable drop-ins.

(Solo build — no teammates.)