Every night, in restaurants across the country, a manager sits down with a spreadsheet. They punch in hours, cross-reference role assignments, apply weighted point values, subtract credit card processing fees, and divide what remains among a dozen employees — all while navigating a maze of state labor laws they may not fully understand.

This isn't an edge case. It's the norm. The restaurant industry — one of the largest private-sector employers — still relies heavily on manual spreadsheets to manage tip distribution and payroll compliance. The process is slow, error-prone, and opaque. Employees rarely see how their share was calculated. Managers lose hours each week to arithmetic that a computer should handle. And when labor law audits come, the paper trail is a patchwork of saved Excel files and sticky notes.

The people who feel this most acutely are small and mid-size restaurant owners who can't afford enterprise payroll systems, and their employees who depend on transparent, accurate compensation.

ProTip replaces the spreadsheet with a purpose-built platform. A restaurant owner signs up, walks through a guided onboarding flow to configure their business — defining roles with point values, setting wage rates, choosing a tip distribution model, and selecting their jurisdiction's labor rules. Within minutes, they have a working system.

Day to day, shifts are logged with clock-in/out times and role assignments. The platform instantly calculates weighted hours, applies processing fee deductions, and distributes tips according to the chosen model. Managers review and approve tip sheets before they're finalized. At week's end, a payroll summary materializes with overtime, spread-of-hours pay, and minimum wage compliance baked in — ready to export.

Employees get their own portal. They log in, see every shift, every tip breakdown, every calculation. If they work at multiple restaurants, they switch between workspaces in a dropdown. Transparency isn't a feature — it's the architecture.

ProTip is a full-stack TypeScript monorepo: a single-page application on the frontend, a RESTful API server on the backend, and a relational database underneath. A shared module sits between client and server, providing a single source of truth for the data model and validation schemas — ensuring that types flow seamlessly from database to browser.

The frontend uses a component library and utility-first CSS for rapid UI development, with a lightweight router keeping the bundle lean. Server-side state is managed through a query-caching layer with configurable staleness, eliminating redundant API calls without introducing a heavy state management library. The backend uses session-based authentication backed by the database, with modular route handlers organized by domain concern.

The system is multi-tenant by design. Every query is scoped to a company identifier, ensuring strict data isolation. Containerized deployment keeps infrastructure portable.

Not all restaurants split tips the same way. ProTip supports three distinct distribution models — and each one has its own mathematical universe.

In the pooling model, all tips flow into a shared pool and are divided by weighted hours: each employee's hours multiplied by their role's point value. A higher-point role (like a bartender at 2.0) earns twice the share per hour as a 1.0-point role. In the sharing model, tipped employees keep their tips directly but "tip out" configurable percentages to support roles. In the hybrid model, different revenue centers within the same restaurant can use different rules, with income sources routed to specific pools via configurable contribution percentages.

The engine had to be model-agnostic at the API level while deeply model-specific in calculation logic — a challenge solved through a strategy pattern that selects the correct calculation path based on company configuration.

Payroll in the restaurant industry isn't just "hours times rate." It's a layered compliance problem.

The system implements overtime calculations that go beyond the standard 1.5x-after-40 rule. For tipped employees, the overtime rate must account for tip credits: the effective overtime rate is the greater of the blended rate (weighted average across roles, times 1.5) or a minimum threshold derived from the regional minimum wage. Getting this wrong means a labor law violation.

On top of that, jurisdictions like New York require "spread of hours" pay — an extra hour at minimum wage if an employee's workday spans more than ten hours. This required detecting overnight shifts that cross midnight, splitting them at the date boundary, and computing the earliest-to-latest span per employee per day. The system also enforces minimum wage compliance as a final check: after all tips, wages, overtime, and spread pay are tallied, if total compensation still falls below the minimum wage threshold, a make-up amount is automatically calculated.

Restaurant workers frequently hold jobs at multiple establishments. ProTip models this through a many-to-many relationship between users and companies, with each association carrying its own wage rate, permission level, invitation status, and portal access flag.

This means a single employee can be an editor at one restaurant and a view-only team member at another — with completely independent permission scopes, role assignments, and pay histories. The invitation system handles both cases gracefully: if a new employee is added who already exists in the system, they're silently associated with the new company rather than creating a duplicate account.

When replacing a spreadsheet, the numbers have to match — exactly. Floating-point arithmetic in most programming languages doesn't behave like Excel's rounding. ProTip implements Excel-compatible rounding (round-half-up to two decimal places) at every aggregation level: shift, daily, weekly, and payroll period.

The system also uses integer-based cent arithmetic for critical calculations to avoid floating-point drift, and deliberately rounds at each level rather than only at the final output — matching the behavior managers expect from their existing spreadsheets.

Employee pay rates change. A server might get a raise mid-week, or switch roles between shifts. The payroll engine maintains a full rate history indexed by employee, role, and effective date range. When computing payroll for any given shift, the system resolves the rate that was in effect on that specific date — not the current rate. This prevents retroactive pay errors and creates an audit trail with timestamps, reasons, and attribution.

Monorepo over microservices. For a product with tightly coupled business logic between client validation and server calculation, a shared type system eliminates an entire class of integration bugs. The trade-off is a larger single deployment, but the team velocity gain from end-to-end type safety was decisive.

Session-based auth over tokens. For a product where users are humans on browsers — not API consumers — server-managed sessions with HTTP-only cookies provide stronger security defaults with less client-side complexity. The system supports dual password hashing formats to enable a live migration from a legacy algorithm without forcing password resets.

No global state library. Rather than reaching for a state management framework, the application relies on server cache with staleness policies for remote state, URL parameters for navigation state, and React's built-in primitives for local state. This keeps the dependency surface small and avoids the abstraction overhead that often outweighs its benefits in form-heavy applications.

Lightweight routing. A minimal client-side router was chosen over heavier alternatives. For an application with many routes but relatively simple navigation patterns, this reduced bundle size without sacrificing functionality.

Most payroll tools are built for generic businesses and bolt on tip support as an afterthought. ProTip is built from the ground up for the specific mathematics and compliance requirements of tipped employment. The weighted-hours calculation engine, multi-model tip distribution, and jurisdiction-aware payroll aren't plugins — they're the core product.

The multi-employer employee model is rare in this space. Most solutions assume one employee, one business. ProTip's architecture reflects the reality that restaurant workers often hold multiple positions, and lets them see all their compensation in one place.

Finally, the spreadsheet-compatibility commitment isn't cosmetic. By matching Excel's rounding behavior at every level, ProTip earns trust from managers who will inevitably spot-check the numbers against their old process.

Domain complexity dwarfs code complexity. The hardest parts of this system aren't architectural — they're regulatory. Understanding how New York's spread-of-hours rule interacts with overtime thresholds and tip credits required more research than any framework decision.

Precision is a feature. Users who've been doing this math by hand for years will notice if a number is off by a penny. Floating-point rounding isn't a "nice to have" — it's a trust issue.

Design for the migration, not just the destination. Supporting dual password formats, CSV imports from existing spreadsheets, and Excel-compatible math aren't technical choices — they're empathy for users who are making a leap of faith by switching tools.

The roadmap includes deeper integrations with point-of-sale and accounting systems to eliminate manual data entry, a comprehensive automated test suite to match the complexity of the calculation engine, and continued expansion of jurisdiction-specific compliance rules beyond the current state coverage.

ProTip took the most spreadsheet-dependent workflow in the restaurant industry and turned it into a real-time, compliance-aware platform — without losing a penny of precision.