Next.js · Supabase · Claude API · Claude Code

PantryPilot.
Demand planning for the Indian kitchen.

Indian households re-order what they already own and quietly throw out what expired in the back of the fridge — because the kitchen is the one inventory nobody keeps books on. PantryPilot turns any grocery receipt — a Blinkit order or a photo of a kirana bill — into a live inventory that forecasts what's about to run out and plans meals around what's about to spoil. The AI reads the receipt; deterministic code does every number.

0.96
extraction F1, measured across both quick-commerce and store receipts
01 — THE PROBLEM

You already own it.
You buy it again anyway.

Every inventory in your life has software behind it — except the one you touch three times a day. Staples run out mid-recipe. Perishables die unseen behind the leftovers. The same toor dal gets bought twice because no one remembers the first bag. It's a demand-and-inventory problem, sitting in plain sight in every kitchen, run entirely on memory.

Quick-commerce made the buying frictionless — a Blinkit order lands in ten minutes — but did nothing for the tracking. So the fridge fills faster and empties more wastefully than ever, and the household has no idea what it has until it's already gone or already spoiled.

3×/day
a supply chain you run entirely by memory
2 worlds
clean q-commerce orders and messy kirana bills, never reconciled
Silent
how perishables expire: no alert, no record, no system
02 — THE APPROACH

The model reads.
The code decides.

The tempting build is to let the LLM do everything — read the receipt, add up the total, guess when the milk runs out, invent a recipe. The decision that shaped the entire product was drawing a hard line instead: the model handles perception and generation; deterministic code owns every number. The LLM reads a crumpled bill and normalises "TOOR DAL 1KG ORG" into something real. Code strips the GST, checks the line items actually tie to the printed total, forecasts run-out from a consumption rate, and verifies that a suggested meal only uses food you genuinely have. Knowing what not to hand the model is the whole point.

Built end-to-end with Claude Code across four sessions, designed in Claude Design first — so the product decisions were locked in low-fi before a line of code was written.

01
Ingest
Vision reads any receipt: a Blinkit PDF or a kirana photo
02
Reconcile
Code strips GST and checks line items tie to the total
03
Match
Cryptic strings resolve to canonical foods, each with a confidence
04
Plan
Forecast run-out; ground every meal in real inventory
03 — STRUCTURE BEFORE SKIN

Six screens decided in grey,
before a single colour.

The six screens were blocked out in low fidelity first — hierarchy, tap targets, and, above all, where the AI's confidence and the human's correction would live. Four decisions were locked on that wireframe board on day one and never moved. When the skin went on, the palette and the type changed more than once. The structure didn't change at all — every grey box maps one-to-one to a shipped component: expiry badge, run-out chip, confidence badge, reason tag.

That discipline is the difference between designing a product and decorating one. The interesting calls — pinning uncertain items to the top of the review screen, putting the validation banner above the data so trust comes first — were made when they were cheap to make, in grey, and survived all the way to the built app.

Step 01 — Wireframes
Low-fidelity wireframes of PantryPilot's six core screens

Six screens in grey. The low-confidence review, the validation banner, and the single status scale were all placed before any colour existed.

Step 02 — Hi-fi
High-fidelity design of PantryPilot's core flow — Home, Add, Review

The same core flow, skinned. One status scale — fresh / use-soon / expired — drives every badge, chip, and tag in the system.

Step 03 — Built
The shipped PantryPilot Home screen running on a phone

Shipped. Add is one tap from both Home and the tab bar; the kitchen view leads with what's about to run out.

Add receipt is reachable from Home and the tab bar — never more than one tap away.
Low-confidence items are pinned to the top of the Review screen, where the eye lands first.
The validation banner sits above the item list — trust is established before data.
One status scale — fresh / use-soon / expired — drives every badge in the app.
Every wireframe box maps 1:1 to a hi-fi component. The skin changed three times; the structure never did.
04 — WHAT IT DOES

From a crumpled receipt
to a planned kitchen.

Reads any receipt — clean or messy
A Blinkit PDF or a photo of a kirana bill. It detects the source and adapts: tidy quick-commerce names sail through, while abbreviated store strings get heavier normalisation.
Does the math the model can't be trusted with
Strips GST, reconciles line items against the printed total, and forecasts run-out from a learned consumption rate. When the numbers don't add up, it flags the receipt instead of quietly "fixing" it.
Plans meals grounded in what you actually own
Suggests Indian dishes that use what's expiring first — and will never claim you have an ingredient you don't. Respects veg, Jain, and no-onion-garlic, enforced in code, not just the prompt.
👤
Shows its work, and its doubt
Every uncertain item surfaces with a confidence score and a "did you mean," routed to a review screen. The app never guesses silently — the human confirms before anything enters the pantry.
05 — THE OUTCOME

Measured,
not vibed.

0.96
extraction F1 across both input modes (0.97 q-commerce, 0.95 store)
100%
accuracy on high-confidence items; everything below is routed to a human
22.6 → 2.0 days
forecast error, cold-start vs after just two repurchases

This is a portfolio build, so the proof isn't adoption — it's that the measurement caught the model being wrong, exactly where it was designed to. The grounding guardrail reclassified a 7% rate of fabricated "you have this" claims before any meal reached the screen. The reconciliation check caught every injected price error, three for three. And the confidence score turned out to mean something: items above 0.85 were right 100% of the time, items below 0.70 only 63% — which is precisely why the low ones go to a person. All of it runs at about ₹0.41 a receipt, roughly ₹30 a month at real usage.

The model reads a crumpled kirana bill; the code refuses to lie about what's in your fridge. Less waste, fewer double-buys, and a kitchen that finally keeps its own books.

STACK
Next.jsSupabasepgvectorClaude APIVoyage embeddingsClaude CodeClaude Design
Anyone can make an AI read a receipt. The product was everything I didn't let it touch.