DEV Community: Nitin Gangwal

LazyRack: A Clothes Shop That Fetches Itself (Gemma, Running Locally)

Nitin Gangwal — Sat, 24 Oct 2026 10:20:42 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Think about the last time you went clothes shopping.

You ask for a kurta in blue and the shopkeeper pulls down six. You want to see the other colour, so he pulls down four more. You try a few on, then ask for a size that turns out to be out of stock. Forty-five minutes later you leave with nothing, and he is standing in a pile of unfolded clothes.

Nobody did anything wrong. It is just a lot of manual work for everybody.

LazyRack takes most of that work away. The shopkeeper sticks a QR code on the counter. The customer scans it with their phone, sees only what is actually in stock, picks a size and colour, and taps Order. A screen in the godown (the storeroom) shows the new order, the assistant brings exactly that piece, and the customer can try it on right there.

The shopkeeper never unfolds a shirt that nobody wanted. The customer never asks for a size that doesn't exist. Both of them get to be a little lazier.

And the laziest part is the setup: the shopkeeper never types a catalogue. He photographs a garment and Gemma fills in the name, category and colour. He only adds the price and how many pieces he has in each size.

Demo

https://1drv.ms/v/c/136E95ECD6A003BB/IQC4cVNEnD-mRZWDqeOI_C-YAb8-WcLxg-VDFlnS-9v4glk?e=Hin8ZI

1. The shopkeeper uploads a photo, Gemma fills in the details

2. The customer scans the QR and sees only what is in stock

3. The godown sees the order the moment it is placed

4. Gemma running locally through Ollama

Code

