Done

Just say My child has a birthday and it’s Done. Done autonomously plans and shops for the celebration, creating a single-use prepaid card only when every budget, preference and guardrail is satisfied.

Comment

Inspiration

Done was inspired by a simple problem: busy, ambitious people do not need another app that displays hundreds of products. They need help turning an important plan into a reliable purchase decision.

When you are planning a home renovation, organizing a birthday party in two weeks, or buying ski equipment during the summer before the season starts, the challenge is not finding one cheap product. The challenge is coordinating the entire purchase plan:

  • staying within a planned budget;
  • buying the right set of products, not isolated items;
  • deciding what should be bought now and what can safely wait;
  • avoiding missed delivery dates, unavailable products, and last-minute compromises.

For example, a renovation may require materials, tools, furniture, and deliveries scheduled around contractors. A birthday requires food, drinks, cake, decorations, and allergy-safe products. Ski equipment requires coordinating skis, a helmet, jacket, trousers, and sizing — ideally bought before demand and prices rise.

Time is expensive. Done is designed to save decision-making time without taking away control.

What it does

Done transforms a goal into a structured shopping mission.

A user can describe a plan by voice or text, for example:

“Organize a nut-free birthday party for 10 children in two weeks, under 300 PLN, delivered before 16:00.”

Done converts this into a mission contract containing the budget, deadline, required products, constraints, and preferences. It then evaluates available offers and produces an explainable recommendation:

  • what to buy;
  • which merchant can fulfill the basket;
  • whether to buy now or wait;
  • whether the current price is attractive;
  • how the decision affects the total budget;
  • when the user should approve the purchase.

Done does not only ask: “Is this product cheap?”

It asks: “Is buying this product now the best decision for the entire planned budget?”

Architecture and trust

Voice and text input help users express an intent naturally. However, the final purchase decision is deterministic, explainable, and auditable.

Done stores immutable market snapshots containing prices, inventory, merchant reliability, and delivery information. Every portfolio decision is tied to a specific snapshot, selected actions, risk signals, explanations, and approval state.

This means the system can answer:

  • Why did it recommend buying now?
  • What price information did it use?
  • Which constraints shaped the basket?
  • What changed when a plan was replanned?
  • Which approval belongs to which purchase decision?

Technical details

Done uses two connected decision layers: price intelligence and portfolio optimization.

Buy-or-Wait Decision: Price, Uncertainty, and Timing

Done does not decide to wait based on a lower expected price alone. Waiting is allowed only when it is both financially meaningful and operationally safe.

First, Done calculates a recent reference price:

$$p_{avg} = \frac{1}{m} \sum p_i$$

and the recent trend:

$$ \Delta p_t = p_t - p_{t-1} $$

A lower future price is considered plausible when the current price is above its recent reference level and is not rising:

$$ p_t > \bar{p}_t \qquad \text{and} \qquad \Delta p_t \leq 0 $$

Done then uses a Conformal Prediction-inspired calibration to calculate an uncertainty interval around the expected price:

$$ r_i = |p_i - \hat{p}_{t+1}| $$

$$I = [\max(0, p - q), p + q]$$

where q is the empirical 90th-percentile residual. The interval makes uncertainty visible instead of presenting a price forecast as certainty.

Finally, Done calculates the Latest Point To Buy:

$$ LPTB = deadline - p95\ delivery\ time - safety\ buffer $$

The decision to wait is only available when the price signal supports waiting, the latest safe buying point has not been reached, and the failure risk remains acceptable:

$$ WAIT \iff PriceSignal = WAIT_PREFERRED \land t < LPTB \land Risk < Risk_{max} $$

Otherwise, Done recommends buying now.

This prevents a theoretically attractive future price from causing an operationally unsafe decision.

Portfolio Optimization with Google OR-Tools CP-SAT

The final decision is made by a portfolio optimizer built with Google OR-Tools CP-SAT.

For each eligible purchase action a, Done creates a binary variable:

$$ x_a \in {0,1} $$

Every mandatory need must be covered exactly once:

$$ \sum_{a \in A_n} x_a = 1 $$

The total purchase, including delivery cost $d$, must fit the budget $B$:

$$ \sum_{a \in A} x_a \cdot q_a \cdot c_a + d \leq B $$

The optimizer also enforces a single-merchant checkout:

$$ \sum_{m \in M} y_m = 1, \qquad x_a \leq y_{m(a)} $$

It minimizes the total cost of the decision while accounting for price, risk, quality, waiting, and merchant preference:

$$ \min \sum_{a \in A} x_a \left( q_a c_a + 800r_a - 20s_a + w_a \right) $$

where q_a is product quantity, c_a is action cost, r_a is failure risk, s_a is product quality, and w_a represents the cost or benefit of waiting.

Before optimization, Done removes actions that violate stock, allergen, delivery-deadline, required-item, or latest-point-to-buy constraints.

The price model answers whether an offer is attractive under uncertainty. The CP-SAT optimizer answers whether it is the best decision for the entire shopping mission and budget.

A better way to shop

Online shopping is usually optimized for finding and selling individual products. Done is optimized for completing an important plan.

Instead of opening many tabs, comparing products manually, worrying about delivery dates, and hoping the final cart stays within budget, users can define one goal and receive a clear, understandable purchase plan.

For customers, this means less decision fatigue and more confidence:

  • the full basket is planned around their budget;
  • delivery timing and availability are considered before checkout;
  • the recommendation explains whether to buy now or wait;
  • the user remains in control through approval before important purchases.

For e-commerce, Done creates a more meaningful shopping journey. It helps customers move from fragmented product browsing to a complete, feasible basket that matches their real need.

Done turns e-commerce from “find a product” into “complete the plan.”

Our goal is not to automate spending blindly, but to make every purchase support the whole plan.

Built With

Share this project:

Updates