DEV Community: Tanishq Gupta

Mail Sloth: Photograph Your Paper Mail, Get Verdicts and Calendar Reminders, Fully Offline

Tanishq Gupta — Thu, 22 Oct 2026 03:43:13 +0000

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

What I Built

Mail Sloth turns a pile of paper mail into a short list of things to do, each with a calendar reminder, without you reading any of it.

Nobody reads paper mail properly. Bills, bank letters, school circulars, society notices, and government letters pile up on a shelf, and the one with a due date gets missed. Mail Sloth is built for the laziest possible workflow:

Take one photo of each letter, bill, or notice. A pile takes about a minute.
Drop the photos into the app and go do something else.
Come back to a one-page summary and a calendar file.

For every item, it gives you:

Who it's from and what it's about, in one line
A verdict: Pay, Reply, Sign, Keep, or Ignore
The key facts: amount due, due date, reference number, and what you actually have to do
A calendar reminder for anything with a deadline, exported as a standard .ics file that opens in any calendar app, with a reminder a week before and a day before

You glance at a review table, fix anything flagged, and export. Junk mail gets a clear "Ignore" so you can throw it away without guilt.

Who gets to be lazier: anyone who dreads their mail pile, such as busy parents buried in school circulars, people managing a home or a parent's paperwork, and anyone who has paid a late fee for a bill they never opened.

How I Built It

Reading the letters: an open-weight model, Gemma, running locally through [Ollama / your runtime]. [Choose what you really built: the vision model reads the photo directly, or OCR with Tesseract extracts the text first and the model reads that.] It extracts the sender, summary, amount, due date, reference number, and required action as structured JSON.
Dates and amounts are handled by plain code, not the model. The model only reads what the letter says. Normal code parses and validates the dates, checks that a due date is plausible, and generates the calendar entries. This keeps reminders trustworthy, because a language model should never be the thing deciding when your bill is due.
Honest uncertainty: if the photo is blurry, a date is ambiguous (for example 03/04), or the model isn't confident, the item is flagged in the review table instead of silently guessed.
Verdicts: a small, editable rule set maps the extracted fields to Pay, Reply, Sign, Keep, or Ignore, and you can adjust the rules to your own life.
Calendar export: the .ics file is generated directly in code with standard reminders, so it works with any calendar app and needs no account or integration.
Batch processing: photos are processed one after another in the background. It is not fast, and it does not need to be, because you are not waiting for it.
Interface: [describe what you built: for example a local web app with drag-and-drop photo upload and an editable review table].

Why Does Open Innovation Matter?

Paper mail is about the most private data you have. It holds your home address, bank and medical details, tax and government references, and your children's school information. Uploading photos of all of that to a cloud API is a bad trade for the convenience. Because the model runs on your own machine, none of it leaves it.
It costs nothing per letter. A pile of mail is dozens of photos every month, forever. With a paid vision API, a boring household task would carry a running bill. With a local model, you set it up once and never pay again.
It works offline. There is no account, no login, and no connection needed.
You control how it behaves. Verdict rules, reminder timing, and the output format are all editable, and the model can be swapped for a better or smaller one without waiting on a provider. If the model gets a layout wrong, I can fix the prompt or the rules myself.
Slow is fine. A local model on an ordinary laptop is not as fast as a hosted API, but this is a task you hand off and walk away from, so speed hardly matters.

WhatsApp Order Ledger: Turn a Messy Order Chat into a Clean Sheet, Offline, with Gemma

Tanishq Gupta — Mon, 12 Oct 2026 21:37:47 +0000

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

What I Built

WhatsApp Order Ledger turns a messy order chat into a clean, usable sheet.

Plenty of small businesses run on WhatsApp: home bakers, tiffin and meal services, boutique and handmade sellers. Customers send orders as casual text, half-sentences, edits ("make that 3, not 2"), mixed-language messages, and voice notes. The seller then spends an hour every evening scrolling through it all, copying orders into a notebook or spreadsheet, and working out who owes what.

You export the chat from WhatsApp, drop the file into the app, and it produces:

A clean order sheet: customer, items, quantities, notes, delivery date
A delivery list, grouped by date and area, ready to print
Daily totals: how many of each item to make or pack
A payment tracker: bills per customer and who hasn't paid yet
Voice notes, transcribed and read like any other message

The seller sets up their menu and prices once in a simple list, including the nicknames customers actually use for items and the way their customers actually write. After that, every day's chat becomes a sheet in minutes.

Who would pay for it: a solo home baker, caterer, or small seller who takes 10 to 50 orders a day over WhatsApp. It replaces the daily hour of copying and tallying, and it catches mistakes that cost real money, like a missed order or a forgotten payment. It's priced as a small monthly fee, which is a tiny cost against an hour saved every day. [Add the price you would actually charge.]

How I Built It

Language model: Gemma, an open-weight model, running locally through [Ollama / your runtime]. It reads each message in context and extracts items, quantities, corrections, delivery dates, and payment notes as structured JSON.
Voice notes: an open-source Whisper model transcribes WhatsApp voice notes locally, so they flow into the same pipeline as text.
Chat parsing: the standard WhatsApp "Export chat" text file is parsed into messages with timestamps and senders. The app never connects to WhatsApp itself, so there is no risk to the seller's account and nothing to authorize.
Menu and slang config: a plain editable file holds the seller's items, prices, and the nicknames customers use for them. The model is prompted with this list, so it learns the shop's own vocabulary without any retraining.
Structured output and validation: the model's JSON output is validated against the menu. If an item or quantity looks wrong or ambiguous, it is flagged for the seller to check instead of silently guessed.
Totals are computed in plain code, not by the model. The model only reads messages, and normal code does the arithmetic. This keeps bills and totals exact.
Outputs: a printable delivery list and a CSV export that opens in any spreadsheet app.
Interface: [describe: a simple local web app, with a drag-and-drop file upload and an editable review table].

