Case Study: An Expense-Splitting App

Case Study: An Expense-Splitting App — Tech Epitome

The brief

Friends share costs on a trip. Anyone in a group can record an expense they paid and say who it was for, split equally, by exact amounts, or by percentages. The app shows each person's balance, suggests a short list of payments to settle everything, and records settlements. Moving real money is out of scope; multiple currencies are an extension.

Money is a value object

The first decision is the most consequential. Binary floating point cannot represent most decimal fractions exactly, so 0.1 + 0.2 is not 0.3 in a double, and errors accumulate across thousands of expenses. Store amounts as integer minor units (cents, paise) or a decimal type, and never let an amount travel without its currency.

Before and after

Splitting 100.00 three ways

double, rounded per share

33.33

sum: 99.99

a cent has vanished

Money.allocate(3)

33.34

33.33

sum: 100.00

nothing lost

Rounding each share independently loses the remainder. Allocation hands the leftover minor units out one at a time, so the parts always add back up to the total.

java

1public record Money(long minor, Currency currency) {2 3    public static Money zero(Currency currency) { return new Money(0, currency); }4 5    public Money plus(Money other) {6        requireSameCurrency(other);7        return new Money(Math.addExact(minor, other.minor), currency);8    }9 10    /** n parts that differ by at most one minor unit and sum exactly. Assumes minor >= 0. */11    public List<Money> allocate(int n) {12        long base = minor / n, remainder = minor % n;13        List<Money> parts = new ArrayList<>(n);14        for (int i = 0; i < n; i++)15            parts.add(new Money(base + (i < remainder ? 1 : 0), currency));16        return parts;17    }18 19    private void requireSameCurrency(Money other) {20        if (!currency.equals(other.currency))21            throw new IllegalArgumentException(currency + " vs " + other.currency);22    }23}

Immutable, currency-aware, and incapable of losing a cent.

python

