Homepage
Afterglow (yearly recap)
Night Out Planner

Bunqmates

You know when you keep telling your friends, “We should eat out sometime,” but nothing ever happens because everyone gets stuck in hours of group-chat back and forth about where to go, what to eat, how much to spend, and who is actually coming?

And when you finally do agree on a plan, there is always the second problem: figuring out who paid what, splitting receipts, chasing down that one friend who still has not paid, and awkwardly deciding who should get money back.

Bunqmates makes those problems disappear.

Bunqmates is a social planning and payment module designed to live inside the bunq app. It uses AI to help groups plan nights out, collect preferences, create fair shared budgets, manage pooled payments, scan receipts, calculate refunds, and turn each night into part of a bigger social-financial story.

Everyone pools the same starting amount into a shared bunq account. The host can then use that pool to pay for the event. At the end of the night, receipts are scanned, items are assigned to the right people, and anyone who did not spend their full share can automatically receive a refund. No more messy group chats, no more awkward payment reminders, and no more “I’ll pay you back later.”

But Bunqmates goes further. It uses a data analysis agent to learn from past nights out and estimate whether someone is likely to overspend their contribution. If the app predicts that a user’s expected spending exceeds their available balance, they are blocked from joining until they top up or use a sufficient account. This makes the system more responsible, fair, and realistic.

Finally, Bunqmates includes Afterglow, a year-end social analytics experience. Afterglow turns a year of shared nights, spending patterns, cities, receipts, refunds, and friend groups into a personalized story: how much you collectively pooled, who you went out with most, your most active month, your favorite cities, your most chaotic night, and an AI-generated personality archetype that captures how you show up on a night out.

Inspiration

We built Bunqmates around a problem that almost everyone recognizes: making plans with friends sounds easy, but in practice it is full of friction.

Choosing where to go takes too long. People have different preferences, budgets, locations, diets, and schedules. Once the night actually happens, the payment side becomes even more annoying. One person pays, another forgets to send money, someone only had one drink, someone else ordered half the receipt, and the group chat slowly turns into a spreadsheet.

We wanted to build something that felt genuinely useful in real life: a tool that helps friends go from “we should do something” to “the plan is made, the money is handled, and everyone is settled fairly.”

bunq was the perfect platform for this because the idea combines social planning, pooled money, payment links, receipt-based settlement, refunds, and financial insight. We also wanted the project to feel fun, not just functional, which is why we added Afterglow as a social analytics layer.

What it does

Bunqmates helps a group of friends plan and pay for a night out from start to finish.

The organiser creates an event and invites friends. Each participant enters their preferences, such as budget, food preferences, activity interests, location, and availability. An AI consultant analyzes everyone’s preferences and generates a plan that works for the group. Using map and reservation tooling through an MCP server, the system can recommend venues and help move toward making a booking.

Once the group agrees, everyone contributes the same starting amount into a shared bunq pool. The organiser uses that pool to pay during the night. This keeps the payment flow simple: one shared pool, one organiser paying, and clear records for everyone.

After the event, the organiser uploads a receipt. The receipt is analyzed, line items are identified, and items can be assigned to the people who consumed them. The app calculates who actually spent what, compares it to each person’s contribution, and prepares refunds for anyone who did not use their full share.

Bunqmates also includes a spending-risk layer. Based on historical behavior, the data analysis agent estimates whether a participant is likely to exceed their contribution. If their expected overspend is higher than their available balance, they are prevented from joining until they top up. This helps avoid situations where someone joins an event they cannot actually afford.

The final feature is Afterglow, a year-end recap generated from the user’s nights out. It shows statistics like total pooled money, total spent, cities explored, most active month, most frequent group, favorite venues, and a playful AI-generated personality archetype.

How we built it

We built Bunqmates as a mobile-first web application with a backend that coordinates payments, planning, data analysis, and AI agents.

The frontend was built with Next.js, TypeScript, Tailwind, and a mobile-first component style. We used Claude Design to rapidly prototype interface ideas and improve the product flow. The UI focuses on making the event creation, plan review, receipt scanning, and Afterglow recap feel clear and fun.

The backend was built around FastAPI and Postgres. Postgres acts as the source of truth for users, events, participants, payments, receipts, receipt items, refunds, and Afterglow analytics. We created a dedicated data analysis agent that reads from Postgres, computes deterministic analytics, and prepares structured insights for the frontend. AI is used only after the metrics are computed, so the system does not invent amounts, friends, or events.

