DEV Community: Ch Yasaswini

SalesWhy: I Built an AI That Explains Sales Drops — Then a Generic LLM Beat My Own Pipeline

Ch Yasaswini — Tue, 13 Oct 2026 12:01:34 +0000

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

What I Built

SalesWhy tells a small shop owner why their sales dropped — in plain English (or Telugu), backed by actual numbers, in about 20 seconds.

Picture the person this is for: she runs a little Etsy shop selling candles and ceramics on the side. Tuesday's sales were fine. Thursday they fell off a cliff. She has no idea why, and no time to become a data analyst to find out. Was it the weather? A competitor? Did she mess something up? Right now her only options are "stare at a spreadsheet" or "guess."

SalesWhy takes her orders CSV — whatever export her platform gives her, no reformatting required — and gives her three things:

A chart of what sales actually did vs. what they should have done, with the rough weeks shaded and labeled.
A ranked list of likely causes (price went up, shipping got more expensive, something went out of stock — or, honestly, "not sure, might be something outside this file").
A three-sentence explanation she can actually read, plus a shareable "ledger slip" PNG she can screenshot to WhatsApp a supplier or business partner.

Who'd pay for this? Anyone running a one-person storefront who doesn't have, and can't afford, a data analyst — which is most of them. $5-10/month to stop guessing about your own numbers is an easy sell.

Demo

