DEV Community: Nischay Shukla

Week 3 Dev Challenge

Nischay Shukla — Sat, 24 Oct 2026 06:35:11 +0000

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

What I Built

Sloth Sorter is a file tidier that runs entirely on my own machine. Point it at a messy folder (my Downloads folder was a landfill of scan0012.pdf, final_FINAL_v3.docx and IMG_4471.heic). It reads the start of each file, asks a local open-weight model for a category and a clean filename, and files it away.

scan0012.pdf becomes Finance/electricity-bill-2026-03.pdf.

It's safe to be lazy with. It previews by default and only moves files when I pass --apply. Every move is logged, so --undo puts everything back.

Anyone who has a folder they keep promising to sort "this weekend" gets to be a little lazier.

How I Built It

-Model: an open-weight model, Qwen 2.5 3B by default.
-Inference: Ollama, running locally on localhost:11434. There's no API key and no account.
-Glue: plain Python with no pip dependencies. For PDFs it uses pdftotext if it's installed, and falls back to the filename if not.
-Structured output: Ollama's JSON mode makes the model return {"category": ..., "name": ...}. I check the category against an allowed list and clean the filename before touching any file.
-Safety: dry run by default, collision-safe renames (name-1.pdf), and a JSON log for --undo.
-Graceful degradation: if the model isn't running or returns bad JSON, it sorts by file extension instead of crashing. I tested apply and undo in that offline-fallback mode.

Why Does Open Innovation Matter?

-Privacy:A Downloads folder holds tax forms, payslips, medical reports and ID scans. Sorting them with a closed API means uploading all of that to someone else's server. Here the file contents never leave my machine.
-Works offline:There's no dependency on a connection or a vendor being up, and a model I downloaded won't change under me.
-Free after setup:Sorting thousands of files costs only a little electricity, so I can run it on a schedule without watching a bill.
-Right-sized and swappable:Filing is a small task, and a 3B model on a laptop handles it. Because the weights are open, --model lets me try Llama, Gemma or Phi and compare them on my own files.

The trade-off:a small model sometimes picks a vaguer category than a frontier model would. That's why the preview and undo exist. For files this personal, I'll take that trade.

Prize Categories

1.Use of Gemma
2.Use of Entire.

Week 2 Dev Challenge

Nischay Shukla — Fri, 16 Oct 2026 14:19:51 +0000

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

What I Built

Receipt Sorter is a local-first tool that turns a messy folder of receipts and invoices into a clean, tax-ready archive. It’s for freelancers and solo consultants.

Point it at a folder of photos and PDFs. A vision model running on your own laptop reads each document and extracts the vendor, date, total, currency, tax and expense category. Each file is then renamed (2026-03-14_Notion-Labs_16.00.png), filed under year/category/, and logged in a ledger.csv you can hand to an accountant. Anything with a missing date or total goes to a needs-review/ folder instead of being guessed at.

Who would pay: a freelancer whose receipts are scattered across Downloads, WhatsApp and email attachments, and who loses a weekend to retyping them at tax time. Their invoices also show client names and rates, so many of them won’t upload those to a cloud service. I’d sell it at $29 one-time, or $9 a year for updated category packs (GST, VAT, US Schedule C).

How I Built It

Open-weight model: Qwen2.5-VL 7B by default (gemma3:12b or any Ollama vision model works with --model).
1.Local inference: Ollama, called over its local HTTP API.
2.Structured output: I pass a JSON schema to Ollama’s format parameter, so the model can only return valid, typed fields, with the category restricted to a fixed list. Temperature is 0, so the same receipt gives the same result.
3.Routing: images go straight to the vision model. Text PDFs are extracted with pdftotext and sent as text, which is faster and more accurate than rasterizing them.
4.Safe failure: a missing date or a zero total sends the file to needs-review/ rather than filing a wrong guess under a tax year.

Why Does Open Innovation Matter?

1.Privacy is the product. Receipts reveal clients, rates and travel. With a local open-weight model, nothing leaves the machine, which a cloud API can’t promise.
2.The economics only work with local inference. A closed vision API charges per image forever. That would force me into a subscription, and the freelancer would pay for every receipt they scan. Running on the customer’s own hardware lets me sell a one-time license, and my cost per receipt is zero.
3.No lock-in. If a better small vision model comes out, users change one flag. A hosted model that is deprecated or repriced can break a product overnight.
4.Room to specialize. General APIs handle locale-specific paperwork poorly, such as Indian GST invoices, DD/MM dates and mixed-language line items. Open weights can be fine-tuned on exactly that niche, which is where a small product can beat a general one.

Prize Categories

Best Use of Gemma: Receipt Sorter uses Gemma, Google's open-weight multimodal model, running locally through Ollama to read receipt photos and invoices. Running it on the user's own laptop keeps client data private and means there is no per-receipt API cost.

Week1 Dev Challenge

Nischay Shukla — Sun, 11 Oct 2026 14:08:56 +0000

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

