DEV Community: Dhanush Gowda

A receipt sorter that never leaves your laptop (Gemma + Ollama)

Dhanush Gowda — Wed, 14 Oct 2026 04:47:31 +0000

This is a submission for the Hacktoberfest Challenge, Week 2: Side Hustle.

What I Built

Freelancers collect receipts and invoices from many places: email PDFs, phone photos, app screenshots. At tax time someone has to type each one into a spreadsheet. Those documents hold client names, rates and payment details, and many freelancers don’t want them uploaded to a service they don’t control.

Local Receipt Sorter is a small app that runs entirely on the user’s own computer. You drop in receipts, it reads the vendor, date, invoice number, currency, subtotal, tax and total, flags anything suspicious, and exports a CSV or Excel file for the accountant. It also suggests a clean filename for each document, like 2026-03-04_acme-cloud_1180.00.pdf.

The side hustle idea: sell it to freelancers as [a one-time license / a monthly fee of X / a done-for-you service for X per batch].

Demo

Code

DhanushGowdaDev / Local-Receipt-Sorter

Local Receipt Sorter

Drop in receipts and invoices; get a reviewed CSV/Excel. Runs fully offline.

Setup

Install Ollama (https://ollama.com), then: ollama pull gemma3:4b
pip install -r requirements.txt
streamlit run app.py

Use a bigger model with RECEIPT_MODEL=gemma3:12b streamlit run app.py.

Measure accuracy

Put 30-50 receipts and a labels.json in eval_set/, then python eval.py eval_set.

View on GitHub

How I Built It
Model: a Gemma vision model (gemma3:4b) served locally through Ollama. Documents never leave the machine.
Structured output: the model’s answer is forced into a JSON schema, so every field comes back in a predictable shape.
Checks instead of self-reported confidence: small models are poor at judging their own accuracy, so I didn’t ask the model how sure it was. A rule-based checker flags missing fields, bad or future dates, non-positive totals, and rows where subtotal plus tax doesn’t equal the total.
Review before export: every row appears in an editable table, so the user fixes mistakes before the file is exported.
Stack: Python, PyMuPDF for PDFs, Streamlit for the interface, pandas for export.
What I Found

I tested it on 25 documents: 15 PDFs, 10 photos and 15 screenshots. .

One result I liked: my first test files were order pages that can generate an invoice, not actual invoices, and they had no date. I assumed the empty date column was a model failure and loosened my prompt. Then I realized the model was right: there was no date to read. I changed the prompt to say “never invent a date, vendor or amount” so it stays that way.

Why Open Innovation Matters
Privacy is the product. The documents are read by a model running on the user’s own computer.

I turned off Wi-Fi and it still worked.
No per-document fee. There’s no API bill that grows with each receipt, so a flat price can work.
I can change it. I can swap in a larger Gemma model with one setting, tighten the prompt, or fine-tune later for a specific kind of invoice.

I did not compare it against a closed model, so I’m not claiming it’s better. The claim is smaller: a small open model, running locally, can do a useful part of this job.

Limits
I tested only 25 documents, so these results show it works, not how often.

What’s Next

More test documents, a larger model, fine-tuning for a niche such as GST invoices, a first paying user

Prize Category

Best Use of Gemma. The whole project runs on Gemma through Ollama.

SurgiPlan

Dhanush Gowda — Sat, 10 Oct 2026 08:19:00 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

SurgiPlan — AI-Powered Operating Room Scheduling

SurgiPlan is an intelligent hospital scheduling system designed to optimize operating room allocation and hospital resource utilization.

Hospitals must coordinate surgeries while considering surgical priority, staff availability, equipment requirements, operating room capacity, and recovery beds. Managing these constraints manually can be challenging.

SurgiPlan uses constraint-based optimization to generate feasible schedules and includes an emergency surgery workflow and an AI copilot for scheduling assistance.

Demo

Live Application: https://surgiplan-frontend.vercel.app

Backend Health Check: https://surgiplan.onrender.com/api/health

Code

GitHub Repository: https://github.com/DhanushGowdaDev/SurgiPlan

How I Built It

I built SurgiPlan using the following technologies:

Frontend: React, TypeScript, Vite
Backend: Python and FastAPI
Optimization: Google OR-Tools with the CP-SAT solver
Database: MongoDB Atlas
AI Integration: Google GenAI SDK with Gemma integration
Deployment: Vercel for the frontend and Render for the backend

The scheduling engine models resource constraints to help assign surgeries to operating rooms while accounting for staff, equipment, and recovery-bed requirements.

The application also includes an emergency workflow and an AI copilot.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to inspect, adapt, and build upon existing technologies rather than starting from scratch.

In SurgiPlan, open-source tools such as FastAPI and Google OR-Tools provide a flexible foundation for backend development and constraint optimization. This allows the scheduling logic to be customized for different resource requirements and operational constraints.

Using modular components also makes it easier to experiment with new optimization strategies and improve the system over time.

My Agent Session

Not included.

Prize Categories

Render — Best Use of Render
Gemma — Best Use of Gemma
MongoDB — Best Use of MongoDB Atlas

These categories are relevant only if the implementation satisfies each partner's requirements. Verify the Gemma integration and demonstrate how MongoDB Atlas contributes to the application before claiming those categories.

SrgiPlan

Dhanush Gowda — Sat, 10 Oct 2026 08:14:42 +0000

SurgiPlan — AI-Powered Operating Room Scheduling & Resource Optimization

SurgiPlan is an intelligent hospital scheduling system designed to optimize operating room allocation and improve the use of critical hospital resources. Inspired by railway block scheduling, it helps coordinate surgeries while considering operating room availability, surgical priority, staff availability, equipment requirements, and recovery-bed capacity.

The system uses constraint-based optimization to generate feasible surgical schedules and help hospitals manage competing demands more efficiently. It also includes an emergency surgery workflow and an AI copilot to assist users with scheduling-related questions.

Key Features

Intelligent Scheduling: Optimizes operating room assignments and surgery timings.
Resource Management: Accounts for staff, equipment, operating rooms, and recovery beds.
Emergency Mode: Supports adding urgent surgical cases.
AI Copilot: Provides an AI-powered interface for scheduling assistance.
Web Dashboard: Offers a centralized interface to view surgeries, rooms, and resources.

Tech Stack

Frontend: React, TypeScript, Vite
Backend: Python, FastAPI
Optimization Engine: Google OR-Tools (CP-SAT)
Database: MongoDB Atlas
AI: Google GenAI SDK with Gemma integration
Deployment: Vercel (frontend) and Render (backend)

Project Links

Live Demo: https://surgiplan-frontend.vercel.app
GitHub Repository: https://github.com/DhanushGowdaDev/SurgiPlan
Backend API: https://surgiplan.onrender.com/api/health

SurgiPlan explores how constraint optimization and AI can help tackle complex resource-allocation problems in healthcare. The goal is to make operating room scheduling more structured, resource-aware, and adaptable to changing hospital needs.