Weedmaps · Checkout · Pricing trust
Explaining an unexpected discount at checkout
A checkout pattern for a price change discovered only after downstream cart validation — turning a silent total change into a clear, trustworthy confirmation moment.
Context
This work was for Weedmaps, a regulated marketplace where consumers browse products, compare options, and place orders through local retailers.
At checkout, the platform validated the cart against downstream systems before the order could be placed. That validation could return updated pricing, including retailer-configured discounts or specials that were not visible earlier in the cart experience.
When that happened, the order total dropped silently. The outcome was positive — the user was paying less — but the experience did not explain why the number changed. In a checkout flow, even good news can create doubt if the system cannot make the change legible.
The brief
What was asked for
Add a message when checkout discovered that a lower price had been applied to an item in the cart.
What it actually was
Define how the product should communicate an asynchronous price change without overclaiming the source, slowing checkout unnecessarily, or making a positive change feel like a system error.
Constraints
Every project has the constraints you negotiate and the ones you live inside. The ones that shaped this work:
- The lower price was not known when the user built the cart. It only appeared after checkout validation.
- The discount came from retailer-connected systems, so the platform could not always claim ownership of the savings.
- Checkout is a high-intent moment. Any interruption needed to earn its place.
- The message needed to explain the change without implying the order was complete or the discount required user action.
- The pattern needed to leave room for harder future states, including price changes that affect order thresholds, minimums, or eligibility.
Decisions
Message the change only when the system actually knows it
The discount could not be promised in cart because the platform did not know whether downstream validation would return a lower price. I anchored the message to the moment the new total became available. That kept the experience honest and avoided showing savings before the system could confirm them.
Treat the discount as a trust event before a delight event
The original temptation was to make the moment celebratory. That mattered, but it could not be the only goal. A checkout total changing without explanation is still a trust problem, even when the number goes down. The design needed to answer the user's likely question first: why did my total change?
Use neutral attribution instead of claiming credit
More branded copy would have been warmer, but it risked implying the platform had found or created the discount. I chose language that described the event without overclaiming the source: a lower price was found and applied. The copy was intentionally precise because pricing language at checkout has to be defensible.
Make the interruption lightweight and recoverable
The modal had to earn the interruption. It confirmed that something good happened, then returned the user to checkout with the updated total visible. The pattern avoided creating a new decision point or making the discount feel like something the user needed to manually accept.
Design the pattern as part of a larger price-change system
This was one version of a broader checkout problem: totals can change because of discounts, fees, taxes, inventory, or operational rules. I treated the modal as a first step toward a more consistent pattern for explaining asynchronous cart changes, not as a one-off celebration state.
Tradeoffs
- Delight vs. trust — chose a clear confirmation moment over a heavily celebratory message that could obscure the reason for the change.
- Attribution vs. accuracy — chose neutral language over branded ownership that overclaimed the source.
- Momentum vs. interruption — chose a short, dismissible modal over a persistent explanation that slowed checkout.
- Immediate scope vs. future edge cases — chose shipping the confirmed savings state over waiting to build a comprehensive framework for all scenarios.
Working with the room
The design needed agreement across product, engineering, and legal because each group owned a different part of the truth. Engineering knew when the price change became available. Product knew where the interruption could fit without damaging checkout momentum. Legal shaped what the product could responsibly claim about the source of the savings. I used flow logic, copy variants, and annotated states to make the tradeoffs visible. The conversation shifted from "Should this feel more delightful?" to "What can the system know, what can the interface claim, and what does the user need to understand before placing the order?"
Outcome
The final pattern gave users a clear explanation when checkout discovered that a lower price had been applied. It made the updated total feel intentional rather than suspicious, avoided overclaiming where the savings came from, and preserved momentum through the checkout flow. More importantly, the work established a useful principle for future checkout states: when the system changes the terms of an order, the interface needs to explain what changed, why it changed, and what the user can do next.
In hindsight
The value of this work was not the modal itself. It was recognizing that a system event had become a user-facing trust moment. Checkout design is full of moments like this: small changes in totals, rules, availability, or eligibility that the system understands but the user does not. Good design does not just make those moments look better. It makes them legible. That was the core lesson here: when a product changes something important, the explanation is part of the experience.
Next case study →
Reframing cart and checkout as a growth system
Weedmaps · Consumer growth