HuddleBooks - Youth Sports Financial Management Software

Most youth sports teams run tens of thousands of dollars through one volunteer treasurer, a personal bank account, and a spreadsheet nobody else can see. It works until it doesn't. Organizations lose an estimated 5% of revenue to fraud every year, and nonprofits with thin financial controls are among the most exposed, accounting for 10% of all reported fraud cases at a median loss of $76,000. HuddleBooks is the platform Modall built to close that gap: bank-synced, tamper-proof team books that every parent, treasurer, and association can see in real time. We designed and engineered the full system, from a multi-tenant data model to a conditional role-based access layer built on Next.js Parallel Routes.

Managing the finances of a youth sports team has long been an inconsistent and time-consuming task. Most teams rely on a parent volunteer to act as treasurer, often using disconnected spreadsheets and manual processes with little standardization, even within the same league.

This lack of structure creates unnecessary stress for volunteers and increases the risk of financial errors or misuse of funds. While most teams operate with integrity, limited transparency can make it difficult to properly track and manage team finances.

HuddleBooks was built to simplify and standardize financial management for youth sports teams. Teams can securely connect their bank accounts, sync transactions, categorize income and expenses, upload receipts, and manage budgets all in one place.

Every action taken on the platform is tracked and visible to parents, creating transparency and accountability while protecting the privacy of the children involved. Bank-provided transaction details are immutable, ensuring financial records remain accurate and trustworthy.

HuddleBooks also supports associations by providing oversight across multiple teams. Customizable rules and approval workflows help enforce consistent financial policies, such as requiring multiple approvers or receipts for larger transactions.

Every action taken by team administrators is recorded and timestamped within HuddleBooks. Parents can review any transaction and see exactly when it was imported, who categorized it, any receipts or supporting documents that were uploaded, and who approved the transaction.

This level of transparency is a core part of the HuddleBooks experience and helps give parents confidence in how team finances are managed. If questions or concerns arise, parents can clearly see the full history of a transaction and communicate directly through built-in comments for clarification or discussion.

Transactions in HuddleBooks cannot be manually created or altered. The connected bank account always serves as the source of truth. However, bank transactions do not always provide the full context behind how funds are being used.

For example, some vendors may prefer cash payments, leading a team to withdraw a larger amount once and distribute those funds over the course of a season. Without additional tracking, this could appear as a single large withdrawal with little visibility into how the money was actually spent.

To solve this, HuddleBooks allows transactions to be split into multiple entries while preserving the original bank transaction. Funds cannot be added or removed, but portions of a transaction can be categorized separately and supplemented with receipts, timestamps, comments, and other supporting details. This provides teams with accurate, transparent records while maintaining the integrity of the original banking data.

HuddleBooks includes a structured budgeting workflow designed to support collaboration, review, and transparency throughout the season. Budgets progress through several stages, including draft, under review, approved, and superseded, allowing teams to clearly track the status and history of their financial plans.

During the planning phase, budgets are visible only to team administrators. However, administrators can export budgets as CSV files to gather feedback or collaborate externally when needed.

Once approved, budgets become visible to parents, providing a clear breakdown of how team funds are allocated, how much has been collected, and what specific expenses player fees are contributing toward. Combined with detailed transaction tracking, this gives parents greater visibility into the team’s financial operations and helps build trust through transparency.

Throughout HuddleBooks, we chose to use popovers instead of traditional dropdown menus for workflows such as selecting categories, vendors, players, teams, and other data-heavy inputs.

Popover-based interfaces provided greater flexibility for building custom, context-aware experiences while also scaling more effectively for large datasets. Each popover includes integrated search functionality, allowing users to quickly filter and locate options instead of navigating lengthy static lists. This significantly improves usability and efficiency, particularly for administrators managing large volumes of financial data.

Popovers also enabled a more scalable approach to hierarchical data. For example, categories in HuddleBooks can contain nested subcategories. Users can begin by selecting a top-level category and progressively drill down into more specific options as needed. To optimize performance, subcategory data is loaded dynamically only after a parent category is selected, reducing unnecessary database queries and minimizing initial payload sizes.

Combined with global search capabilities across all category levels, this approach delivers an interface that remains intuitive, responsive, and performant without compromising functionality or design consistency.

Designing a scalable and maintainable Role-Based Access Control (RBAC) system can be challenging, particularly in applications where users may belong to multiple organizations with different permissions. HuddleBooks supports several distinct user types, including association members, team administrators, and parents. A single user may also hold different roles across multiple teams or associations, such as being a parent on one team while serving as a treasurer or coach on another.

Traditional RBAC implementations often lead to excessive conditional rendering and permission checks scattered throughout the application. This becomes especially difficult when different roles require unique experiences on the same page. For example, both parents and team administrators may access /transactions, but with entirely different permissions, filtering logic, and available actions. Splitting these into separate routes such as /parents/transactions and /teams/transactions can reduce some complexity, but often results in repetitive route structures and unnecessary URL nesting.

To address this, HuddleBooks leverages Next.js Parallel Routes in a non-traditional but highly effective way. While parallel routes are commonly used to render multiple views simultaneously, they also support conditional route rendering based on application state and user context.

