Float-The friendly group expenses sorter

Framing the Problem

What is the problem you are trying to solve? Who does it affect?

Splitting bills with friends is awkward and tedious.

After group outings, people have to send DMs or reminders that often feel like demanding money back. This creates social friction and can even strain friendships.

Idea Explanation

What is your idea? How does it fix the problem?

Money between friends isn’t just about numbers — it’s about relationships and emotions. People want to settle expenses fairly without guilt or awkwardness.

Solution — Float 💭

Float makes bill splitting fun, visual, and emotionally light — by turning expenses into balloons.

Each friend has a personalized balloon that represents their expense balance in a group.

Your balloon floats higher when others owe you money, and sinks lower when you owe others.

The more balanced and fair your payments, the steadier your balloon floats.

Float gamifies financial interactions between friends:

🪄 XP and Rewards: Earn XP for good payment habits and generous gestures.

⏳ Friendly Nudges: Lose XP for delaying payments and get gentle, playful reminders instead of guilt-tripping messages.

🎈 Visual Engagement: The dynamic balloon interface turns a boring transaction into a shared, delightful experience.

Implementation

How do all the pieces fit together? Does your frontend make requests to your backend? Where does your database fit in.

We turned our idea into something that feels fun, social, and easy to use. Instead of making bill splitting about numbers and stress, we made it visual and rewarding.

• Balloons show everyone’s status at a glance:

  • If your balloon is green and floating high, you’re in credit.

  • If it’s blue and in the middle, you’re all balanced.

  • If it’s red and sinking, you owe money.
    This makes group expenses instantly clear without needing to read spreadsheets.

• We added a reward system to motivate quick action. Whoever pays upfront earns the most points. Friends who repay fast also get rewarded, but if someone delays too long, they lose points and their balloon deflates.

• To make it fun, we built a badge system. As your points add up, you unlock titles like Fast Payer, Generous Hero, or Finance Pro. And if you keep delaying, you get a playful penalty badge called Chronic Delayer.

• The app also sends nudges and notifications that feel like little game updates:

  • “Nice! You repaid in 2 hours — +5 points ⚡”

  • “3 days late… balloon sinking 🎈 −5 points”

• For the hackathon, we created a live demo where you can click through different repayment scenarios. The progress bar fills with stars when you gain points, balloons change colour, and badges pop up when you hit milestones.

• We focused on building a working prototype to demonstrate how our gamified expense-splitting system would feel in action. The backend logic and database rules are fully designed, but for the hackathon we hard-coded scenarios to show the key features — balloons, points, badges, and notifications in a live demo.

  How it all fits together (full design):

  • Frontend (Next.js + Tailwind): Provides the group view with balloons, badges, progress bar, and notifications.

  • Backend (Firebase Cloud Functions): Responsible for awarding points, changing balloon states, assigning badges, and sending nudges.

  • Database (Firestore): Stores user data (points, badges, balloon status), group expenses, settlements, and notifications.

  Flow:

  1. When an expense is created, the payer would earn points and debtors’ balloons sink. A nudge notification is created to encourage repayment.

  2. When a settlement is made, the system checks how fast it was done, awards or removes points, updates balloons, and unlocks badges.

  3. If a payment is overdue, scheduled checks apply penalties and send reminders.

  4. The frontend reads this data in real time from Firestore to update the UI instantly.

  Where the database fits:

  • Firestore holds all the records: users, groups, expenses, settlements, and notifications.

  • Only backend functions can update points, badges, and balloons, ensuring fairness.

  Prototype note:

  • For this hackathon, we didn’t build the full backend integration. Instead, we built a hard-coded demo with animated UI to simulate the reward system.

  • Clicking through different scenarios (+10 upfront, +5 fast repay, −5 late, etc.) shows how the system will look and behave once connected to Firebase.

This way, we don’t just track who owes what — we encourage good habits, make it light-hearted, and keep groups engaged

Challenges

What did you struggle with? How did you overcome it?

• ⏰ Time Constraint: Limited time and travel pressure — we prioritized core features and divided roles efficiently.

• 💭 Idea Clashes: Differing creative directions (like the Monopoly concept) — resolved through open discussion and team alignment.

• 🏦 Tech Limitation: No direct Starling access — overcame it by researching its API, UI, and mock interactions for realistic simulation.

Accomplishments

• Built a working prototype UI for Float with interactive balloon dynamics.

• Developed a reward system and badges that enhance motivation and user delight.

• Implemented core gamification elements that make expense splitting light and engaging.

• Strengthened teamwork, communication, and creative focus under tight deadlines.

• Realizations & Growth

  Through this process, we learned to identify our strengths -creativity, collaboration, design thinking and recognized areas to improve, like backend integration and API handling.

Next Steps

• Integrate Starling Bank’s API for live financial data and automation.

• Refine Monopoly-inspired gamification, using properties and currency metaphors for shared expenses.

• Enhance AI nudges and insights for personalized behavioural feedback using user data analysis.

• Expand the experience to include group challenges, streaks, and savings goals.