This is a submission for the MLH x DEV Writing Challenge
What if planning a trip with friends didn't require everyone to reveal how much money they have?
That's the question behind Wise Piggy, the project we built for the IKU Womxn in STEM Hackathon 2026, competing in the Wise Max Ease track.
Our goal wasn't simply to build another travel planner. We wanted to solve something much more human: the awkward conversations, endless calculations, and coordination headaches that happen when friends want to travel together but have different budgets, currencies, and schedules.
Here's how we approached that problem, the technology we used, and what we learned while bringing the idea to life.
What We Built
The problem: Group trips are harder than they look
Planning a trip with friends sounds simple until the actual planning in the group chat starts.
One person is checking flight prices.
Another is trying to work out accommodation costs.
Someone has a strict budget but doesn't feel comfortable saying so.
Everyone has different dates, departure cities, and expectations about how much the trip should cost.
Suddenly, planning a holiday becomes a negotiation.
We wanted to make that experience easier without forcing anyone to disclose their personal finances.
Wise Piggy is a privacy-first group travel planner that helps friends find trips that work for everyone, without exposing individual budgets.
Instead of asking the group to agree on one budget, each person enters their own limits privately. The application evaluates the group's constraints and presents options that fit everyone without revealing whose budget determined the outcome.
The principle is simple: the group should see what works for everyone based on the feasible options, not everyone's private financial information.
How Wise Piggy works
The application brings several parts of the travel experience together.
1. Plan privately, decide together
Members enter their availability, home currency, flight budget, shared-cost limits, and daily spending allowance. The backend compares these constraints and calculates feasible options for the group.
If an option doesn't work, the application can return a neutral no-match result rather than revealing which person's financial limit excluded it.
2. Compare expenses across currencies
Friends departing from different cities don't necessarily face the same prices. Wise Piggy uses flight prices lookups and real time currency calculations to help compare options against each member's limits.
3. Make group decisions easier
Anonymous voting helps the group choose without exposing individual votes. The aim is to make collaboration easier while keeping personal preferences private.
4. Turn receipts and voice notes into expenses
After the trip starts, nobody wants to spend their evening manually entering every receipt or paying back their friends individually.
Wise Piggy uses Google Gemini to extract structured information from receipt images and interpret voice expense entries. ElevenLabs supports speech transcription and spoken confirmation.
Users can review and confirm extracted information before saving it, and the application code then handles the actual expense calculations and allocations.
5. Make settling up less painful
The application tracks expenses, calculates balances, and proposes a settlement plan intended to reduce the number of transfers. It also supports currency-aware settlement calculations and a Wise payment hand-off using the Wise Open API sandbox environment.
The result is a workflow that connects planning, spending, and settling up instead of leaving the group to coordinate everything across separate tools.
The technology behind it
We used a full-stack architecture because the product needed more than a convincing interface. Private budgets, shared decisions, expenses, and currency calculations require actual backend logic and persistent data.
Our stack includes:
- React for the frontend.
- Node.js and Express for the backend and application logic.
- PostgreSQL for users, trips, budgets, expenses, splits, and settlements.
- Google Gemini API for receipt extraction and natural-language expense parsing.
- ElevenLabs for speech-to-text and text-to-speech.
- SerpApi for flight lookups on Google Flights.
- Wise Open API for exchange-rate support and payment hand-off.
- Snowflake and Cortex API for aggregate spending insights and analytics.
- Vultr for deployment on the GoDaddy domain.
One of our most important architectural decisions was keeping AI-generated suggestions separate from financial calculations. AI can help interpret an image or a sentence, but deterministic application code should validate the data and calculate the money.
That distinction matters when a small parsing or rounding error could affect what someone owes a friend.
What building it taught us
One of the biggest lessons was that the hardest part of building a useful application isn't always adding more features, but it's making all the parts work together reliably.
External APIs have limits: currency conversions introduce edge cases, AI-generated output needs validation, and a fallback that keeps a workflow running must not be mistaken for live data.
We designed fallback paths for several integrations so that the core experience could remain usable when a provider was unavailable. We also used integer minor units for money calculations and proportional allocation logic to help keep expense splits accurate.
We also had to make scope decisions. Some ideas, including automated re-planning and richer itinerary and accommodation search, remain future work. Being clear about what we built and what we didn't in 24 hours was part of making the project more coherent.
Most importantly, the project reinforced that privacy isn't just a setting you add to an interface: it needs to shape what the backend calculates, what the API returns, and what other members are allowed to see.
Demo
See Wise Piggy in action:
- Live application: https://wisepiggy.club
- Source code: https://github.com/josie-collins/iku-hackathon
Hackathon Experience
We built Wise Piggy at the IKU Womxn in STEM Hackathon 2026, choosing the Wise track and its focus on making everyday experiences easier.
The experience pushed us to think beyond the question, "Can we build this feature?" and ask, "Does this actually remove effort for someone using it?"
That changed how we approached the project: rather than treating AI as the main attraction, we focused on the complete user journey: keeping budgets private, coordinating a decision, tracking expenses, and simplifying settlement.
The most valuable part of the process was learning to connect a product idea to the engineering decisions required to make it useful.
As a team of just two, we set out to build Wise Piggy as a complete experience rather than a collection of disconnected features. We wanted users to be able to plan a trip with private budgets, compare options, coordinate decisions, track expenses, and simplify settlement.
The scope was ambitious, especially given the number of external APIs we needed to integrate. We worked hard throughout development to connect those services and bring our planned features together into one application. Every integration introduced new challenges, from handling inconsistent responses to planning for rate limits and service failures.
The experience pushed us to balance ambition with practical engineering. We had to keep asking ourselves whether a feature was genuinely useful, how it would interact with the rest of the system, and what would happen if one of its dependencies failed.
What made the experience meaningful was seeing how much we could accomplish by dividing responsibilities, working through technical challenges, and staying focused on the product we wanted to deliver.
Two people, an ambitious scope, and a lot of integrations later, Wise Piggy became our attempt to make group travel less stressful and more inclusive.
We came away with a deeper appreciation for the work behind a reliable full-stack application and for how much thoughtful engineering happens beyond the features users see on the screen.
What's Next?
Wise Piggy is a starting point, not a finished travel platform.
Next, we'd like to improve the reliability of live data integrations, expand trip and itinerary discovery, strengthen automated testing, and make the planning experience even more seamless.
We also want to keep exploring a question that goes beyond travel: how can technology help people coordinate shared decisions without requiring them to disclose more personal information than necessary?
For us, that's the real idea behind Wise Piggy.
Make the decision together. Keep the personal details private. Spend less time coordinating, and more time enjoying the trip.
If you're interested in privacy-first product design, practical AI integrations, or building useful tools under hackathon constraints, I'd love to hear what you think.