{ https://github.com/NitinGangwal/LazyRack }

How I Built It

Gemma 3 (4B), an open-weight model, served locally through Ollama on my own laptop (16 GB RAM, nothing else needed).
Streamlit for the three screens: shopkeeper, customer and godown.
SQLite for the catalogue and orders, in a single file.
A QR code generated by the app that points to the shop's local address. The phone and the laptop only need to be on the same WiFi.

Gemma does two jobs. First, it reads a garment photo and returns the name, category (Men / Women / Kids) and colour as JSON:

resp = ollama.chat(
    model=VISION_MODEL,   # gemma3:4b by default
    messages=[{"role": "user", "content": DESCRIBE_PROMPT,
               "images": [_shrink(image_bytes)]}],
    format="json",
)

Second, it powers the customer's search. A customer can type something like "shaadi ke liye blue kurta", and Gemma reads the catalogue and returns the best matches. Hindi in Roman script works too. If the model is unavailable, the app falls back to a simple keyword search, so the shop never gets stuck.

Stock is reduced the moment an order is placed, so the last piece of a size can never be ordered twice.

I am a third-year student and still learning Python, and I built this with an AI coding assistant helping me write the code. I ran, tested and debugged everything myself on my own laptop.

Why Does Open Innovation Matter?

A small shop is exactly where a closed API is a bad fit.

The shop's data stays in the shop. Product photos, prices and stock live in a file on the shopkeeper's own laptop. Nothing is sent to someone else's server.
It costs nothing to run. There is no per-photo or per-search fee. A shopkeeper who adds 200 items pays the same as one who adds 2: nothing. With a paid vision API, the shop with the biggest catalogue would pay the most.
The AI doesn't need the internet. The model and the app run on the shop's own WiFi, so a dropped connection doesn't stop the shop.
I can swap the model with one line. If a shop has a stronger laptop, setting VISION_MODEL=gemma3:12b gives better results without changing any code. With a closed API, that choice isn't mine to make.

The Lazy Payoff

I haven't put this in a real shop yet, so I am not going to invent a "saves X hours a week" number. Here is what I actually measured:

I added more than 20 clothes across Men, Women and Kids, using photos of clothes at my home and professional product photos from the internet.
Gemma got every category, name and colour right, on both the messy home photos and the clean product photos.
The first photo took about 40 seconds because the model had to load into memory. Every photo after that took about 15 to 20 seconds. The shopkeeper can keep working while it runs, so cataloguing one item means taking a photo, then adding the price and stock.
The full flow worked end to end: scan the QR, pick a size, place the order, and the godown sees it.

One honest limitation: once, when I searched for "shirt under 500", a shirt priced at 600 also showed up. On the next attempt it was correct, and it stayed correct for the rest of my testing. The reason is that the model reasons over the catalogue in a prompt, it doesn't run a strict price filter. My next step is to read the price limit in plain code and use Gemma only for the fuzzy part (style, occasion, colour).

The same idea fits shoe stores, malls and even restaurants, anywhere people browse a physical catalogue and someone fetches things for them.

Prize Categories

Best Use of Gemma: Gemma 3 (4B) runs locally through Ollama and does the photo cataloguing and the customer search. Swapping in a larger Gemma is a one-line change.

KaamClear AI: Turning Messy Client Briefs into Clear Projects with Local Gemma AI

Nitin Gangwal — Wed, 14 Oct 2026 17:39:30 +0000

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

What I Built

Freelancers often receive client messages that sound simple at first but hide a lot of unanswered questions.

A client might say, "I need an e-commerce website in two weeks." But what does that include? How many products will be listed? Which payment gateway is required? What should the admin panel manage? Is the proposed budget realistic?

Missing these details can lead to misunderstandings, underquoting, and scope creep.

That's why I built Kaam Clear AI, a local-first AI assistant that turns confusing client messages into structured project briefs.

With KaamClear AI, a freelancer can paste a client's message and get:

A clear project summary
Requirements mentioned by the client
Important questions to ask before starting
Suggested deliverables
Project risks and assumptions
Preliminary effort and price estimates
Suggested milestones
A professional draft reply to the client

The application also lets users download the generated project brief.

Who would use it?

Independent freelancers, beginner developers, and small service businesses could use KaamClear AI to understand project requirements before agreeing to a scope, timeline, or price.

It is designed to be a practical starting point for client conversations, not a replacement for professional judgement.

Demo

Video demo:

https://1drv.ms/v/c/136E95ECD6A003BB/IQBgSXR2T6zwQqsOqpQVk4r7AUsDqXooHZjgwzSretI3sDU?e=f3gnm5

The demo shows a sample client request being analysed and converted into a structured project brief.

Code

GitHub repository: https://github.com/NitinGangwal/KaamClearAI

The repository includes the application source code, dependencies, licence, and setup instructions.

How I Built It

I built KaamClear AI using Python and Streamlit, with Ollama providing access to the locally running Gemma 3 4B model.

The basic workflow is:

The user enters a client's project request and an hourly rate.
Streamlit sends the request to the local Ollama API.
Gemma analyses the message and generates a structured response.
The application displays the project brief and offers a download.

The main technologies are:

Python for application logic
Streamlit for the user interface
Ollama for local model inference
Gemma 3 4B as the open-weight language model

I kept the first version focused on one useful workflow instead of trying to build a large freelancer management platform.

Why Does Open Innovation Matter?

Client conversations can contain confidential information about budgets, business plans, products, and upcoming projects.

By running Gemma locally through Ollama, KaamClear AI can process client messages on the user's own computer instead of sending the prompt to a hosted AI inference API through this application's normal workflow.

This offers several practical advantages:

More control over data: Client messages can remain on the local machine during inference, provided the user keeps the device and its software secure.

Lower recurring API costs: The app does not require a paid hosted-model API for its normal inference workflow. Local hardware, electricity, and setup still have costs.

More flexibility: Developers can experiment with other compatible models and modify the application without depending entirely on a single hosted AI provider.

For me, open innovation makes it possible to build a useful AI tool that people can run and experiment with on their own computers.

What I Learned

Building KaamClear AI helped me understand how a local language model can be integrated into a practical application using Python, Streamlit, and Ollama.

It also showed me that generating a detailed answer is only one part of building a useful AI product. Estimates need to be checked, missing requirements need to be surfaced clearly, and the final decision must remain with the user.

This is an early version, and I want to improve its pricing calculations, budget comparisons, and scope-reduction suggestions in future iterations.

Prize Categories

Best Use of Gemma

Final Thoughts

KaamClear AI started with a simple question: can a local AI model help freelancers turn vague client requests into clearer, more actionable projects?

This first version is my attempt to answer that question.

I would love to hear how you would improve it, especially if you work with freelance clients or build tools using open-weight AI.

devchallenge #hf26challenge

Touch Grass Quest: An AI Scavenger Hunt That Gets You Outside.

Nitin Gangwal — Sun, 11 Oct 2026 07:38:42 +0000

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

What I Built

Touch Grass Quest is an AI-powered outdoor scavenger hunt. You pick a place and a difficulty, and the app generates five photo quests. You then put the laptop down, go outside, and photograph what you find. An open-weight Gemma model checks each photo, tells you what it sees, adds a fun fact, and finally writes a short nature journal. The screen is only needed to start the hunt and to upload the photos.

Taking It Outside

I tested it in the garden in front of my house with my sister. We were out for around half an hour to forty minutes, and the laptop was only used when it was time to upload a photo. The rest of the time we just walked around and took pictures.

My five quests were:

Find a fallen green leaf under a tree.
Photograph something natural that is yellow or red.
Photograph a tree.
Capture sunlight coming down through the branches.
Photograph the eye of an animal.

The yellow and red flowers were the easiest. The animal's eye was the hardest: I spotted a bird sitting on a branch and photographed it there. it was hard because the bird was far away or kept moving.

The AI judged almost every photo correctly. My favourite moment was the fun fact for the fallen leaf photo. The leaves were lying on a stone, and the model said it looked like leaves resting on a bald man's head. I laughed, and my sister enjoyed the whole thing too. Honestly, the best part was not the app. It was the thirty minutes of walking around and looking closely at things we usually ignore.

Demo

How I Tested It

Besides the garden walk, I tested both AI engines on all three difficulty levels (Easy, Medium and Hard), with five quests each. That is about 30 photo checks in total. I did not notice any serious mistakes. This was an informal test and not a benchmark, so I cannot give an accuracy number. But this is far better than random tools.

How It Works

Interface: Streamlit
AI: Gemma 4 through the Gemini API, or Gemma 3 (4B) running locally through Ollama. You can switch between them in the sidebar.
The model returns structured JSON, both for the quests and for each photo check. The quest prompt tells the model to keep quests safe: no trespassing, no touching wild animals, no picking plants.

Why Open Innovation Matters Here

Privacy: with the local engine, photos taken outdoors, including photos with family, stay on the laptop.
Cost: the local engine needs no API key and costs nothing to run.
Flexibility: changing the model is a one-line change in the code.
My comparison: because the open innovation helps to make a new thing that builds actually something great new and better then others.

What's Next

A phone-friendly version that works offline, quests tuned to the season and local plants, and a group mode for friends and run clubs.

Code

https://github.com/NitinGangwal/touchgrass-quest

Smart Expense Tracker: A Private, Local AI Finance Assistant for My Friend.

Nitin Gangwal — Sun, 04 Oct 2026 13:55:16 +0000

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

What I Built

I built Smart Expense Tracker, a finance assistant for my friend "Denim Sharma". Instead of filling in forms, you simply type something like "tea 20, bus 100, lunch 120". A local AI model works out the items, amounts and categories, then the app shows spending analytics and gives personalised saving tips.

Who It's For

Denim Sharma is my friend. they were Live at Home Alone. who spends on many small things during the month and rarely knows where the money went. I wanted something effortless to use that does not require handing financial data to a third party.

Demo

How It Works

Interface: Streamlit, with custom styling
AI: Gemma 3 (4B), an open-weight model, running locally through Ollama
Storage: a simple CSV file on the user's own machine
The model converts free text into structured JSON expenses, and later writes a summary with saving tips from the category totals.

Why Open Source AI Matters Here

Privacy: financial data never leaves the laptop. There is no server and no account.
Zero cost: no API fees, which matters for a student.
Works offline: it runs on an ordinary 16 GB laptop with no dedicated GPU.
Flexible: switching to a different model takes a one-line change.

What My Friend Said

Denim Sharma is my best friend. She lives away from home, and like most students she spends on many small things during the month but rarely knows where the money went. I wanted something effortless to use that does not require handing financial data to a third party.

What's Next

Budget limits and alerts, monthly reports, and voice-note input.

Code

https://github.com/NitinGangwal/Smart-finance-Expense-tracker

hellooooo

Nitin Gangwal — Sat, 03 Oct 2026 17:37:53 +0000

Hiiiii....

Nitin Gangwal — Thu, 01 Oct 2026 19:58:40 +0000