DEV Community: Ishaan Chowdhury

OpenKhata: Building a Local-First Digital Credit Ledger for a Kirana Shop

Ishaan Chowdhury — Sun, 04 Oct 2026 03:32:20 +0000

Yes — this is the official Hacktoberfest Weekend Challenge submission template. Your current OpenKhata post should be reshaped to follow these exact sections.
Here is a ready-to-paste final version, using your actual project, demo, Rahul feedback, technical implementation, and Gemma usage. I would use this instead of the longer GitHub-style version.
OpenKhata: Building a Local-First Digital Credit Ledger for a Kirana Shop
This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
What I Built
I built OpenKhata for my friend Rahul, whose family runs a traditional kirana (neighborhood grocery) shop in India.
In a small shop, customer credit — udhar — is often tracked in a handwritten khata. It works, but finding old entries, keeping track of outstanding balances, and writing every transaction manually can become inconvenient.
So I built OpenKhata as a local-first digital khata that lets a shopkeeper record transactions using either:

Quick typed entry
Voice entry using the laptop microphone The core idea is simple: AI assists with the entry, but the shopkeeper remains in control of what gets saved.

A voice entry goes through:
Voice → Local Whisper → Transcript → Local Gemma 3 4B → Structured transaction → Safety checks → Human confirmation → SQLite
If the system is uncertain about an amount or customer, it does not silently guess and save the transaction.
For example, during testing I used:
Rahul-er 340 na 3400 baaki

The application detects that two possible monetary amounts were spoken — ₹340 and ₹3,400 — and refuses to choose between them automatically.
The shopkeeper must resolve the ambiguity before the transaction can be saved.
I also added an optional WhatsApp reminder that generates a pre-filled message link, rather than automatically sending anything.
Demo
🎥 Demo Video:
https://drive.google.com/file/d/1PMPooBlJqikraozcAmFbAUmQreW5YTBW/view?usp=sharing
The demo shows:

A normal credit transaction through Quick Entry.
Voice recording and local transcription.
Gemma extracting the transaction structure.
An ambiguous amount being detected and blocked.
The ledger and customer balance.
A pre-filled WhatsApp reminder link. One important limitation is also demonstrated: Whisper can mishear Bengali/Hindi/English code-mixed speech. I intentionally kept this limitation visible instead of pretending the speech recognition is perfect. Code
ishaanchowdhury1 / OpenKhata

A local-first digital khata for small shops with voice-assisted credit entry, human confirmation, and a SQLite ledger.
📒 OpenKhata

A local-first digital khata for a small kirana shop.

OpenKhata lets a shopkeeper record customer credit using typed entry or voice. AI assists with transcription and extraction, but the shopkeeper confirms the transaction before anything is written to the ledger.

Core flow

Voice → Local Whisper → Transcript → Local Gemma 3 4B → Structured transaction → Human confirmation → SQLite

Features
- Quick typed credit/payment entry
- Browser voice recording
- Local Whisper transcription
- Local Gemma 3 4B extraction through Ollama
- Human confirmation before saving voice transactions
- Ambiguous amounts are not silently selected
- Existing-customer selection for unrecognised spoken names
- Explicit confirmation before creating a new customer
- SQLite customer ledger
- Optional WhatsApp reminder with a pre-filled message
- No automatic WhatsApp sending
Known limitations

Whisper medium can mishear Bengali/Hindi/English code-mixed speech and can produce names in different scripts. Voice is therefore an assisted workflow rather than an automatic write path.

Requirements
- Python…
View on GitHub
GitHub: https://github.com/ishaanchowdhury1/OpenKhata OpenKhata is MIT-licensed. The main stack is:
Python
Streamlit
SQLite
Pydantic
Whisper
Gemma 3 4B
Ollama The repository also contains focused automated tests for the extraction safety rules. How I Built It The most important design decision was to keep the core AI processing local.
Local speech recognition The shopkeeper can record speech directly from the browser. OpenKhata uses Whisper Medium locally to convert the recording into text. The speech can contain Bengali, Hindi and English mixed together. However, this also introduced one of the biggest problems I encountered: Whisper does not reliably understand every code-mixed phrase. Instead of allowing another AI model to blindly "fix" the transcript, I treat the transcript as uncertain input.
Local Gemma extraction The transcript is passed to Gemma 3 4B running locally through Ollama. Gemma converts the unstructured transcript into structured information such as:
Customer name
Items
Quantity
Amount
Due-date expression
Transaction type
Confidence values
Ambiguities For example, the model can turn a phrase like: Suresh-er 1200 baaki ache

into a structured transaction representing a ₹1,200 credit balance.
But the model is not trusted as the final authority.

Deterministic safety checks This is one of the most important parts of OpenKhata. After Gemma produces its output, normal Python application logic checks the result. The safety layer handles cases such as:
Low amount confidence
Low customer-name confidence
Negative amounts
Multiple possible monetary amounts
Distinguishing quantities such as 5 kg from money
Future payment promises vs. payments already received
Ambiguous customer names For example: Rahul-er 340 na 3400 baaki

