CommonLot

CommonLot calls small businesses and their supplier, assembles a shared purchase that meets each buyer’s conditions, and revises the proposal when those conditions change

Comment

Inspiration

Small neighborhood businesses often pay retail prices because wholesale discounts sit behind minimum order quantities they cannot reach alone. The demand exists, but it is fragmented across informal phone calls, private budgets, changing quantities, and different delivery constraints.

CommonLot began with a simple question: what if those conversations could become one trustworthy, organizer-controlled purchasing proposal?

What it does

CommonLot helps an organizer coordinate shared purchases through CALL-E phone conversations.

The organizer creates a buying group, adds buyers and suppliers, and starts a purchasing round. CALL-E gathers structured conditions such as quantity, maximum price, spending ceiling, and timing. CommonLot then combines those conditions and evaluates supplier pricing tiers.

Our demo follows three buyers requesting 12, 10, and 8 cartons. Together, they reach a 30-carton wholesale tier:

  • Combined quantity: 30 cartons
  • All-in price: ₹950 per carton
  • Total: ₹28,500
  • Potential savings: ₹7,500

If Buyer C reduces their request from 8 cartons to 6, CommonLot immediately withdraws the result and reports a two-carton shortfall. When Buyer A offers to increase from 12 to 14, the system still refuses to proceed until their spending ceiling is explicitly reconfirmed.

A feasible proposal is never treated as an order. Every consequential step remains under organizer control.

How we built it

CommonLot is a TypeScript monorepo with a Next.js and React interface, an Elysia API, type-safe oRPC contracts, PostgreSQL, Drizzle ORM, and Better Auth.

CALL-E handles real phone-call execution and returns structured results. A deterministic feasibility engine evaluates quantities, supplier thresholds, buyer limits, price changes, savings, and reconfirmation requirements.

Every call is labeled as LIVE, RECORDED, or SIMULATED. Simulation is the default, making the complete workflow safe and inexpensive to demonstrate without hiding what is real.

The interface follows Apple-inspired principles of clarity, deference, depth, and direct manipulation. We also created a seven-scene cinematic product story using original carton artwork and screenshots captured from the real application.

Challenges we ran into

The hardest challenge was preserving the difference between information and authorization.

A buyer saying they can accept more cartons does not automatically mean they approved a higher total. Missing or unclear answers cannot be interpreted as demand. A supplier price revision can also invalidate confirmations that were previously valid.

We therefore separated CALL-E’s conversational extraction from a deterministic business-rules engine. Unknown answers produce no write-back, changed terms trigger reconfirmation, and order transitions remain explicit human actions.

We also worked through cross-origin authentication, monorepo deployment, server-side aggregation, and presenting dense operational data without overwhelming the organizer.

Accomplishments that we're proud of

  • Reproduced the complete 12 + 10 + 8 scenario through actual application workflows.
  • Automatically withdrew a stale proposal after demand fell to 28 cartons.
  • Prevented Buyer A’s increase until their new ₹13,300 ceiling was explicitly confirmed.
  • Kept every result traceable to its originating call and evidence mode.
  • Built a safe simulation path that uses the same proposal engine as live calls.
  • Successfully placed and reconciled a real CALL-E call while correctly preserving unanswered fields as unknown.
  • Created a polished, accessible interface with responsive presentation and reduced-motion support.

What we learned

Voice agents are most valuable when they collect evidence—not when they silently make business decisions.

The strongest architecture was to let CALL-E handle conversation while deterministic software handled feasibility, authorization, and state transitions. This made changing answers, incomplete calls, and contradictory constraints much easier to reason about and audit.

We also learned that explaining why a proposal stopped being feasible is just as important as finding a feasible proposal.

What's next for CommonLot

Next, we want to add webhook-based call reconciliation, multilingual buyer conversations, richer supplier-tier comparisons, reusable purchasing templates, and exportable audit reports.

We also plan to test Hindi and regional-language workflows, measure organizer time saved per round, and expand from packaging supplies into other repeat-purchase categories where small businesses can benefit from coordinated buying.

Built With

Share this project:

Updates

Submission history