DEV Community: Sumeet Choudhary

LocalLedger - Your private AI expense copilot.

Sumeet Choudhary — Mon, 19 Oct 2026 04:39:08 +0000

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

LocalLedger — Your Private AI Expense Copilot for Indian Freelancers

Your private AI expense copilot.

LocalLedger is a local-first AI expense intelligence tool built for Indian freelancers, solo developers, creators, consultants, and small businesses.

It turns receipts and invoices into a structured, searchable, validated expense ledger using local OCR, deterministic financial validation, SQLite, and an open-weight Gemma model running locally through Ollama.

The core idea is simple:

AI understands the document. Code protects the numbers.

🚀 What I Built

Managing invoices and business expenses can quickly become messy, especially for freelancers and small businesses.

LocalLedger provides a privacy-focused workflow for turning financial documents into useful structured information:

IMPORT → EXTRACT → UNDERSTAND → VALIDATE → CLASSIFY → REVIEW → ANALYZE → EXPORT

Users can upload:

PDF invoices
Scanned PDFs
JPG/JPEG images
PNG images
WEBP images

LocalLedger then processes the document locally and extracts information such as:

Vendor name
Invoice number
Invoice date
Subtotal
Discount
Taxable amount
CGST
SGST
IGST
GST total
Total amount
GSTIN
Expense category
Description
Business-expense classification
Extraction confidence

The extracted information is then validated using deterministic rules before being stored in the expense ledger.

💡 Why LocalLedger?

Financial documents contain sensitive information.

Instead of sending invoices and receipts to a cloud AI service, LocalLedger is designed around a local-first architecture.

The goal is to keep financial documents and AI processing under the user's control.

Local-first by design

🤖 Gemma 3 4B runs locally through Ollama
🔍 Local OCR
🗄️ SQLite local database
🔒 No cloud AI required
📄 Documents remain local
🧮 Financial calculations are handled by deterministic code
🧠 AI is used for interpretation rather than blindly calculating financial values

This makes LocalLedger particularly useful for people who don't want their financial documents uploaded to third-party AI services.

🏗️ How It Works

                    ┌──────────────────────┐
                    │      User Upload     │
                    │ PDF / JPG / PNG etc. │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │   Document Ingestion │
                    └──────────┬───────────┘
                               │
                    ┌──────────┴───────────┐
                    │                      │
                    ▼                      ▼
          ┌─────────────────┐    ┌─────────────────┐
          │ Native PDF Text │    │   Local OCR     │
          │   Extraction    │    │   for Scans     │
          └────────┬────────┘    └────────┬────────┘
                   │                      │
                   └──────────┬───────────┘
                              ▼
                    ┌──────────────────────┐
                    │ Structured Extraction│
                    │       Pipeline       │
                    └──────────┬───────────┘
                               ▼
                    ┌──────────────────────┐
                    │    Gemma 3 4B        │
                    │  Local AI Reasoning  │
                    └──────────┬───────────┘
                               ▼
                    ┌──────────────────────┐
                    │ Pydantic Validation  │
                    └──────────┬───────────┘
                               ▼
                    ┌──────────────────────┐
                    │ Financial Validation │
                    │    & Duplicate Check │
                    └──────────┬───────────┘
                               ▼
                    ┌──────────────────────┐
                    │     Expense Ledger   │
                    └──────────┬───────────┘
                               │
                 ┌─────────────┼─────────────┐
                 ▼             ▼             ▼
            Dashboard       Review        Export

🎥 Demo

GitHub Repository: https://github.com/sumeet156/LocalLedger

Video Demo: Watch the LocalLedger demo

🌍 Why Open Innovation Matters

LocalLedger would not have been possible in the same way without open-source and open-weight technologies.

The project combines open technologies across multiple layers:

Open-weight Gemma model
Ollama for local model execution
FastAPI
React
Python
SQLite
Pydantic
Local OCR tooling The open ecosystem makes it possible to build a useful AI application without depending entirely on proprietary cloud AI APIs.

More importantly, it allows developers to experiment with privacy-preserving AI applications.

For financial documents, this is especially important.

Instead of asking:
"How can I send this document to an AI?"

LocalLedger asks:
"How much intelligence can we bring to the user's machine?"

🏅 Prize Categories & Tools

🏆 Hacktoberfest — Side Hustle
🤖 Google / Gemma
🌍 Open-Weight AI
🛠️ AI-powered Productivity / Developer Tools
🎙️ *ElevenLabs for creating demo video

Sidewalk Safari: Local AI That Gives You a Reason to Leave the Screen

Sumeet Choudhary — Sun, 11 Oct 2026 05:38:46 +0000

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

What if AI's job wasn't to keep us looking at the screen — but to give us something worth looking at outside?

For the Touch Grass challenge, I built Sidewalk Safari, a screen-light outdoor quest generator powered by local Gemma AI.

The idea is simple:

AI creates the adventure. You go live it. 🌿

What I Built

Sidewalk Safari generates short, age-appropriate outdoor observation missions that encourage people — especially kids and families — to explore their surroundings instead of spending more time inside an app.