We integrated bunq concepts such as shared payment flows, bunq.me-style contributions, pooled event accounts, and refund logic. The goal was to make the money flow realistic and compatible with how a banking product should behave.

We used Anthropic for AI-powered planning, summarization, receipt interpretation, and playful Afterglow copy. We also used Claude Code heavily during development to move quickly, refactor components, and integrate features across the frontend and backend.

For venue recommendations and reservation logic, we explored an MCP server approach so the AI planner could work with external tools in a structured way. We also used AWS cloud services for deployment and supporting services. Toward the end of the hackathon, we ran into deployment issues on AWS, but we managed to resolve them and get the system working.

Challenges we ran into

One of the biggest challenges was scope. Bunqmates touches many areas at once: group planning, AI recommendations, payments, receipt analysis, refunds, analytics, and recap generation. Each piece is useful on its own, but making them feel like one connected product was difficult in a short time.

Another challenge was integrating AI in a way that felt trustworthy. We did not want the AI to simply make things up. For Afterglow especially, we had to be careful that all numbers and insights came from actual stored data. The AI should only turn verified metrics into fun captions and summaries.

We also had issues with AWS deployment. Some parts worked locally but needed extra configuration to run correctly in the cloud. Debugging deployment, environment variables, and service connections took longer than expected, but we managed to fix the major issues toward the end.

Receipt analysis and settlement logic were also challenging. Real receipts can be messy, and fair splitting requires clear data structures. We had to think carefully about how to represent pooled contributions, actual consumption, refunds, and personal spending patterns.

Finally, designing a product that is both practical and fun was a challenge. We wanted Bunqmates to solve a real banking problem, but also feel social and enjoyable enough that people would actually want to use it with friends.

Accomplishments that we're proud of

We are proud that the idea is genuinely applicable to real life. This is not just a fun demo; it solves a problem that many people deal with regularly. Planning nights out and splitting costs are common sources of friction, and Bunqmates gives that process a full end-to-end solution.

We are also proud of how much we were able to build in a short time. The project combines AI planning, pooled payments, receipt analysis, refund logic, spending analytics, and a year-end recap experience. Even though the scope was ambitious, we were able to connect the core pieces into one product concept.

The Afterglow feature is something we are especially excited about. It turns financial data into something emotional and shareable. Instead of showing boring spending charts, it tells a story about your social life: who you went out with, what kind of friend you are, where you spent your nights, and what patterns defined your year.

We are also proud of the technical learning curve. We used several tools and platforms that were new to us, including Claude Code, Claude Design, AWS services, MCP servers, AI agent patterns, and bunq-style payment flows.

What we learned

We learned that building with AI is not just about calling a model. The important part is designing the right system around it. For example, our data analysis agent computes actual metrics first, then AI turns those verified metrics into summaries and captions. That “metrics first, AI second” pattern made the product much more reliable.

We learned a lot about designing agent-based systems. Different agents have different jobs: planning, receipt analysis, data analytics, and summarization. Keeping those responsibilities clear helped us avoid making one giant AI blob that does everything poorly.

We also learned how important deployment and infrastructure are. A project can work locally but still fail in the cloud because of environment variables, service permissions, or deployment configuration. Debugging AWS under time pressure taught us a lot.

On the design side, we learned that the best fintech experiences are not only about transactions. Money is emotional, social, and contextual. Bunqmates works because it connects payments to the real-life moments around them.

What's next for Bunqmates

The next step for Bunqmates is making the whole experience more streamlined, with fewer steps and more fun.

We want the flow to feel almost effortless: create an event, invite friends, let AI propose a plan, pool money, enjoy the night, scan the receipt, and settle automatically. The user should not feel like they are managing a financial system. It should feel like the boring parts of planning and payment simply disappear.

We would also improve the reservation flow, add stronger real-time notifications, and make the receipt tagging experience faster and more intuitive. Another next step would be tighter bunq integration, so pooled accounts, payment requests, refunds, and spending insights feel native inside the bunq app.

For Afterglow, we would expand the analytics into a more interactive yearly experience with shareable cards, privacy controls, group recaps, and more personality archetypes. We also want users to be able to compare different friend groups, cities, and types of nights out.

Longer term, Bunqmates could become a social layer for banking: not just a way to pay friends, but a way to plan, experience, remember, and understand the financial side of your social life.