Nobody Has to Say Their Budget Out Loud: Building Wise Piggy in 24 Hours

Eva Stamatovska — Wed, 28 Oct 2026 13:18:58 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

"So, what's everyone's budget?"

That's the question that kills group trips. The chat goes quiet. Nobody wants to be the one who can't afford it, so people say yes to things they can't really pay for, or quietly drop out. It's even harder when your friends live in different countries, pay different amounts for flights and think in different currencies.

So my teammate Josie Collins and I built Wise Piggy, a group trip planner where nobody has to say their budget out loud. We built it for the Wise "Max Ease" track, which asked for projects that take the friction out of everyday tasks.

Before the trip: each person privately enters a flight budget, a budget for shared costs and a daily allowance, in their own currency. The app only shortlists destinations that fit everyone, using live flight prices from each person's own airport. The group then votes anonymously.
During the trip: you snap a receipt or just say what you paid ("I paid 42 euros for dinner, Amara had the pasta for twelve"), and the bill is split by what each person actually had.
After the trip: the app settles up in as few payments as possible, converted into each payer's home currency with live Wise rates.

Keeping budgets private

I work in security, so this was the part I cared about most. Hiding a number in the UI doesn't make it private, because anyone can open dev tools and read the raw API response. So we put the privacy rules on the server.

Budgets go in, but never come out. The budget endpoint only accepts the caller's own budget, checked against the user ID in their login token. Every response is built from an explicit list of approved fields, and other people's budgets are never on that list.

A hidden group ceiling. To work out what the group can afford together, the server calculates a ceiling from everyone's budgets. It can stretch slightly above the lowest budget, but only if the person with that budget privately agrees:

// ceiling = lowest + min(10% of (highest - lowest), 10% of lowest)
const stretch = Math.min(
  Math.floor(0.1 * (highest - lowest)),
  Math.floor(0.1 * lowest)
);
const stretchCeiling = lowest + stretch;

let ceiling = stretchCeiling;
for (const m of below) {
  // No answer or "no" means the ceiling drops to their budget
  if (m.acceptsStretch !== true) ceiling = Math.min(ceiling, m.groupBudgetBase);
}

The ceiling never leaves the function that computes it. Only the resulting shortlist is saved where clients can read it.

No leaks through failure messages. If no destination fits, everyone sees the same neutral message. It never says whose budget is the problem. Votes come back as totals only. And in a group of two, where you could work out the other person's budget by elimination, both people get a warning before entering one.

The AI never sees a budget. Gemini only gets receipt photos, transcripts and member names, and gemini.js doesn't even import the database. All the money maths runs in plain, deterministic code covered by 75 unit tests.

Splitting receipts so the pennies always add up

Receipts never divide cleanly, because tax, tips and discounts break the maths. We work in integer minor units (pence, cents) and give the leftover units to the largest remainders, so the shares always add up to the exact total:

function splitByWeights(totalMinor, weights) {
  const people = weights.filter((w) => w.weight > 0);
  const sum = people.reduce((s, w) => s + w.weight, 0);
  const exact = people.map((w, i) => ({ i, userId: w.userId, raw: (totalMinor * w.weight) / sum }));
  const shares = exact.map((e) => ({ userId: e.userId, shareMinor: Math.floor(e.raw) }));
  let leftover = totalMinor - shares.reduce((s, x) => s + x.shareMinor, 0);
  const order = [...exact].sort((a, b) => (b.raw % 1) - (a.raw % 1) || a.i - b.i);
  for (const e of order) {
    if (!leftover) break;
    shares[e.i].shareMinor += 1;
    leftover -= 1;
  }
  return shares;
}

The rest of the stack is React, Node/Express and PostgreSQL, with the Wise API for live exchange rates (every expense stores the rate, its source and when it was fetched) and ElevenLabs for voice entry and spoken confirmations like "Saved €42 for Dinner. Amara owes you €12."

What I learned

Privacy is a backend problem. If the server sends a value, it isn't private, whatever the UI does.
Let AI handle messy input, not money. Gemini is great at reading a crumpled receipt. Deciding who owes what belongs in tested code.
Read the pricing page twice. More on that below.

Demo

🔗 Live: wisepiggy.club. Log in as tom, amara or lucia with the password demo1234.

💻 Code: github.com/josie-collins/iku-hackathon

Partner Technologies

Vultr (winner: MLH Best Use of Vultr 🏆)

Vultr runs our production app. We used an Ubuntu 24.04 VPS with one Node process serving both the API and the built React app on port 8080. Caddy sits in front as a reverse proxy and gets and renews HTTPS certificates automatically:

wisepiggy.club, www.wisepiggy.club {
    encode gzip
    reverse_proxy localhost:8080
}

Because the app handles financial data, I wanted the server locked down, not just running. The firewall only allows SSH, HTTP and HTTPS, so port 8080 can't be reached from outside. The app runs as a systemd service under its own unprivileged user, with hardening options that limit it to its own folder:

[Service]
User=wisepiggy
ExecStart=/usr/bin/node index.js
Restart=on-failure
NoNewPrivileges=true
ProtectSystem=full
ProtectHome=true
PrivateTmp=true

The whole setup is a setup-server.sh script, a Caddyfile and the service file, and redeploying is one script.

Gemini API

Gemini reads receipts line by line (total, currency, shop and each item) and turns voice transcripts into draft expenses. We used structured JSON output with a strict schema, which made it far more reliable than parsing free text. Amounts are converted to minor units in our own code, not by the model. When the main model returned "high demand" errors, a lighter Flash-Lite model took over.

The lesson: we activated a Google student offer expecting free Cloud credits, then found the credits only came with a higher tier. Instead of fighting billing at 2am, we redesigned around the free tier's rate limits, and the whole app runs at no cost.

Snowflake

Snowflake holds anonymised analytics only: hashed trip IDs, no names, no budgets and no trips with fewer than three people. It powers the "what past groups spent here per day" figure on each destination and a Streamlit dashboard. Cortex wasn't available on trial accounts, so the "why this trip fits" explanations fall back to templates, and we throw away any model reply that mentions money.

GoDaddy Registry

Our domain, wisepiggy.club, which also gave us a nice short URL for the demo.

Hackathon Experience

We attended the IKU Womxn in STEM Hackathon at King's College London's Bush House on 17–18 October 2026. It was organised by the women in STEM societies at KCL, UCL and Imperial for women and non-binary students, and it had a lovely atmosphere: welcoming to beginners, but with lots of people building seriously ambitious things.

Josie and I were a team of two, which meant we each owned big chunks of the app. That came back to bite us at 3am, when the Gemini and voice branch and the main branch had both rewritten the expenses code. We untangled the merge conflicts together, and it still worked at the demo.

Talking to the people from Wise helped shape the idea early on, and incident.io gave a brilliant presentation on their software and how they help teams handle incidents.

Thank you to Wise, incident.io, Deutsche Bank, MLH, Hackathons UK and ElevenLabs, and to all the organisers for such a great weekend. 💜

If you've ever sat through the "so what's everyone's budget?" silence, give Wise Piggy a try and tell me what you'd add!

DEV Community: Eva Stamatovska