contains two possible monetary amounts.
Instead of asking Gemma to decide which one is correct, the application-level check detects the conflict and blocks the save.
The principle is:
Don't make the LLM the final authority over financial data.

Human confirmation Before a voice transaction reaches SQLite, the shopkeeper gets a confirmation step. They can review and correct:
Customer
Amount
Transaction type
Due date
Description
Phone number There is also an explicit confirmation when the system is about to create a new customer. Only after confirmation is the transaction written to the ledger.
Local ledger The confirmed transaction is stored in a local SQLite database. OpenKhata keeps track of:
Customers
Credit transactions
Payments
Current balances
Transaction history The data stays on the local machine rather than being sent to a remote database.
WhatsApp reminders For customers with an outstanding balance, OpenKhata can generate a WhatsApp link containing a pre-filled reminder. It does not automatically send the message. The shopkeeper remains responsible for reviewing and sending it. Why Does Open Innovation Matter? For this project, open and local AI wasn't just a technical choice. The application deals with customer names and outstanding financial balances, so keeping the core processing on the shopkeeper's computer is valuable. With local models, OpenKhata can perform its core AI workflow without sending every voice recording or transaction to a paid cloud AI API. It also means the project can be:
Run locally
Modified by developers
Inspected instead of treated as a black box
Built around open tools and models
Adapted to different languages and shop workflows
Used without paying for every AI request This would have been much harder to design around a closed API where every voice entry had to be sent to a remote service. There is also an important limitation: local-first does not mean completely internet-independent. The models need to be downloaded initially, and WhatsApp itself requires internet access. The core AI processing and ledger, however, run locally. My Friend's Feedback I handed the prototype to Rahul and asked him to test it and give me honest feedback. He liked that it felt fast, helpful and modern, and he felt it could be useful because manually writing every transaction in a diary is not always practical. He also found the first use somewhat confusing because it was his first time using the application. His biggest feature request was broader multilingual support, rather than limiting the experience to Bengali or Hindi. Most importantly, he said he would use something like this in the shop because it would make maintaining the khata more convenient. That feedback changed what I want to work on next: better multilingual speech recognition and broader language support. What I Learned The biggest lesson from OpenKhata wasn't that AI can replace a traditional khata. It was this: AI should know when not to guess.

Whisper can make transcription mistakes.
Gemma can be uncertain.
Names can appear in different scripts.
Amounts can be ambiguous.
So rather than trying to make the AI appear perfect, I designed the system around those failures:
AI assists → deterministic checks verify → human confirms → database saves
For financial data, that felt much more responsible than allowing an LLM to make the final decision.
Prize Categories
🏆 Best Use of Gemma
OpenKhata uses Gemma 3 4B locally through Ollama as the natural-language understanding layer between messy shopkeeper speech and structured financial data.
Gemma handles the difficult language interpretation:
Transcript → Customer + Items + Amount + Due Date + Transaction Type + Confidence
The application then performs deterministic safety checks and requires human confirmation before saving.
This separation lets Gemma be useful without making the model the final authority over financial data.
What's Next?
Based on Rahul's feedback, the next major improvement would be broader multilingual support.
I would also like to improve speech recognition for real-world Bengali/Hindi/English code-mixed conversations.
For now, OpenKhata deliberately keeps the shopkeeper in control of every uncertain transaction.
🔗 Links
GitHub:
https://github.com/ishaanchowdhury1/OpenKhata
Demo Video:
https://drive.google.com/file/d/1PMPooBlJqikraozcAmFbAUmQreW5YTBW/view?usp=sharing

OpenKhata: Building a Local-First Digital Credit Ledger for a Kirana Shop

Ishaan Chowdhury — Sat, 03 Oct 2026 13:14:39 +0000

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

What I Built

I built OpenKhata for my friend Rahul, whose family runs a traditional kirana (neighborhood grocery) shop in India.

Customer credit (udhar) is traditionally tracked in a physical khata. During busy hours, entering and finding handwritten transactions can be inconvenient, especially as the number of customers and transactions grows.

OpenKhata is a local-first digital khata that lets a shopkeeper record credit transactions through fast typed entry or spoken voice notes.

The important part isn't just the AI. Nothing from an uncertain voice entry is silently written to the ledger. The shopkeeper gets a confirmation step before the transaction is saved.

Demo

Demo Video: https://drive.google.com/file/d/1PMPooBlJqikraozcAmFbAUmQreW5YTBW/view?usp=sharing
Key Demonstration:
1. Quick Entry — Record a normal credit transaction directly into the local SQLite ledger.
2. Voice Safety Gate — The shopkeeper says: "Rahul-er 340 na 3400 baaki". Whisper produces the transcript, and an application-level check detects that two monetary amounts were spoken: ₹340 and ₹3,400. Instead of choosing one, OpenKhata clears the amount and requires the shopkeeper to resolve the ambiguity before saving.
3. WhatsApp Reminder — The Ledger generates a pre-filled payment reminder link. OpenKhata does not automatically send the message.

Code

ishaanchowdhury1 / OpenKhata