What I Built

Trailcard turns a voice memo from a walk into a printable one-page field card. You record birdsong on your phone and put it in your pocket. Afterwards, one command gives you:

a checklist of the birds identified by their calls
a short journal entry about the walk
a “listening challenge” for next time

You print it, put it in your pocket, and go back outside. The screen is only used for about a minute. It’s for beginner birders, hikers, and anyone who wants to notice more on a walk without staring at a phone while doing it.

Code

Nischay1909 / trailcard

Trailcard

Record birds on a walk, print a field card afterwards. Bird calls are identified offline with BirdNET (open source), and a local open-weight model (via Ollama) writes the journal entry.

Run locally: pip install birdnet-analyzer, ollama pull llama3.2, then python trailcard.py ./recordings --lat 26.85 --lon 80.95

Deploy: push to GitHub, then Render > New > Blueprint (uses render.yaml).

View on GitHub

How I Built It

BirdNET-Analyzer (open source) identifies bird calls from audio.

I pass the latitude, longitude and current week so it only considers birds that are plausible for that place and season.

An open-weight model served by Ollama (Llama 3.2 by default) writes the journal entry. Its prompt contains only the species BirdNET detected and tells it not to add other birds or facts.
Everything runs locally. After the one-time model downloads, no internet connection or API key is needed, which suits trails with no signal.
If Ollama isn’t running, the tool still produces a card with a template journal entry.
The whole tool is a single readable Python file, trailcard.py. The repo also includes an optional web wrapper and Render Blueprint config that I haven’t deployed.

Why Does Open Innovation Matter?

Offline use. A closed API can’t identify a bird on a ridge with no signal. Open models can run on your own laptop.
Privacy. Your recordings and your location never need to leave your machine.
Contribution. It’s one small file, so people can add regions, other taxa such as frogs and insects, or other languages.

Weekend 1 Launch Project

Nischay Shukla — Sun, 04 Oct 2026 19:50:15 +0000

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

What I Built

I built PDF → Quiz, a small web app that turns lecture PDFs into multiple-choice practice quizzes. I made it for my college friend. They upload a lecture PDF, pick how many questions they want, and the app writes a quiz from the material. Each question comes with four options, a correct answer, and a short explanation. At the end it shows a score. He had piles of lecture slides and no good way to check whether any of it had stuck. Rereading feels productive but doesn't show what you actually know. Practice questions do, but writing them by hand takes as long as studying. This tool automates that step.

How I Built It

The core of the project is Ollama, which serves an open-weight language model ([confirm: Llama 3.2 3B locally, Llama 3.2 1B on Render]). The app sends text to the model's local HTTP API and gets quiz questions back. Nothing in the pipeline depends on a closed API.

Extract text. The backend reads the uploaded PDF with pypdf and collapses it into clean text.
Chunk and spread. The text is split into roughly 2,500-character chunks. The app picks chunks evenly across the whole lecture, so the questions cover the entire document, not just the first few pages.
Generate one question per chunk. Each chunk goes to Ollama's /api/chat endpoint with a system prompt asking for exactly one question that tests understanding rather than trivia. I used Ollama's JSON output mode, so the reply is structured as a question, four options, an answer index and an explanation.
Validate. The backend checks that there are exactly four options and a valid answer index. Questions that fail are skipped instead of showing broken output.
Stream to the browser. The page requests questions one at a time, so they appear as they are written. This also keeps every request short, which matters on hosted platforms with request time limits.

Why Does Open Innovation Matter?

Lecture material, personal notes and study habits are things a student may not want to send to someone else's server. Because the model runs through Ollama on my own machine, the PDFs never leave my friend's computer. There is no account, no upload and no third party holding their coursework.

Using an open-weight model also made these things possible:

It costs nothing to run. There are no per-token charges, which matters to a college student generating quizzes from dozens of PDFs. With a paid API, every extra lecture would add to the bill.
It works with no internet. After the one-time model download, it runs in a library, on a commute or on bad campus Wi-Fi [confirm this matches your testing].
I can swap and tune the model. If a different open model writes better questions for a subject, I change one environment variable (MODEL) instead of rewriting the app around a new vendor's API. I can also change the prompt and behavior freely, because nothing sits behind a closed endpoint.
I could choose where it runs. The same code runs privately on a laptop or as a public demo on Render. A closed API would have forced a third-party server in both cases.

An honest trade-off: the Render deployment is a public demo, so on that version the PDFs are processed on a cloud server. It also uses a smaller model ([1B]) than my laptop does ([3B]), so question quality is lower. The private, free, offline experience is the local one.

My Agent Session

Prize Categories

Render: I deployed the project on Render using a single render.yaml Blueprint. It defines a private service that runs Ollama from a Dockerfile with a persistent disk, so the model downloads once and survives restarts. It also defines a public web service that reaches Ollama over Render's private network. Both services deploy from one GitHub repo with one click.