You choose:

🌳 Outdoor setting
⏱️ Available time
👦 Age group
🍂 Season
☁️ Optional weather note

Then Gemma 3 4B, running locally through Ollama, creates a small outdoor adventure.

For example:

FIND SHAPES

Locate five different leaf shapes scattered across the ground and draw them in your mind's eye.

COUNT THINGS

Estimate the number of different shades of brown you can observe in fallen leaves.

The missions encourage simple actions:

FIND → COMPARE → COUNT → NOTICE

And once the safari is ready, the app tells you to put the phone away.

🌱 Why Sidewalk Safari?

A lot of AI products are designed to keep you interacting with the screen.

I wanted to reverse that.

Instead of:

AI → Screen → More Screen Time

PLAN
↓
GENERATE
↓
PUT PHONE AWAY
↓
GO OUTSIDE
↓
OBSERVE
↓
EXPLORE

The screen is only the starting point.
The goal is what happens after you stop looking at it.

Demo

SideWalk Safari Demo Video

Code

The entire project is open source:

GitHub:
Sidewalk Safari

The project is designed to run locally using Ollama and Gemma.
Tech Stack

React
TypeScript
Vite
Python
FastAPI
Ollama
Gemma 3 4B
Browser Storage

How I Built It

React + Vite
↓
FastAPI
↓
Ollama
↓
Gemma 3 4B
↓
JSON Mission Output
↓
Validation + Safety Rules
↓
Safe Mission Pack

Gemma doesn't directly control the application.
It proposes missions.
The application then decides whether those missions are acceptable.

🤖 Gemma Proposes. Code Validates.

This was one of the most important design decisions in Sidewalk Safari.
A language model can generate something that sounds reasonable but isn't necessarily appropriate for the selected age, time limit, or environment.
So generated missions go through validation for:

Age appropriateness
Time budget
Allowed outdoor activities
Safety rules
Mission structure
Required safety guidance

The system uses constrained JSON output so the backend receives structured mission data rather than arbitrary text.

The principle is:
Don't blindly trust the model.

If a generated pack doesn't pass validation, generation is retried.
And if bounded generation attempts still fail, Sidewalk Safari falls back to a handwritten backup mission pack rather than leaving the user with a broken experience.
This means the AI is responsible for creativity, while the application remains responsible for safety and control.

🔒 Local AI by Design

One of the biggest reasons I chose Gemma + Ollama was that Sidewalk Safari doesn't need a cloud AI endpoint to generate its missions.

That gives the project some important properties:

No cloud AI endpoint :The mission-generation model can run on the user's own computer.
No accounts :The application doesn't require users to create an account just to go outside.
No exact-location tracking :I deliberately avoided requiring precise location data. Even the weather field is user-entered rather than automatically sending coordinates to a weather service.
Saved packs can work offline :Once a safari pack has been saved, it can be played without a network connection.

🛡️ Safety Wasn't an Afterthought

Because this project is designed for children and families, safety couldn't simply be left to an LLM prompt.
For younger age groups, Sidewalk Safari includes adult-supervision guidance.
The application itself generates the safety guidance and performs validation rather than relying on Gemma to make the final safety decision.

This separation was intentional:

Gemma generates.
Code validates.
The user explores.

Why Does Open Innovation Matter?

This is the part of the project I think matters most.

I could have built Sidewalk Safari around a closed cloud AI API.

But that would have worked against the problem I was trying to solve.
A product whose purpose is to help someone disconnect from the internet shouldn't necessarily depend on an internet connection just to generate the experience.

Using an open-weight model with local inference makes a different design possible.

Local AI changes the relationship between the model and the user.
Instead of:

User
↓
Internet
↓
Cloud AI
↓
Response

Sidewalk Safari can work as:

User
↓
Local application
↓
Local Gemma
↓
Outdoor mission
↓
Phone away

That means developers can experiment with:

Different open-weight models
Different prompts
Different validation rules
Different age groups
Different outdoor activities
Fully local inference
Privacy-preserving experiences There's also no need to treat the AI provider as a permanent dependency.

That's what open innovation made possible for this project:
AI that can help someone disconnect from the internet instead of giving them another reason to stay connected to it.

What I Learned Building It

One thing this project taught me is that adding AI is often the easy part.
Designing boundaries around AI is harder.
During development, I encountered cases where generated output:

Didn't contain the required safety language
Exceeded the intended mission text limits
Failed time-budget validation

Instead of simply changing the prompt and hoping for better results, I moved important guarantees into application code.

That led to a more robust architecture:

LLM for generation → deterministic code for constraints.

I also intentionally kept features out of the first version.

No:

Social feed
Leaderboards
Accounts
Maps
Location tracking
Photo verification
Cloud database

The goal wasn't to build another giant platform.
The goal was to build a small tool that gets out of its own way.

Prize Categories

This project is submitted for:

Best Use of Gemma
Best Use of ElevenLabs

ElevenLabs was used to create the narration for the project demonstration video.

Gemma is at the core of Sidewalk Safari's mission-generation system, running locally through Ollama.

