This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
Every car owner on earth has had the same moment: the mechanic slides a bill across the counter, you stare at "throttle body decarbonising — ₹3,400," and you have absolutely no idea whether that's real or theatre. You pay, because the alternative is an argument you're guaranteed to lose.wrenchwise is my answer to that moment: paste any repair estimate, and it checks every line against fair-price data, flags the inflated ones, and explains the whole thing in plain English — with AI that runs 100% on your device. Bills, made honest.
## What I built
A single-file web app. You paste the estimate (straight from the garage's WhatsApp message — that's how estimates actually arrive), pick your region, and hit Analyze. In under a second you get:
- A verdict stamp: OVERPRICED, QUESTION IT, or FAIR DEAL — plus an overpay gauge and count-up totals
- Your quoted total vs. the fair range, with a potential overpay figure
- A line-by-line breakdown — each item flagged FAIR / HIGH / ABOVE RANGE / BELOW RANGE / UNKNOWN, with its fair range on a visual bar and a note on what to watch for
- A cross-check: does the bill's stated total actually match the line items? (Padding hides here more often than you'd think)
- Then, one click loads Gemma 2B in your browser and streams a plain-English explanation of the flagged items, a two-sentence verdict, and three sharp questions to ask your mechanic
Try the sample estimate first — it's a realistically padded brake-job bill, and watching it get caught is the whole pitch in ten seconds.
Demo
Live demo: wrenchwise — bills, made honest
Source code: github.com/shivvpokhariya-lgtm/hacktoberfest-dev-challenge
No signup, no server, no API key. Open it in Chrome or Edge; the line-by-line analysis works instantly, and the AI explainer needs one click to download the model weights (~1.5 GB, cached after).
How I built it
Two layers, each doing what it's actually good at — this is the architectural decision the whole project rests on:
- A deterministic engine in plain JavaScript. It parses the pasted text (one item per line, price at the end), matches each line against a curated price pack using alias matching, and flags anything outside fair range with deliberately conservative thresholds. Every number on screen is computed by code. The model never does math, never invents a price. I tested the core in Node against both sample estimates and edge cases (unknown parts, totals-only pastes, empty input) before it ever touched a browser.
- Google's open-weight Gemma 2B as the explainer, via WebLLM. One CDN import, WebGPU inference, zero backend. The model receives the computed numbers and does the one thing small models do well: put figures into plain words, in a tone a non-car person can act on. If the browser has no WebGPU, the app degrades gracefully — the deterministic analysis is complete on its own.
The price data ships as PRICE_PACKS: 22 common jobs for India (₹), 14 for the US ($, marked beta). The ranges are indicative baselines compiled from published Indian service-price sources — GoMechanic's own rate cards, MyCarHelpline's wear-and-tear tables, insurer-published cost guides — with full methodology and links in DATA_SOURCES.md in the repo. They err on the wide side deliberately: a flag means "ask about this," not "you're being cheated." Adding a region is literally one object — that's the expansion path.
Why open innovation matters for what I built
The challenge asked four questions. Here's my honest answer to each:Does running your own model keep costs low enough that the business actually works? Yes — and it's structural, not marginal. The pricing I have in mind is $2 per quote, pay-per-use. At that price, any per-token API cost plus server hosting turns a side hustle into a hobby that loses money. With the model running on the user's device and the whole app as a static file, my marginal cost per quote is $0 and my infrastructure is a static host. The unit economics survive contact with reality.Keep your customers' data private? This is the one I'd lead with. A repair estimate carries your number plate, your VIN, your phone number, your service history — it's an identity document with an oil change attached. Nobody should have to upload that to a cloud API to find out if their brake pads are overpriced. Here, the privacy boundary is the product: weights download once, and after that the page works with the network effectively irrelevant.
Let you fine-tune for a niche that a general-purpose API handles poorly? A general chatbot, asked "is ₹6,800 fair for front brake pads," will hedge, hallucinate a range, or confidently state something wrong. wrenchwise doesn't ask the model about prices at all — the curated price pack is the source of truth, and the open model is the translator between that data and a human. Niche knowledge in code, language in weights: each component doing the job it's reliable at.
Avoid getting locked into someone else's pricing? No API key means no one can raise my prices, throttle my users, or deprecate the model under a live product. The weights are open weights under Google's Gemma Terms of Use, which permit commercial use; if a better 2B model appears, I swap one string.
The through-line across all four: Gemma isn't a feature bolted onto this product — it's the load-bearing wall. Without a capable open-weights model that runs on the user's own hardware, wrenchwise cannot exist at its price point, cannot keep its privacy promise, and cannot run without a backend. That's what "best use" means to me: the product is shaped around what the open model makes possible, not the other way around.## Who would pay for this?
Car owners, $2 a quote — the pitch writes itself: "this app saved me ₹4,450 on one visit" (that's the actual overpay figure on the built-in sample). Beyond that, there's a B2B angle I like even more: independent garages white-labeling a "verified fair quote" badge to win trust from first-time customers. Trust is the scarcest commodity in that industry, and a third-party check manufactures it.
My first user
The validation that matters isn't my test suite — it's a real person with a real bill. The test I'm running this week: hand the demo to a car owner with a recent service bill and ask three things — did the flags match his gut, what confused him, and would he have paid $2 to know before approving. If you've got a service bill handy, run it through the demo and tell me in the comments what it gets wrong — you'd be the first user this section is about.## Prize categories
- Best Use of Gemma — Gemma 2B is the entire AI layer, running as open weights on-device.
Built as a single HTML file. The deterministic core is framework-free and Node-tested; the AI layer is one WebLLM import. If you run a garage, or you've ever paid a bill you didn't understand — I'd genuinely like to hear what it gets wrong.
Top comments (0)