Try it live: [https://saleswhy.onrender.com]

Or run it in 3 commands (needs Ollama for local explanations):

git clone https://github.com/Yasaswini-ch/SalesWhy.git && cd SalesWhy
pip install -r requirements.txt && ollama pull gemma3:4b
python app.py

Open http://127.0.0.1:8000 and click "Try sample shop" — no upload needed to see it work end to end.

Code

Yasaswini-ch / SalesWhy

SalesWhy

Why did your sales drop? SalesWhy tells you — in plain words, backed by numbers.

Upload an orders CSV from Shopify, Etsy, or any small shop export. SalesWhy predicts what sales should have been, finds the days where they fell short (or jumped), names the most likely cause, and explains it in a short, plain-language note — in English or Telugu.

Built for the DEV Hacktoberfest Open-Source AI Challenge — Week 2 ("Side Hustle").

Live demo: saleswhy.onrender.com — click "Try sample shop," no upload needed.

What it does

Upload an orders CSV (or click "Try sample shop" to see it work instantly).
SalesWhy auto-maps your columns (date, amount, quantity, product) and lets you confirm or fix the guess.
It predicts expected daily revenue with TabPFN, trained on your own earlier data.
It flags windows where actual revenue was well above or below expected, and deterministically ranks price, shipping…

View on GitHub

How I Built It

The whole thing rests on one rule I didn't let myself break: a language model is never allowed to decide the cause of a sales drop. It only phrases a decision that's already been made by plain arithmetic. Here's the pipeline:

TabPFN (local, open-weight) predicts what daily revenue should have been, trained on a seller's own earlier days — no hyperparameter tuning, which is TabPFN's whole premise and exactly what makes it workable for a tool that has to retrain itself on a stranger's CSV in a few seconds.
A small deterministic function flags windows where actual revenue falls well below (or jumps well above) that prediction for 2+ consecutive days.
For each flagged window, I compare price, shipping cost, and active-product-count inside the window against a 14-day baseline before it, and rank which one moved the most. If nothing moved enough, it says "not sure" — out loud, not silently.
Only then does Gemma 3 (4B), running locally through Ollama, get involved — and only to turn {"cause": "stockout", "change_pct": 43.5} into three readable sentences, in English or Telugu.

Everything else — the CSV column auto-mapper (so it works on Shopify, Etsy, or a raw transaction export without asking the user to reformat anything), the what-if estimator (re-predicts with a counterfactual price to say "if you hadn't raised the price, sales would've been about X"), the product drill-down, and the ledger-slip PNG export — is plain Python and a FastAPI endpoint. No agent framework, because this didn't need one.

I evaluated it properly, not just vibes: injected 30 synthetic drops with known causes (price hike, stockout, freight spike) into real seller data from the Olist e-commerce dataset, then checked whether SalesWhy named the right one. Full table and discussion in results/eval.md.

Why Does Open Innovation Matter?

Three concrete things open models bought me that a closed API wouldn't have, plus one honest surprise.

Cost that actually makes the business work. A shop owner checking "why did my sales drop" a few times a week, forever, needs a per-query cost near zero or the product doesn't exist. Local Gemma costs nothing beyond the laptop it's already running on.

Privacy that's actually true, not just claimed. TabPFN and Gemma both run on the same machine the CSV was uploaded to. The footer of the app states exactly what ran where, read from the live config — not a marketing claim, a fact I can check.

And here's the part I didn't expect going in. To build a fair baseline, I gave a generic LLM (Gemini, via API — the one closed piece in this whole evaluation, used only as a comparison point) the exact same raw data and asked it one plain, unstructured question: "why did sales drop?" I expected my engineered, deterministic pipeline to win easily. It didn't — the raw LLM call scored 53.3% accuracy against my pipeline's 36.7%, on the same 30 synthetic drops. (This post on why LLMs struggle with tabular prediction is about the opposite claim, and reading it after my own result made me take the surprise more seriously, not less.)

It wasn't all good news for the generic LLM, though — it does something SalesWhy's deterministic pipeline structurally can't: it sometimes gives a confidently wrong answer, blaming "orders fell" (true, but a symptom) instead of the price change that caused the orders to fall (the actual cause). SalesWhy can only ever name price, freight, stock, or say "not sure" — it can't invent a plausible-sounding non-answer. Whether 17 points of accuracy is worth that guardrail is a genuinely open question, and I'd rather report that honestly than quietly bury the number that didn't flatter my own design. (Full breakdown, including a grading bug I caught in myself mid-evaluation — my keyword classifier was marking the LLM wrong because it said "zero active products" instead of my expected word "stock" — is in results/eval.md.)

That's the open-innovation case in one sentence: because every piece of this ran somewhere I could inspect it, I could catch my own tool being outperformed, understand exactly why, and write about it instead of hiding it behind an API I couldn't see inside.

My Agent Session

The full build log — including every bug, every wrong turn, and the exact moment the generic-LLM baseline beat my own pipeline — is in DEVLOG.md in the repo. (Agent session embed/link to be added — see DevRelay session saving.)

My First User

Not an external customer yet — this was built solo against a tight deadline. But the closest thing to a first user so far: I put the running app in front of myself fresh, without pre-explaining the UI, and used it like a stranger would. First reaction: "the UI looks too boring." That's genuinely useful feedback, and it's the reason the finished app has the stamp-mark header, color-coded ledger rows, and a custom-styled chart instead of the plain bordered boxes I shipped first. The next real test is putting it in front of an actual Etsy or Shopify seller — that's the honest next step, not a fabricated success story.

Prize Categories

Best Use of TabPFN
Best Use of Gemma

Nimbus Choir: Point Your Phone at the Sky, Hear It Sing

Ch Yasaswini — Sat, 10 Oct 2026 12:51:49 +0000

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

What I Built

Nimbus Choir points your phone's camera at the sky and turns it into a soft, generative ambient piece -- entirely offline, no account, no cloud service watching what's above you.

Every cloud the camera tracks becomes one voice in the choir:

Cloud type picks the timbre (cirrus, cumulus, stratus, cumulonimbus each hum differently)
Size picks volume
Height picks pitch
Left-right drift pans it across the stereo field
A short-term weather forecast tunes how consonant or unsettled the whole piece feels

The intended use is exactly what the theme asks for: point it at the sky, tap once, then put the phone down. The screen is the shortest part -- after that it's just you, outside, listening to clouds drift while an ambient pad drifts with them.

There's also an optional Earth mode: tap the globe icon, watch a few cloud shapes part to reveal a real spinning globe (actual coastlines, actual rotation -- written from scratch, no mapping library), tap a glowing region, and the same sound engine sonifies live NASA satellite imagery instead of your camera. It's clearly marked "Online" and falls back to the camera automatically if the network's unreachable.

Demo

Live: web-pi-wine-28.vercel.app -- the real frontend (camera pipeline, tracking, sound engine) running live. This is a static deploy of just /web, so the backend-dependent bits (tension forecast, sky narrator, Earth mode's satellite proxy) aren't reachable from it and gracefully fall back exactly as they're designed to offline -- the core camera-to-sound experience is fully live and functional. For the complete experience including those, clone the repo and run the FastAPI server alongside it (instructions below).

Code

github.com/Yasaswini-ch/Nimbus-Choir

How I Built It

/web -- vanilla JS + Vite. A real-time sky segmentation pipeline (sky masking, connected-component cloud detection, an IoU tracker that handles merges/splits as clouds drift and overlap) feeds a cloud-type classifier that runs entirely in-browser via onnxruntime-web -- a frozen, open-weight DINOv2 backbone with a small trained head, quantized to ONNX. Zero network calls for the core experience. The sound engine is hand-built Web Audio: detuned oscillator pads through a lowpass + slow tremolo, plus physically-modeled partial-based chimes.

/training -- the classifier pipeline. Public CCSN cloud dataset → dedupe/augment → DINOv2 (open-weight, frozen) + trainable head, distilled with optional Tinker teacher soft-labels for extra accuracy, but the version actually shipped here trained on ground truth only -- $0 spent, no closed model touched at all. (CCSN has no clear-sky class, so I generated 60 synthetic gradient-sky images as a documented stand-in for that one label.)

/forecast -- an open-weight TabPFN model (a tabular foundation model) predicts the "tension" value from cloud cover + pressure trend, trained on public Open-Meteo reanalysis data across ~40 global locations. Held-out-by-location accuracy (tested on 6 cities -- Buenos Aires, Cairo, Mumbai, São Paulo, Shanghai, Sydney -- the model never saw during training): 77.5%.

/server -- FastAPI. Serves the tension model, an optional sky narrator (local Gemma 3 via Ollama writes a caption, Piper -- open-weight, fully offline TTS -- speaks it), and Earth mode's NASA GIBS satellite tile proxy (confirmed live against GOES-East, GOES-West, and Himawari-8, no API key needed).

Why Does Open Innovation Matter?

This is the part I actually want to highlight, because it wasn't just philosophical -- it changed a real decision mid-build.

The narrator originally used ElevenLabs for voice. It worked, but it meant: no network → no voice, an API key to manage, and a per-character cost for something meant to run in a field with no signal. I swapped it for Piper, an open-weight local TTS. Same user-facing feature, zero network calls, zero marginal cost, and it keeps working exactly where the app is meant to be used -- outside, possibly with no bars.

That one swap is the whole argument in miniature:

Runs with no internet. The main camera mode -- segmentation, tracking, classification, the entire sound engine -- never makes a network call after first load.
Nothing about your sky leaves your device. No photos, no GPS (even the forecast lookup coarse-rounds coordinates to 0.5° before it ever leaves the client).
Costs nothing to run, at any scale. The open-weight classifier, TabPFN forecaster, and Piper narrator all run locally after their one-time download. No per-request bill waiting at the end of a demo day.
The one online feature is opt-in and honest about it. Earth mode needs the network (real satellite data has to come from somewhere), so it's the only part with an "Online" badge, and it's the only part that can't run in a field with no signal -- which is exactly why it's optional, not the default.

Open-weight models didn't just make this cheaper to build. They're the reason the app can keep its core promise -- point it at the actual sky, anywhere, with nothing phoning home -- instead of quietly becoming "offline, except for the parts that aren't."

Prize Categories

Best Use of TabPFN -- the /forecast tension model, trained and honestly validated as described above.
Best Use of Gemma -- the sky narrator's captions, generated by a local Gemma 3 model via Ollama.

CrackIt: Big Equations, Broken into Small Pieces (Built for My Brother)

Ch Yasaswini — Sat, 03 Oct 2026 08:42:04 +0000

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

💡 What I Built

My younger brother is a diploma student in petrochemical engineering. Every evening, he sits with thick textbooks filled with dry, heavy equations like the Ergun Equation, Bernoulli's Principle, and Raoult's Law.

Like many engineering students, he gets bored and overwhelmed by abstract derivations. When you're trying to understand how a packed catalyst bed in an oil hydrotreater works, looking at this:

\frac{Δ P}{L} = \frac{150 μ ( 1 - ϵ ) ^{2} v _{s}}{ϵ ^{3} d _{p 2}} + \frac{1.75 ρ ( 1 - ϵ ) v _{s 2}}{ϵ ^{3} d _{p}}

...feels completely disconnected from real plant operations.

So for the Hacktoberfest "Build for a Friend" Weekend Challenge, I built CrackIt: an engineering equation interpreter designed like a friendly senior explaining over a cup of chai.

CrackIt breaks heavy formulas into small, practical pieces:

🎯 What It's For: One clear sentence connecting the formula to real plant equipment (distillation towers, hydrotreaters, heat exchangers).
🔤 Crack the Symbols: Every symbol in plain words with its engineering units, plus an Interactive Focus picker.
✏️ Worked Example: Calculations broken into 3 to 5 clean steps with round numbers.
🧪 Try It Live (Interactive Calculator): A live numeric playground where students tweak parameters (flow rates, particle size, void fraction) and watch outputs recalculate in real time.
💡 What Happens If...?: Real plant intuition, e.g. "Smaller catalyst particles create a substantially higher pressure drop due to the $d_{p 2}$ term in the denominator."
🎯 Practice Challenge & AI Feedback: Practice problems with an answer checker powered by Google's open-weight Gemma 3 4B.

🌐 Live Demo & Code

Live Application (on Render): https://crackit-ch8e.onrender.com/

Yasaswini-ch / CrackIt

Big equations, broken into small pieces.

⚗️ CrackIt

Big equations, broken into small pieces.

Built for my brother, a diploma student in petrochemical engineering who finds heavy maths boring CrackIt takes an engineering equation and breaks it into small, friendly parts, with a petrochemical plant example every time, and lets you play with the numbers live.

🌐 Live Demo & Deployment

Live on Render: https://crackit-ch8e.onrender.com/
Repository: https://github.com/Yasaswini-ch/CrackIt

What it does

Type an equation name (or pick a quick card, or upload a photo of your notes) and CrackIt shows:

The formula, rendered properly (Ergun's viscous and inertial terms are colour-labelled)
What it's for, with a real plant example
Crack the Symbols, a table of every symbol, its meaning and its unit, plus an Interactive Focus picker for any one symbol
Worked example, small round numbers, one step per line
Try it live, a calculator pre-filled with the worked-example values. Change a…

View on GitHub

📸 Screenshots & Walkthrough

1. The Equation Dashboard

Midnight Navy and Off-White interface with Inter and STIX Two Math typography.

Students can:

Type in any equation name (e.g. "Ergun equation", "Q = mCpΔT", or "Bernoulli").
Upload textbook photos to have the vision model identify the formula.
Click any of the 10 quick-start cards spanning fluid dynamics, heat transfer, kinetics, and thermodynamics.

2. The Learning Workspace

Semantic color highlights: viscous contribution in Soft Blue (#EAF3FF) vs. inertial contribution in Soft Violet (#F1ECFF).

3. Step-by-Step Breakdown, Symbols & Worked Example

Every variable cataloged with physical units, followed by sequential numeric walkthroughs.

🛠️ How I Built It

CrackIt is built around two principles: deterministic physical accuracy and open-weight AI guidance. The numbers always come from plain Python, and the AI only explains and checks.

┌─────────────────────────────────────────────────────────────────┐
│                      Browser UI: Gradio 6                       │
│      (Inter Typography + STIX Two Math + KaTeX Rendering)       │
└────────────────────────────────┬────────────────────────────────┘
                                 │
                ┌────────────────┴────────────────┐
                ▼                                 ▼
┌───────────────────────────────┐ ┌───────────────────────────────┐
│      Deterministic Core       │ │     Open-Weight AI Tutor      │
│    (Pure Python / Offline)    │ │    (Gemma 3 4B via Ollama)    │
├───────────────────────────────┤ ├───────────────────────────────┤
│ • 10 Petrochemical Formulas   │ │ • AI Practice Answer Checker  │
│ • Step-by-Step Walkthroughs   │ │ • Multimodal Vision Reader    │
│ • Real-time Live Calculator   │ │ • Cloud Fallback (Backboard)  │
└───────────────────────────────┘ └───────────────────────────────┘

1. The Open-Weight AI Core: Gemma 3 4B & Ollama

On local laptops, CrackIt runs fully offline via Ollama using Google's gemma3:4b:

Why open-weight AI? Students often study with limited bandwidth or in offline libraries. Gemma runs privately on consumer laptop hardware with zero API fees.
Multimodal equation recognition: Gemma's vision encoder reads textbook snapshots and identifies formulas directly.
Pedagogical tutor mode: Gemma checks student practice answers, explaining math or unit mistakes in at most two friendly sentences.

2. Live Cloud Deployment on Render

The application is deployed on Render as a Python web service using a render.yaml blueprint with automated port binding and dynamic environment handling.

3. Cloud Fallback & Prompt Evaluation via Backboard

So the live Render demo stays responsive for judges even without a local Ollama daemon, I integrated Backboard as a cloud inference gateway, evaluating prompts across open-weight models (google/gemma-2-9b-it).

4. Industrial Design System

Instead of generic AI gradients, CrackIt uses an engineering palette:

90% Baseline: Midnight Navy (#14263D), Deep Navy (#172B45), and Off-White (#F8FAFC).
Semantic Accents: Viscous laminar contribution in Engineering Blue (#2F80ED / #EAF3FF) and turbulent inertial contribution in Violet (#7C5CDB / #F1ECFF).
Typography: Inter for clean UI paired with STIX Two Math for proper mathematical typesetting.

🌍 Why Does Open Innovation Matter?

Engineering education shouldn't be locked behind expensive proprietary cloud subscriptions that track student data.

Open-weight models like Gemma show that a compact 4-billion-parameter model on a modest laptop can work as a personal chemical engineering tutor. When AI is open and runs locally:

Students with limited connectivity can still use AI study tools.
Plant engineers can run proprietary calculations without data leaving their laptops.
Learners are not dependent on closed API providers.

🤖 My Agent Session

CrackIt was built with the help of an autonomous AI pair-programmer. From resolving Windows Hyper-V port exclusion conflicts, to refactoring Gradio 6 lifecycle hooks, to implementing the deterministic calculation engine and custom CSS design tokens, the agent and I worked through it together. You can explore the full commit history in the GitHub Repository.

🏆 Prize Categories Entered

Overall Winner: Theme: Build for a Friend (built for my brother studying petrochemical engineering)
Featured Partner: Render: Deployed live on Render Web Services
Featured Partner: Gemma: Powered by Google's open-weight Gemma models (gemma3:4b locally, Gemma cloud via Backboard)
Partner Category: Backboard: Open-weight inference routing and prompt benchmarking
Partner Category: Entire: Agent-assisted pairing session and documented build trajectory

🧑‍🎓 The Verdict From My Brother

After testing it, my brother gave his ultimate engineering stamp of approval:

"I'm satisfied, but the pen and paper stays!"

That is exactly the right answer. CrackIt doesn't replace the notebook. It makes the math inside it actually make sense.

Built with ❤️ for my brother and engineering diploma students everywhere.