SmartCart

Urban shoppers increasingly split groceries across 2 to 4 quick-commerce apps because no single platform is reliably cheapest or fastest across every category. The result is a manual process that doesn't scale: opening three or four apps, searching the same item repeatedly, and mentally tracking which app had what price, a process that gets abandoned for convenience well before a full weekly shop is actually optimized.

None of the platforms themselves will build a cross-comparison tool, that's a structural conflict of interest. General price-comparison sites are built for one-off purchases, not recurring multi-item baskets. No existing product treats the basket, not the individual item, as the unit of comparison, or reasons about the real convenience cost of splitting an order across checkouts.

SmartCart is a single-page tool: paste a free-text grocery list, and it returns a full basket allocation, which items to buy on which platform, total cost, savings versus sticking to one app, fastest combined delivery time, and an explicit callout when splitting the order across multiple checkouts is required to get that price.

The allocation logic itself follows a fixed set of rules: for each matched item, filter to platforms where it's actually available, take the lowest price, and if two available platforms are within ₹3 of each other, prefer the faster one. ₹3 was chosen deliberately as a flat, absolute threshold rather than a percentage, so the tie-break means the same thing whether the item is ₹15 or ₹900. If nothing is available anywhere, the item's curated substitute list is tried next. If that fails too, the item is surfaced by name in a dedicated 'not found' section, never silently dropped.

The final interface wasn't the first attempt. It went through a structured, section-by-section critique process, treating each round as if reviewing a junior designer's submission, naming specific problems rather than iterating on vague 'make it look better' feedback.

The comparison is the product, so the result must be the visually dominant element, not a footnote beneath marketing copy. AI should disappear into the workflow, invoked once and silently, never surfaced as a chat interface. Users optimize baskets, not individual items, so the total and the savings lead, not a per-item price list. And trust is earned structurally: never silently drop a user's input, and always make the real tradeoffs, like a multi-checkout split, visible rather than neutral.

SmartCart v1 is intentionally stateless and no-auth, with no saved lists or history, since no per-user server-side state exists at all. Pricing comes from a static, realistic mock catalog rather than live or scraped data, since none of the four platforms expose a public pricing API and production-scale scraping carries real legal and reliability risk. There's no location-awareness, no checkout or cart integration, SmartCart recommends, it never transacts, and no price-per-unit normalization across differing pack sizes yet, though the data model already supports adding it without a schema change.

Treating design critique as a distinct, named step, not a vague pass, produced the single biggest quality jump in the project. Specific, named problems produce specific, targeted fixes. Vague 'make it look better' feedback produces vague changes. The Round 7 correction also matters as its own lesson: restraint and emptiness are not the same thing, and a design process needs to actively check for both over-decoration and over-restraint, not assume removing decoration automatically produces good design.

External dependencies turned out to be less stable than assumed. The project moved through three different Gemini model identifiers as earlier ones were deprecated mid-build, each requiring a live debugging session from a raw deprecation error, alongside a Tailwind v3-to-v4 config mismatch between local and deployed environments. Centralizing the shared TypeScript contract between the API, the AI prompt layer, and the UI paid off directly here: whenever the result shape needed to change, the compiler surfaced every place that needed updating, rather than the mismatch surfacing later as a runtime bug.