1def allocate(total_cents: int, weights: list[int]) -> list[int]:2    """Split by weights; leftover cents go to the largest fractional parts."""3    whole = sum(weights)4    raw = [total_cents * w for w in weights]5    parts = [r // whole for r in raw]6    leftover = total_cents - sum(parts)7    by_fraction = sorted(range(len(weights)), key=lambda i: raw[i] % whole, reverse=True)8    for i in by_fraction[:leftover]:9        parts[i] += 110    return parts11 12 13allocate(10_000, [1, 1, 1])     # [3334, 3333, 3333]14allocate(10_000, [50, 30, 20])  # [5000, 3000, 2000]

Weighted allocation covers percentage and share-based splits with one function.

Entities

Entity	Is the only thing that knows
Member	Who a person is within a group
Group	Who is in it and which expenses belong to it
Expense	Who paid, how much, and the resulting share per member — immutable once recorded
SplitStrategy	How a total becomes per-member shares
Settlement	A recorded payment from one member to another
Ledger	Net balances, derived from expenses and settlements
DebtSimplifier	How to turn balances into a short list of transfers

Ledger stores nothing of its own; it is a view over the facts.

Splits are strategies

java

1interface SplitStrategy {2    Map<MemberId, Money> shares(Money total, List<MemberId> participants);3}4 5final class EqualSplit implements SplitStrategy {6    public Map<MemberId, Money> shares(Money total, List<MemberId> people) {7        List<Money> parts = total.allocate(people.size());8        Map<MemberId, Money> out = new LinkedHashMap<>();9        for (int i = 0; i < people.size(); i++) out.put(people.get(i), parts.get(i));10        return out;11    }12}13 14final class ExactSplit implements SplitStrategy {15    private final Map<MemberId, Money> amounts;16    ExactSplit(Map<MemberId, Money> amounts) { this.amounts = Map.copyOf(amounts); }17 18    public Map<MemberId, Money> shares(Money total, List<MemberId> people) {19        Money sum = amounts.values().stream()20            .reduce(Money.zero(total.currency()), Money::plus);21        if (!sum.equals(total))22            throw new InvalidSplit("shares sum to " + sum + ", expense is " + total);23        return amounts;24    }25}

A new split type is a new class; Expense never changes.

Balances are derived

Each member's net balance is what they paid minus what they owe. Rather than keeping mutable balance counters that every expense must update correctly — and that two simultaneous expenses can corrupt — compute balances from the list of expenses and settlements. Cache the result if it gets slow; the list stays the source of truth.

Deriving balances

InputGroup {A, B, C}. A pays 90 for all three. B pays 30 for B and C.

Expense 1: A paid 90Shares 30 each. A: +90 − 30 = +60; B: −30; C: −30.
Expense 2: B paid 30Shares 15 each for B and C. B: −30 + 30 − 15 = −15; C: −30 − 15 = −45.
Check the invariant+60 − 15 − 45 = 0. Any other sum means a bug.

ResultNet: A +60, B −15, C −45. The three balances sum to zero.

Simplifying debts

Recording who owes whom per expense would leave B owing A, C owing A and C owing B: three payments. Using net balances instead, a greedy pass repeatedly matches the biggest creditor with the biggest debtor and settles the smaller of the two amounts. Each step zeroes at least one person, so a group of n people needs at most n − 1 transfers.

java

1List<Transfer> simplify(Map<MemberId, Long> net) {     // > 0 is owed, < 0 owes2    PriorityQueue<Map.Entry<MemberId, Long>> creditors =3        new PriorityQueue<>(Map.Entry.<MemberId, Long>comparingByValue().reversed());4    PriorityQueue<Map.Entry<MemberId, Long>> debtors =5        new PriorityQueue<>(Map.Entry.comparingByValue());    // most negative first6    net.forEach((who, amount) -> {7        if (amount > 0) creditors.add(Map.entry(who, amount));8        if (amount < 0) debtors.add(Map.entry(who, amount));9    });10 11    List<Transfer> transfers = new ArrayList<>();12    while (!creditors.isEmpty()) {13        var c = creditors.poll();14        var d = debtors.poll();15        long amount = Math.min(c.getValue(), -d.getValue());16        transfers.add(new Transfer(d.getKey(), c.getKey(), amount));17        if (c.getValue() > amount) creditors.add(Map.entry(c.getKey(), c.getValue() - amount));18        if (-d.getValue() > amount) debtors.add(Map.entry(d.getKey(), d.getValue() + amount));19    }20    return transfers;21}

Balances sum to zero, so creditors and debtors run out together.

Greedy settlement on the example

InputNet: A +60, B −15, C −45

Match A (+60) with C (−45)Settle 45. A is still owed 15; C is done.
Match A (+15) with B (−15)Settle 15. Everyone is at zero.

ResultTwo transfers: C pays A 45, B pays A 15

Approaches

Turning balances into payments

Pay back per expense
Time
O(expenses)
Space
One debt per share
Never as a suggestion — it is how the data is recorded, not how people should settle.
Greedy on net balances
Taught here
Time
O(n log n)
Space
Two heaps
Almost always. At most n − 1 transfers, fast, and easy to explain to users.
Exact minimum transfers
Time
Exponential in n
Space
Subset search
Small groups where saving one payment matters. The minimum relates to splitting people into the most zero-sum subgroups, which is NP-hard in general.

Trade-offs and extensions

Editing an expense: record a reversal and a replacement rather than mutating the original. Balances stay derivable and every change is explainable — the same reason accountants never use an eraser.
Multiple currencies: keep balances per currency, and convert only at settlement time with the rate recorded on the Settlement. Converting at entry time bakes a rate into history.
Concurrent edits: appending immutable expenses cannot lose an update, whereas two requests incrementing the same balance counter can. The model choice removes the race.
Recurring expenses are a schedule that produces ordinary expenses; the ledger does not need to know they exist.

Search Tech Epitome

Search Tech Epitome

The brief

Money is a value object

Splitting 100.00 three ways

Entities

Splits are strategies

Balances are derived

Simplifying debts

Turning balances into payments

Pay back per expense

Greedy on net balances

Exact minimum transfers

Trade-offs and extensions

You’ve reached the end