Split-Bill-Application

Split Bill App — Case Study

Project Overview

Split Bill is a collaborative expense-management application designed to make sharing expenses among friends, roommates, and groups simple, transparent, and organized. Managing shared expenses can quickly become confusing when multiple people pay for different things, balances change frequently, and settlements need to be tracked. The goal of this project was to build a reliable solution that simplifies this process through a cross-platform mobile application backed by a structured backend system.

The application allows users to manage groups, record shared expenses, split costs, track individual balances, and manage settlements. By bringing these features together, Split Bill aims to reduce the friction of managing shared finances and make it easier for everyone to understand who paid, who owes money, and how expenses are distributed.

The Problem

When people share expenses, they often rely on manual calculations, chat messages, spreadsheets, or separate payment records. These approaches can lead to incorrect calculations, forgotten payments, duplicated entries, and disagreements about outstanding balances.

Split Bill addresses these challenges by centralizing expense records and group financial information in one place. Instead of manually calculating every contribution, users can rely on a consistent system to record expenses, calculate shares, and track settlements.

The Solution

The project combines a Flutter-based mobile application with a dedicated backend API. The mobile client provides the user-facing experience, while the backend manages business logic, authentication, data validation, persistence, and financial records.

Key functionality includes:

• Group management: Create groups and manage their members for shared expenses.
• Expense tracking: Record expenses and associate them with the appropriate group.
• Bill splitting: Represent expense shares so each member's contribution can be tracked.
• Balance management: View group balances and understand outstanding amounts.
• Settlement tracking: Record payments between members and maintain settlement history.
• Activity tracking: Maintain a history of important group and expense-related events.
• Authentication and account management: Support secure access to user accounts and protected API operations.

Technical Architecture

One of the central goals was to build more than a basic mobile interface. The project also involved developing a structured backend capable of handling relationships between users, groups, expenses, splits, and settlements.

The architecture separates responsibilities across the application:

• Flutter and Dart power the cross-platform mobile client.
• Node.js, Express.js, and TypeScript provide the backend API and application logic.
• PostgreSQL stores persistent application data and relationships.
• Prisma ORM provides type-safe database access and schema management.
• Zod supports request validation and helps enforce API input contracts.
• Redis supports caching and other infrastructure needs where applicable.
• JWT-based authentication and refresh tokens support session and access-token management.

The backend follows a layered structure that separates routes, middleware, controllers, services, and database access. This makes responsibilities easier to understand, supports testing, and helps keep business logic separate from HTTP request handling and persistence.

Data Integrity and Financial Operations

Expense-management software requires particular care around data consistency. A recorded expense, its individual splits, and the resulting balances must remain consistent with one another.

PostgreSQL provides the relational foundation for these records, while Prisma supports structured database operations. Transactions and database constraints help protect related operations from leaving inconsistent data behind. Settlement handling and idempotency are also important considerations when preventing repeated requests from accidentally recording the same financial operation more than once.

The project emphasizes reliable data handling, explicit validation, and consistent API behavior rather than relying exclusively on frontend calculations or assumptions.

Testing and Quality Assurance

Another important part of the project is backend reliability. A feature may work during a manual demonstration but still fail under invalid input, database constraints, repeated requests, or unexpected service conditions.

The development workflow incorporates TypeScript, ESLint, automated tests with Vitest, and API testing with Supertest. PostgreSQL and Redis integration tests help verify behavior against real services, while GitHub Actions supports automated validation during development.

The project also considers API error handling, authentication and authorization, environment configuration, health checks, logging, and security practices. These elements help move the application beyond a prototype toward a more maintainable and deployment-ready system.

Engineering Challenges and Learning

A significant part of the work involved coordinating the mobile client with a separately developed backend. This requires consistent API contracts, compatible data models, appropriate error handling, and careful management of authentication and configuration.

Database relationships and financial operations introduced another layer of complexity. Rather than treating expenses as isolated records, the system needs to account for group membership, individual shares, settlements, and the relationships connecting them.

Working with PostgreSQL and Redis integration testing also highlights the difference between unit testing isolated logic and verifying how components behave together. Automated CI checks help identify regressions earlier and make changes easier to review.

The project has provided practical experience with backend architecture, relational database design, API development, authentication, integration testing, and collaborative software development.

Development Workflow and Collaboration

Split Bill is developed as a collaborative project, with attention to clear code organization, incremental changes, Git-based version control, and reviewable contributions. Backend changes are developed and validated in focused steps, with automated checks used to help maintain quality as the codebase evolves.

This workflow reinforces an important engineering principle: building a feature is only part of the job. The implementation must also integrate with existing functionality, preserve data integrity, be testable, and remain understandable to other developers.

Future Improvements

Potential future improvements include expanding automated end-to-end coverage, strengthening production monitoring, improving expense and settlement reporting, optimizing performance as group activity grows, and refining the mobile experience based on user feedback.

Additional attention to accessibility, offline behavior, and clearer financial summaries could also make the application more useful in everyday situations.

Conclusion

Split Bill represents an effort to solve a familiar real-world problem through a practical combination of mobile development, backend engineering, and database design. It brings shared expense tracking, group balances, and settlement management into one application while emphasizing maintainability, validation, security, and reliable data handling.

Beyond the product itself, the project demonstrates hands-on experience building and integrating a cross-platform client with a structured backend, working with relational and caching infrastructure, and using automated testing and CI practices to improve software quality.