Why Does Open Innovation Matter?

The customers' data stays on the seller's laptop. Order chats are full of customer names, phone numbers, and home addresses. Sending that to a third-party API is a real privacy problem for a small business that depends on its customers' trust. Running an open-weight model locally means none of it leaves the machine.
The business actually works at this price. Each day's chat can be thousands of messages, plus voice notes. With a paid API, the cost per seller grows with every message. With a local model, the marginal cost is zero, so a small monthly fee can be real profit.
It handles how people actually write. Order chats mix languages, abbreviations, and local item names. Because the model and the prompts are open and under my control, I can tune them to the seller's own menu and vocabulary, add a new language, or swap in a better model later, without waiting on a provider.
No lock-in. If a provider changes prices or terms, a seller on a closed API is stuck. Here, the model is a file on their machine, and the pieces can be swapped.
It works offline. The tool does not depend on a stable connection, which matters for small sellers who often work from home on unreliable internet.

Acoustic Atlas: An Offline Open-Weight Model That Finds the Best-Sounding Places to Touch Grass

Tanishq Gupta — Thu, 08 Oct 2026 15:32:16 +0000

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

What I Built

Acoustic Atlas is a listening companion that finds the places near you that sound alive. Most outdoor apps tell you where to go. This one measures what a place actually sounds like.

You tap "Listen" at a spot, put your phone in your pocket, and walk or sit for a few minutes. An open-weight audio model classifies the soundscape on-device, separating what it hears into nature sound (birdsong, wind, water, insects, rustling leaves) and human noise (traffic, engines, horns, construction, crowds). When the timer ends, your phone vibrates and gives you a Nature Score for that spot and time of day.

Over a few walks it builds your personal atlas:

Your best-sounding spots, ranked
The best time of day for each spot (for example, "dawn is 3x livelier than evening")
A "quietest, most alive place near me right now" suggestion

The screen is the shortest part of the experience. The app is only used to start and stop a listen, and all the real time is spent outside, listening.

It's for walkers, runners, birders, people who live in noisy cities, and anyone who wants a reason to sit somewhere green and pay attention.

Code

Shivgg1234 / devtopost

🌿 Acoustic Atlas

Acoustic Atlas is a static, offline-first Progressive Web App (PWA) that uses an on-device TensorFlow.js Machine Learning model (YAMNet) to score how "alive" a natural location sounds, building a personal atlas of the best-sounding spots and times.

🎯 Core Philosophy & Privacy Model

The screen is designed to be the shortest part of the experience:

Tap Start Listening (pick 3, 5, or 10 minutes).
Put the phone in your pocket and listen outdoors.
Get a Nature Score (0–100), top sound breakdown, birdsong share, and optimal time-of-day recommendation.

Zero Audio Uploads & 100% On-Device

In-Memory Streaming: Microphone audio is resampled to 16 kHz mono in RAM, sliced into ~0.96s windows (15,360 samples), evaluated by YAMNet, and immediately discarded.
No Audio Saved or Uploaded: Raw audio is NEVER stored on disk or transmitted over any network. Only numeric score aggregates are stored locally.
…

View on GitHub

How I Built It

Model: YAMNet, Google's open-weight audio event classifier (Apache 2.0), trained on AudioSet and able to recognize 521 sound classes. It runs fully in the browser through TensorFlow.js, with the model files bundled locally instead of fetched from a CDN.
Scoring: Each second of audio is classified, and the class probabilities are grouped into "nature" and "human noise" buckets. The Nature Score is the share of the soundscape that is nature. The class grouping is a plain config file, so anyone can change what counts as nature for their region.
App: A static Progressive Web App. A service worker caches the app and the model, so after the first load it works in airplane mode on a trail.
Storage: Spots, scores, time of day, and GPS coordinates are saved in IndexedDB on the device. There is no backend and no account.
Screen-minimal design: After you tap Listen, the screen drops to a dark minimal card with a countdown. The phone vibrates when done, and you only look at the screen again for the result.
Audio is never saved: Audio is processed in memory in short windows and thrown away. Only the numeric scores are stored.

Why Does Open Innovation Matter?

Privacy is the product. An ambient soundscape recording can capture conversations, your family, and your location habits. With an open-weight model running on-device, the audio never leaves your phone and only anonymous scores are kept. A cloud audio API would need the recordings uploaded, which is a bad fit for something you carry everywhere.
It works where the signal doesn't. The best-sounding places (parks, hills, riverbanks) often have the worst reception. Local inference makes zero connectivity the normal case, not an edge case.
It's free to run. There are no per-minute audio API costs, so you can listen for hours without paying anything.
You can change what "nature" means. A forest in Canada and a riverside in Southeast Asia sound very different. Because the model and the class mapping are open, anyone can adjust the scoring for their region, or swap in a bird-specific model like BirdNET or a fine-tuned one.
It's auditable. Anyone can read exactly how a score is computed. There is no black-box "wellness score."