Using route slots such as @team, @parent, and @association, alongside shared Next.js layouts, we are able to serve entirely different implementations behind the same URL structure. Two users visiting /transactions may see completely different interfaces depending on their active role, while the underlying code remains isolated into separate route trees. This architecture significantly reduces conditional logic, improves maintainability, and allows new roles or workflows to be introduced with minimal impact on existing code.

We also utilized parallel routes to power the activity feed system used throughout the application. The activity feed appears selectively across different pages and needed to function as a reusable, independently rendered UI panel. By implementing the feed as its own parallel route slot, we were able to inject it into specific layouts only where needed while keeping it isolated from unrelated pages.

This approach also allowed the activity feed to remain a React Server Component, enabling it to fetch and render its own data efficiently on the server without increasing client-side complexity.

HuddleBooks manages several deeply nested data structures, most notably transactions and categories. Because these structures can contain an unlimited number of nested levels, querying and rendering them efficiently required careful consideration.

To optimize performance, tables initially load only top-level records. Items that contain child entries can then be expanded dynamically, triggering additional data to be fetched on demand. This lazy-loading approach ensures the application only queries and renders the data that is actually needed by the user at a given time.

By avoiding unnecessary database queries and large upfront payloads, this architecture significantly improves responsiveness and scalability. It also simplifies pagination by allowing it to operate exclusively on top-level records, rather than attempting to paginate across an entire nested hierarchy.

A key consideration in HuddleBooks was balancing team-level flexibility with the need for long-term data consistency. Teams require the freedom to organize their finances in ways that work best for them, while the platform also benefits from maintaining standardized underlying data structures that support broader reporting and analysis capabilities over time.

One example of this is vendor management. Transactions can be associated with vendors to provide additional context around where money is being spent. Since teams may refer to the same vendor differently, relying solely on vendor names would lead to inconsistent data. To address this, each vendor is also associated with a website domain that acts as a stable internal identifier. This allows multiple teams to maintain their preferred naming conventions while still linking vendors behind the scenes when appropriate.

We also integrated the Logo API to automatically retrieve and display vendor logos based on their associated website, helping create a more polished and recognizable user experience.

For vendors without an existing website, HuddleBooks generates a consistent internal domain structure. For example, a vendor such as “Referee” may be internally represented as referee.huddlebooks.com. This provides a standardized way to organize vendor data even when no external identifier exists.

A similar approach was taken with budget categories. Teams can customize categories freely by adding, removing, or renaming them, but HuddleBooks also provides sport-specific category templates during setup. These templates encourage greater consistency across teams while still preserving flexibility for individual organizations.

HuddleBooks allows associations to define standardized financial compliance rules that apply across all teams within their organization. These rules are created through a custom filter builder that supports both simple and advanced conditions, enabling associations to enforce requirements around transaction amounts, receipts, vendors, categories, approval counts, and more.

Rules configured through the user interface are translated into dynamic Prisma queries, allowing transactions to be efficiently evaluated against the defined criteria.

When a transaction violates one or more rules, it is surfaced to teams as an actionable task. For example, teams can quickly identify transactions that are missing receipts, still awaiting approval, or require additional review. This creates a centralized workflow for resolving outstanding financial issues.

Associations are also provided with a high-level “team health” view that reflects how well teams are adhering to the association-defined standards. Health scores are calculated based on unresolved tasks generated from association-level rules, giving organizations a simple way to monitor financial compliance across multiple teams.

Teams can additionally create their own internal rules to support organization-specific workflows and requirements. However, team-created rules do not impact the association-level health score, allowing teams to customize their processes without affecting how they are evaluated by the association.

HuddleBooks is live and in the hands of its first founding partner association. The Mississauga Senators have put all eight of their AAA teams on the platform for the 2026-27 season. The product was founded by Mike Dunbar, a hockey parent, coach, and team finance volunteer who lived the spreadsheet problem first-hand, and our team at Modall designed and built the platform he set out to create.

You can explore the live product or watch the 2-minute demo to see the shared ledger exactly as a treasurer, board member, and parent see it.

HuddleBooks brought together several of the hardest problems in custom software: a multi-tenant data model, conditional role-based access for users who hold different roles across different organizations, bank data integrity with immutable records, a complete audit trail, and association-level compliance rules evaluated in real time. These are the same engineering problems behind regulated custom financial software and multi-tenant SaaS platforms.

Modall built HuddleBooks end to end with a 100% in-house team in Uxbridge, Ontario, on a TypeScript stack: React and Next.js on the front end, Node.js, Prisma, and PostgreSQL on the back end. No outsourcing, no offshore handoffs. The result is a platform that is fast with deeply nested data, secure with sensitive financial records, and built to grow as more teams and associations come on board.

Modall is a 100% in-house custom software team in Uxbridge, Ontario. We built HuddleBooks from the data model up, and we build financial platforms, multi-tenant SaaS products, and complex web applications for startups, enterprises, and everything in between. If you are planning a build with real data integrity and access-control requirements, get a free quote or see more of our work.