A local-first digital khata for small shops with voice-assisted credit entry, human confirmation, and a SQLite ledger.

📒 OpenKhata

A local-first digital khata for a small kirana shop.

OpenKhata lets a shopkeeper record customer credit using typed entry or voice. AI assists with transcription and extraction, but the shopkeeper confirms the transaction before anything is written to the ledger.

Core flow

Voice → Local Whisper → Transcript → Local Gemma 3 4B → Structured transaction → Human confirmation → SQLite

Features

Quick typed credit/payment entry
Browser voice recording
Local Whisper transcription
Local Gemma 3 4B extraction through Ollama
Human confirmation before saving voice transactions
Ambiguous amounts are not silently selected
Existing-customer selection for unrecognised spoken names
Explicit confirmation before creating a new customer
SQLite customer ledger
Optional WhatsApp reminder with a pre-filled message
No automatic WhatsApp sending

Known limitations

Whisper medium can mishear Bengali/Hindi/English code-mixed speech and can produce names in different scripts. Voice is therefore an assisted workflow rather than an automatic write path.

Requirements

Python…

View on GitHub

GitHub: https://github.com/ishaanchowdhury1/OpenKhata
License: MIT
Tests: 7 automated unit tests covering extraction-safety rules in tests/test_safety.py

How I Built It

graph TD
    A[Shopkeeper Spoken Audio] --> B[Local Whisper Model]
    B --> C[Raw Transcript]
    C --> D[Local Gemma 3 4B via Ollama]
    D --> E[Pydantic Validation]
    E --> F[Deterministic Safety Checks]
    F --> G[Human Confirmation]
    G --> H[Local SQLite Ledger]
    H --> I[WhatsApp Reminder Link]

Local speech-to-text

Whisper medium runs locally on the laptop. One of the most important things I learned while building this was that code-mixed Bengali/Hindi/English speech is not reliably transcribed every time. For example, a phrase like "Ramesh-da 2 kg rice, 340 baaki" was transcribed incorrectly during testing. So I didn't try to hide that failure. Instead, voice became an assisted workflow, and uncertain entries require confirmation before they can affect the ledger.

Local structured extraction

Gemma 3 4B runs locally through Ollama and converts the transcript into structured transaction data: customer, items, amount, due-date expression, transaction type, confidence values, and ambiguities.

Deterministic safety layer

This is deliberately separate from the model. Python application-level rules check things such as low amount confidence, low customer confidence, negative amounts, multiple possible monetary amounts, quantity numbers (e.g., 5 kg vs. monetary values), and future payment promises vs payments already received. The principle is simple: Don't make the LLM the final authority over financial data.

Storage and UI

The application uses Streamlit, SQLite, Pydantic, local Whisper, and local Gemma 3 4B through Ollama.

Why Local and Open Technology Matter

Customer names and outstanding balances are sensitive information. OpenKhata keeps the core AI processing local on the laptop after the models have been downloaded, rather than requiring every transaction to be sent to a cloud LLM API.

This also means the application can continue to perform its core ledger and AI processing without depending on a per-request cloud AI service.

WhatsApp reminders are different: they generate a web link, so using WhatsApp itself requires internet access. The project is MIT-licensed, while Gemma 3 4B is an open-weight model used locally through Ollama.

Real Friend Handover

I handed the prototype to Rahul and asked him to use it and give honest feedback.

What he liked: Rahul said he loved it because it felt fast, helpful, and modern. He also said that writing every transaction manually in a diary/khata isn't always practical anymore.
What was confusing? He said it was somewhat confusing at first because it was his first time using the application.
What would he change? His main request was broader multilingual support, rather than limiting the experience to only Bengali or Hindi.
Would he use it? Rahul said he would use it in the shop because he found it helpful for reducing manual bookkeeping.

What I Learned

The biggest lesson wasn't that AI can replace the khata. It was that AI should know when not to guess.
Whisper made mistakes. Gemma can be uncertain. Names can appear in different scripts. Amounts can be ambiguous.

So instead of trying to make the AI look perfect, I designed the system around those failures:
AI assists ➔ deterministic checks verify ➔ human confirms ➔ database saves.

That ended up being more important than adding another AI feature.

Best Use of Gemma

OpenKhata uses Gemma 3 4B via Ollama to transform noisy, code-mixed shopkeeper speech into structured transaction data with confidence and ambiguity information. The model is useful because it handles the messy language layer, while the application code remains responsible for the final financial safety checks.

What's Next

Based on Rahul's feedback, the next improvement would be broader multilingual support. I also want to improve speech recognition for real-world Bengali/Hindi/English code-mixed shop speech. For now, OpenKhata deliberately keeps the human in control.

GitHub: https://github.com/ishaanchowdhury1/OpenKhata
Live Demo Video: https://drive.google.com/file/d/1PMPooBlJqikraozcAmFbAUmQreW5YTBW/view?usp=sharing

Hacktober2026

Ishaan Chowdhury — Fri, 02 Oct 2026 12:47:37 +0000

Hi everyone, I am too excited about this year's Hacktober Fest