CoSplit

Inspiration

Splitting Costco receipts with friends is surprisingly painful.

Receipts are long, some items are taxable while others are not, and the tax is usually calculated as a single total rather than broken down per item.
On top of that, shared bulk purchases make manual splitting tedious and error-prone.

Most existing split apps only allow users to enter total amounts — they don’t understand receipts, individual items, or how taxes are actually applied.

We were inspired to build something small but practical: a tool that starts by understanding the receipt itself, so splitting costs finally matches how people actually shop.

What it does

Cosplit lets users upload or photograph a receipt on mobile or desktop, then uses multimodal AI to robustly parse the receipt image into structured data.

It recognizes item names, prices, quantities, and tax-related information even when receipts are messy, abbreviated, or when taxes are not itemized per item.
Users can then assign items to people intuitively, including shared bulk purchases, and split costs fairly at the item level.

Instead of forcing users to manually calculate totals and guess how tax should be divided, Cosplit turns a receipt photo into reliable, structured data that makes splitting simple and accurate.

How we built it

We built Cosplit as a modern, full-stack web application with a strong focus on usability, robustness, and clean architecture.

The frontend is a responsive web interface built with React and Next.js, styled using Tailwind CSS and written in TypeScript.
It is designed to work seamlessly on both mobile and desktop, allowing users to quickly upload or photograph receipts and interact with the UI in an intuitive, touch-friendly way.

On the backend, we use a Node.js-based Nest.js framework to provide a well-structured RESTful API.
Application data is stored in a PostgreSQL database using Prisma as the ORM, while receipt images are saved in S3-compatible object storage (Cloudflare R2) to keep large files separate from core application data.

To ensure a smooth user experience, time-consuming operations such as receipt parsing are handled asynchronously using a job queue, so uploads and interactions remain fast and responsive.
We also integrated Sentry for error monitoring and observability, allowing us to quickly identify and fix issues during development and deployment.

At the core of Cosplit is a multimodal AI system powered by the Google Gemini API.
Instead of relying on rigid OCR pipelines, the model directly understands receipt images and robustly extracts item names, prices, quantities, and tax-related information — even when receipts are messy, abbreviated, or when taxes are not itemized per item.

To keep the system modular and extensible, the receipt understanding logic is implemented as a standalone TypeScript library.
This allows the AI-driven parsing capability to be reused independently of the web application and makes it easier to extend the system with future features.

Challenges we ran into

One of the main challenges we faced was balancing architectural completeness with the limited 36-hour timeline.

Our original plan was to build a more fully coupled frontend–backend system, with persistent storage for receipts, splits, and user state handled cleanly on the backend.
However, as development progressed, it became clear that delivering a working MVP for the pitch required making deliberate compromises.

To avoid spending most of our time building APIs and data flows, we chose to move parts of the receipt editing and splitting workflow to the frontend.
While this allowed us to demonstrate the core idea end-to-end, it also introduced known limitations — for example, some state may be lost if the app refreshes or crashes.

This trade-off raised real concerns for us, but it was a conscious decision: we prioritized showcasing the core value of item-level receipt understanding and fair splitting within the time constraints, while leaving room to improve robustness and persistence in future iterations.

Accomplishments that we're proud of

We’re proud that we built a complete, end-to-end application that solves a real problem in our everyday lives.

Before Cosplit, splitting Costco receipts usually meant relying on awkward apps that only handle totals, or falling back to incomplete scripts and manual calculations.
These approaches worked, but they were tedious, error-prone, and never felt designed for real receipts.

With Cosplit, we now have an application that we can genuinely use ourselves after shopping — one that understands receipt items, handles taxes more reasonably, and makes splitting shared purchases much easier.
More importantly, this wasn’t just a proof of concept: it’s a practical tool that replaces the workarounds we used before.

Delivering something useful within a limited time frame and turning a personal pain point into a working product is something we’re especially proud of.

What we learned

We learned that solving a small, well-defined problem effectively is often more impactful than attempting to build an overly broad system.

Working under a tight 36-hour timeline forced us to make deliberate trade-offs between architectural completeness and delivering a usable MVP.
This experience helped us better understand how to prioritize core values, accept temporary limitations, and still ship something meaningful.

From a technical perspective, we learned the importance of modular design.
By extracting the receipt understanding logic into a standalone TypeScript library, we saw firsthand how separating core AI functionality from application logic improves clarity, reusability, and long-term extensibility — even under time pressure.

We also gained valuable insight from workshops and sponsor challenges, which highlighted the kinds of problems the industry is currently focused on, such as reliability, real-world usability, and responsible use of AI.
These perspectives reinforced our decision to keep the system focused, uncertainty-aware, and grounded in a real user need rather than over-optimizing for novelty.

Overall, this project reinforced that good engineering is less about the number of tools used and more about making thoughtful decisions informed by real constraints and industry priorities.

What's next for Cosplit

The next step for Cosplit is to strengthen the foundation of the application.

We plan to improve the frontend–backend integration by moving more state and business logic to the backend, enabling better persistence, reliability, and a smoother real-world user experience.
This includes properly storing receipts, splits, and user state so the app can be used continuously rather than as a single-session tool.

Building on this foundation, we see natural extensions beyond receipt splitting.
One direction is inventory and fridge management, allowing users to track what they have purchased and reduce food waste.
Another is recipe recommendation, where users’ food preferences and past purchases can be used to suggest meals that fit their tastes and available ingredients.

As the system grows in complexity, we also see opportunities to introduce a chatbot-style, agent-driven interface to help users interact with these features more naturally.
In the longer term, aggregated and opt-in data could support services such as price-drop or discount notifications, creating shared value for the community.

All of these directions build on the same core idea: once receipts are understood and structured, smarter everyday decisions become possible.