WSP | Devpost

Inspiration

Every friend group has the same problem: someone suggests a $60 dinner, someone else quietly can't afford it, and either they skip it or they go and stress about it later. Nobody wants to be the one to say "that's too expensive." We wanted an app that plans hangouts everyone can afford, without anyone having to share what they spend.

What it does

WSP plans group hangouts around the group's budget.

Sign up and link a demo bank account. WSP reads your recent spending (through Capital One's Nessie API) and works out a private comfort level: $, $$ or $$$.
Create or join a group with an invite code, then pick when you're free, what you're into, and how far you'll travel.
WSP finds plans. It finds a time that works for everyone, searches nearby places with SerpApi, filters out anything above the group's budget, and has Gemini write 3 plans with reasons.
The group votes. Each person approves or vetoes. A veto from everyone regenerates the plans.
Lock it in and split the cost. You get the final schedule and an even split. Members pay back whoever covered the bill with real Nessie transfers, and payments update on both sides.

It also includes:

Group management: owners can delete a group. Anyone can leave, but owners must transfer ownership first, and nobody can leave while they still owe money.
Profile and settings: edit your name, add or change a profile photo, and switch between light and dark mode.

The key privacy rule is that friends never see your purchases or your balance. The group only ever sees its lowest comfort level:

$$T_{\text{group}} = \min_{i \in \text{members}} T_i$$

so the plan fits the person with the tightest budget, without revealing who that is.

How we built it

Frontend: Next.js 15 (App Router), React 19 and Tailwind, designed mobile-first and tested on our phones over the same Wi-Fi.
Backend: Next.js API routes with Zod validation, bcrypt passwords and signed session cookies.
Database: Postgres on Tiger Data.
Bank data: Capital One Nessie creates a demo customer and account, seeds a realistic spending history, turns purchases into a comfort level, and handles real transfers when members pay each other back.
Places: SerpApi (Google Maps results) finds spots near the group. When a place has no price listed, we treat it as the most expensive option, so a plan never goes over budget by accident.
Plans: Gemini writes 3 plans in a fixed JSON format. It retries once, then falls back to safe mock plans so the demo never breaks.
Design: all four of us designed screens on a shared canvas. We explored a lot of color palettes and logo ideas before landing on our sage, teal and pink look and the tilted smiley.

We split the work by flow, so each person owned connected screens: onboarding and brand, groups, setup and budget, and plans and voting.

Challenges we ran into

Database switch mid-hackathon. We started on Supabase, then moved to Tiger Data. Hosted Postgres needs SSL, and Node didn't trust the provider's certificate chain at first, so we had to handle the connection setup carefully.
Keeping plans under budget. Real place data is messy, and many places have no price. We had to estimate prices from the data we did get and play it safe whenever we didn't know.
Privacy by design. Raw purchases are only ever returned to their owner, and every group screen shows only names, setup status and the lowest tier. Getting that right across every API route took discipline.
Money that matches on both sides. Making a payback show up for both the payer and the person paying, preventing double payments, and blocking people from leaving with unpaid dues meant enforcing rules in the API, not just the UI.
Nessie quirks. Linking twice could create duplicate customers, so we added guards and a probe script to check how the API actually behaves.
Four people, one codebase, one night. Lots of branches, merges and pull requests, plus agreeing on one design direction out of many options.

Accomplishments that we're proud of

A full flow that works end to end: sign up, link bank, group, setup, AI plans, vote, final plan, split and pay back.
A privacy model that's simple to explain: your friends only see the group's lowest level.
A friendly, cohesive design that feels like an app, not a hackathon prototype.

What we learned

How to design an app around privacy from the start, not bolt it on later.
Working with real sponsor APIs (Nessie, SerpApi, Gemini, Tiger Data), including building fallbacks so a demo survives a flaky network.
How to split a project so four people can build in parallel without stepping on each other.