RackTracker is a specialized scoring system designed for pool tournament directors (TDs) to quickly and efficiently record match data during live tournaments. The system prioritizes speed and simplicity for data entry while capturing the essential nuances of pool matches that are valuable for reporting and player statistics. RackTracker facilitates easy export of match data to external platforms like FargoRate and Challonge, serving as a bridge between live match scoring and comprehensive tournament management.
Key Principles & Design Philosophy
Speed First: Every interaction is optimized for rapid data entry during fast-paced tournaments.
Focused Nuance: Only capture objective, high-value data points that require minimal effort.
Mobile Optimized: Primary interface designed for smartphones and tablets used by TDs at the table.
Export Ready: All data structured for easy extraction to external systems.
Offline Capable: Functions without constant internet connection in venue environments.
Data Points Captured
Essential (Every Rack)
Rack winner (Player A or Player B)
Current score/progression toward race
High-Value Events (Quick Tap)
Break and Run (BR): Player breaks and clears the table without opponent shooting
Rack Runout (RO): Player clears the table after the break (but didn't break)
Safety Exchange Winner: Simplified tracking of tactical play (optional toggle)
Key Errors (Quick Tap)
Opponent scratch on break
Opponent foul during play
Missed shot on the money ball (8, 9, or 10 depending on game)
Match Setup
Game format (8-ball, 9-ball, 10-ball)
Table size (7', 8', 9')
Race length (race to X)
Tournament name
Player information (names, IDs if available)
Scoring Interface Design
Main Match View
Header: Tournament name, match identifier, game format
Player Cards: Two prominent sections showing:
Player names
Current score
Race target
Rack Scoring Controls
Primary Actions: Two large buttons (60% of screen width each)
"[Player A Name] Wins Rack"
"[Player B Name] Wins Rack"
Quick Toggles: Small icons that can be tapped before or after recording the rack win
Break and Run (BR) icon
Rack Runout (RO) icon
Foul icon
Scratch on Break icon
Money Ball Miss icon
Control Actions:
Undo Last Rack button
Edit Match Details button
End Match button
Workflow
TD selects active match from dashboard
As each rack completes, TD taps the winner button
If special events occurred (BR, RO, Foul), TD taps the relevant icon before or after recording the win
System automatically updates score and progresses toward race completion
When race is complete, system prompts for confirmation and finalizes match
Mobile Optimization
Large touch targets (minimum 48x48px)
High contrast for visibility in varying lighting conditions
Minimal scrolling required during active scoring
Portrait orientation optimized for one-handed operation
Haptic feedback for successful actions
System Architecture Overview
Frontend
Technology: React-based SPA with offline support via service workers
Key Components:
Match Dashboard: Overview of active and completed matches
Scoring Interface: Fast data entry during matches
Player Profiles: Stats and history view
Export Center: Data extraction tools
Backend
API Layer: RESTful endpoints for data processing
Authentication: Simple user management for TDs
Business Logic: Match progression, statistics calculation
Sync Management: Handles offline data reconciliation
Database
Core Tables:
Users (Tournament Directors)
Players
Tournaments
Matches
Racks (with associated events)
Statistics (calculated from rack data)
Player Profiles
Win/Loss record
Performance metrics:
Break and Runs per 100 games
Rack Runouts per 100 games
Foul differential (opponent fouls minus player fouls)
Money ball conversion rate
Optional Internal Rating
Simple Elo-based system using match outcomes
Performance adjustments based on captured nuance (BR/RO rates)
Not intended to replace FargoRate but to provide internal seeding options
Reporting & Data Export
Export Formats
CSV: Tabular data for spreadsheet import
Match results summary
Detailed rack-by-rack breakdown
Player statistics
JSON: Structured data for programmatic use
Complete match data
Tournament summaries
Player profiles
Match Summaries
Copyable text format for quick sharing
PDF generation for official records
QR code linking to online match record
Potential Integrations
FargoRate: Export match results in compatible format
Investigation needed for direct API integration
Fallback to formatted export for manual entry
Challonge: Update bracket progress
Explore API options for automatic updates
Provide formatted data for manual entry
Real-time Sharing
Public view-only match tracker for spectators
Embeddable live score widgets for tournament websites
Implementation Considerations
Phased Approach
Core Functionality (MVP):
User management
Match setup and basic scoring
Simple export options
Enhanced Scoring:
Add BR/RO tracking
Implement foul tracking
Develop basic player profiles
Reporting Expansion:
Comprehensive export options
Integration research and development
Advanced statistics
Advanced Features:
Offline mode with sync
Public sharing options
Tournament management tools
Feedback Integration
Early testing with tournament directors
Usability sessions focused on scoring speed
Data collection on most used features
Continuous refinement of the interface based on real-world use
Performance Metrics
Time per rack entry (target: <3 seconds)
Match setup time (target: <30 seconds)
Export completion time (target: <10 seconds)
Sync reliability after offline use (target: 100%)
Technical Implementation
The system will be built using:
TypeScript for type safety
React for the frontend interface
SQLite for data storage
RESTful API for data access
Service workers for offline capability
Conclusion
RackTracker is designed with a singular focus: to make the TD's job easier during tournaments while capturing valuable match data. By prioritizing speed and simplicity in the interface while ensuring comprehensive data export capabilities, the system bridges the gap between efficient tournament operation and detailed match reporting for external platforms.