🌱 Final Thought

The best AI experience isn't always the one that keeps you on the screen.
Sometimes...
it's the one that gives you a reason to leave it.
Sidewalk Safari

The AI creates the adventure. You go live it. 🌿

StudyForge - A Local AI Study Partner Built for a Friend

Sumeet Choudhary — Sun, 04 Oct 2026 19:23:53 +0000

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

What I Built

I built StudyForge, a local-first AI study partner for my friend Piyush, a Class 10 student preparing for his board exams.

The problem was simple: having notes does not always mean understanding them.

While studying, Piyush can have the textbook or class notes right in front of him and still get stuck on one particular concept. At that point, a general-purpose AI chatbot can give him an answer, but I wanted to build something more focused:

Start with his own notes, find the part that matters, and help him understand that specific concept.

That became StudyForge.

A student pastes their class notes and asks a focused question, such as:

“How do the light-dependent reactions help the Calvin cycle make sugar?”

StudyForge then:

Breaks the notes into passages.
Ranks the passages against the student's question using local keyword-based retrieval.
Selects up to five relevant passages.
Sends only those selected excerpts to a locally running AI model.
Generates a short explanation, an example, a quick-check question, and a sample answer.
Shows the source passages used to create the response.

If the question has no matching terms in the notes, StudyForge does not simply invent a study guide. It asks the student to rephrase the question using words that actually appear in their material.

The goal is not to replace studying.

It is to make the confusing part easier to understand.

Demo

StudyForgeDemo

Code

sumeet156 / StudyForge-Local-AI-Study-Partner

A private, local-first study partner that uses Gemma 3 and your class notes to explain confusing topics and generate practice questions.

StudyForge

StudyForge is a local-first AI study partner. Paste in class notes, name a topic that feels confusing, and get a short study guide with a plain-language explanation, an example, a quick-check question, a sample answer, and the note passages used to make the guide.

The project was built for the Hacktoberfest 2026 “Build for a Friend” theme: make a practical study aid that can help someone learn from their own class notes.

What it does

Accepts up to 30,000 characters of notes and a topic or question of up to 200 characters.
Splits the notes into passages and ranks them against the topic using local keyword scoring.
Selects up to five matching passages and sends those excerpts to a locally running Ollama model.
Asks the model to return a focused guide grounded in those excerpts.
Shows the explanation, example, quick check, sample answer, and source passages in the browser.

…

View on GitHub

The repository is open source and includes the React frontend, FastAPI backend, retrieval logic, Ollama integration, and backend tests.

How I Built It

The core of StudyForge is built around open-weight AI running locally.

The default model is Google's Gemma 3 4B, served locally through Ollama.

The architecture is intentionally small:

React + TypeScript + Vite
→ FastAPI backend
→ local passage retrieval
→ Ollama
→ Gemma 3 4B

The browser sends the student's notes and question to the local StudyForge API. Before the model sees anything, the backend splits the notes into passages and ranks them using keyword overlap with a TF-IDF-style scoring approach.

Only the highest-ranked passages are included in the model request.

The model is also instructed to use only those supplied excerpts and to say when the excerpts do not contain enough information rather than confidently filling the gap with outside knowledge.

The application then returns structured JSON containing:

a simple explanation
an example
a quick-check question
a sample answer

StudyForge also returns the actual source passages selected by the retrieval layer, rather than asking the model to invent citations.

There is no hosted AI endpoint in the application, no account system, and no database storing the student's notes. The notes remain in the page while the application is open, and the selected excerpts are sent to the locally running Ollama service.

After the required model and dependencies have been downloaded, generation can run without an internet connection.

Why Does Open Innovation Matter?

This project is probably the clearest example I've had of why open AI matters at the application level.

I could have connected StudyForge to a hosted closed AI API and had a working prototype quickly.

But for this particular problem, local inference changes what is possible.

A student is putting their own study material into the application. I did not want the core experience to depend on sending that material to a third-party AI service by default.

With an open-weight model running through Ollama, I can build the application around:

Privacy:
The AI inference can happen on the student's own computer instead of requiring a hosted AI endpoint.

Control:
I can change the model and experiment with different local models without redesigning the application.

Transparency:
The application can show the passages retrieved from the student's notes alongside the generated explanation.

Offline potential:
Once the model is downloaded, the core generation workflow does not require a continuous internet connection.

Most importantly, open innovation let me design the AI around the actual problem instead of designing the problem around an API.

StudyForge is intentionally small. But that is exactly why I wanted to build it this way: the open model is not just an interchangeable backend. Local inference is part of the product's purpose.

Prize Categories

Best Use of Gemma — StudyForge uses Google's open-weight Gemma 3 4B as its default local AI model through Ollama.

Final Thoughts

The best part of this project was not getting an AI model to generate text.

It was starting with one person.

I built StudyForge because my friend had a real problem: sometimes the notes are already there, but the concept still does not click.

That made the design decisions much easier.

I did not need a giant AI system.

I needed a focused study partner that could take his notes, find the relevant part, explain it simply, and show him where that explanation came from.

That is StudyForge.