Less manual entry: AI receipt scanning turns group bill splitting from “split evenly” into “item by item, accurately”
Timeline
Launched: 2025.08 ~ 2026.02
Scope
I handled PM and UIUX design, including competitor research, leading the whole design system, and cross-language calibration.
Team
Personal project: 1 mobile engineer, 1 UIUX designer
9.09%
Bill creation
Usage rate of creating a split
-33.33%
Bill completion
Results one month after launching the flow from creating a split to settling up
BACKGROUND
Snap a receipt and Klip works out who should pay for each item
Klip is a bill-splitting app designed for friends and family. After you photograph a receipt, AI extracts the items and amounts so shared expenses can be split item by item instead of typed in one at a time.
EVIDENCE
Existing bill-splitting apps can record expenses but only support splitting the whole bill evenly, so whoever ate more pays the same
While traveling I used three splitting tools: Splitwise, Tricount and BillBear. All of them record “who paid how much”, but nearly all split by the whole bill, evenly.
Here is the real scenario: For group meals with complex charges (food, service fees, discounts), let everyone tick their own items as if marking a menu and have the split calculated automatically, helping the organizer collect payment quickly with zero loss while giving everyone a fair, transparent checkout.
INSIGHT
After breaking down 6 competitors: AI can scan the amounts but can’t calculate them correctly
I chose “process-node breakdown” as the research method instead of user interviews, because “where existing solutions fail” calls for a reproducible feature comparison rather than user preference.
1
Manual entry: strengths and limits
Strengths:
Complete split settings, supporting percentages and fixed amounts
Settling up supports partial repayments
Limits:
Reports show only the total owed, not which purchases add up to it
Entry cost rises linearly with the number of items
2
3 shared failure points of AI-scanning apps
Currency decimals:
Yen and euros shouldn’t have decimals in some cases, yet an even split produces amounts like 333.33
Tax and discounts aren’t booked:
Tax, service fees and coupons on the receipt aren’t allocated to items automatically, so users still have to work backwards and adjust by hand
Recognition results can’t be corrected effectively:
Receipt layout and clarity directly affect extraction accuracy, but the correction entry is buried layers deep in the edit page
Competitor analysis summary
AI extraction is already a mature technology. The real bottleneck isn’t “can it scan?” but the correction cost and calculation accuracy after scanning. That decided my design focus.
PROBLEM
Problem
HMW make “claiming items and splitting costs” at group meals as intuitive as marking a physical menu
Three principles distilled from the three failure points set the priority of feature trade-offs
The competitor analysis listed 3 pain points. I filtered them with 2 criteria: whether they affect amount accuracy, and whether a 2-person team could build them within 2 months.
Excluded pain points include conflict handling for simultaneous multi-user editing and merged settlement across bills, because the implementation cost exceeded current resources and they were left for later versions.
Competitor pain point
Design principle
Matching feature
Recognition results are hard to correct
Assume AI will be wrong and minimize the cost of correction
Recognition results page is editable in place
Tax, discounts and currency decimals are miscalculated
Amounts must be verifiable; the sum always matches the original bill
Hypothesis 1: AI will misread, so put the edit entry in the results page and make a correction one step
Receipt layouts, fonts and thermal-paper fading vary enormously by region, so OCR will inevitably misrecognize. The question isn’t “how do we make AI more accurate” (that’s a model-layer concern) but how to let users fix it at the lowest cost.
1
Confirmation page after AI scanning
A separate confirmation page appears after scanning, where each item is checked one by one. But with one more page, if there are many items and recognition is poor, it amounts to making users type everything in again.
2
Recognition results page is editable in place
Items appear directly as editable fields; tap to change
Lowest correction cost, but users may not know they “can edit”
3
Low-confidence flags
AI flags uncertain fields to prompt the user to check
Best experience, but it needs confidence scores from the back end, which wasn’t feasible this cycle
I went with an editable recognition results page to “minimize correction cost”. The trade-off is that users may not realize the results are editable, so I compensated with an edit icon as a cue.
DESIGN
Hypothesis 2: receipts have 4 combinations of tax and discount, covered at once by 4 calculation logics
The most common complaint about competitors is “I still have to work out the tax after scanning”. I broke down the tax and discounts on Taiwan, Japan and US receipts into four scenarios, each mapped to a set of field calculation rules:
1
Listed price includes tax
2
Listed price excludes tax; tax is added at checkout
3
Whole-order coupon (discounts the total)
4
Item coupon (discounts a specific item)
The default logic is chosen from the fields detected on the receipt, and users can switch manually. This lets users get correct split amounts without needing to understand tax systems.
DESIGN
Hypothesis 3: decimal places depend on currency, the remainder always goes on the first item, and the total always matches
Splitting 100 among three people gives 33.33 each, which adds up to 99.99, and nobody pays the missing cent. Competitors generally round, so the split total doesn’t match the bill.
1
Round off
The total doesn’t match the original bill, so users question the accuracy
2
Payer absorbs the remainder
Unfair to the payer, who has usually already paid up front
3
Remainder goes on the first item
A simple, predictable rule, and the total always matches
Decimal places also depend on currency: yen and won show no decimals, while TWD and USD keep two. The design principle is “amounts must be verifiable”: add them up with a calculator and the sum always equals the receipt.
DESIGN
After launch, AI scanning usage was only 9.09%: follow-up optimization
After launch I saw that the share of users using AI scanning was clearly below expectations, since users must create a group before they can create a split. It wasn’t that users didn’t need the feature; the entry copy didn’t convey its value. The original “Take photo” described the action but not the result.
I made an adjustment, changing the entry copy from “Take photo” to “Scan receipt”.
I first assumed it was a copy problem; it was actually that the entry point sat too deep
LEARNING
Building 40 color tokens so light and dark modes share one set of semantic names
I planned a color system for Light and Dark modes and organized 40 color tokens covering brand color, status color, container color and background color. Names are semantic (not color values), so new features can apply them directly without redefining colors.
Layouts are designed for the longest language, avoiding page-by-page redesigns after launch
The app supports 2 languages. Waiting until translation is done to adjust layouts would mean redoing every page, so I simulated layouts with the longest language at design time.