L2M Dashboard

This project analyzes the NBA Last Two Minute (L2M) Report through an interactive Flask dashboard.

The L2M report is the league's transparency initiative for officiating decisions in the final two minutes of close games (fourth quarter and overtime). This app turns that raw report data into a decision-quality dashboard focused on trends, call types, teams, and players.

The broader goal is aligned with the literature review direction: use L2M data to investigate officiating quality, call recognition, and potential patterns in high-leverage moments.

Decision taxonomy

Each event is classified into one of four outcomes:

• CC - Correct Call
• CNC - Correct No-Call
• IC - Incorrect Call
• INC - Incorrect No-Call

Two key metrics are used throughout the dashboard:

• Accuracy = CC / (CC + IC)
• Recognition = CC / (CC + INC)

Important attributes

The source dataset includes rich context. The dashboard currently relies most on the fields below:

• Game context: gid, date, season, playoff, home, away, home_score, away_score
• Decision context: call, type2 (normalized type), decision, comments
• People context: committing, committing_team, disadvantaged_team
• Scope/context extras: period/time and other metadata can support future extensions

Current data scale from the project research notes:

• approximately 64 columns
• approximately 90k rows

Dashboard views

The UI is organized into tabs with filterable views (season, stage, team, call, and min sample):

• Call Types
  • Groups by call category and normalized type
  • Shows CC, IC, INC, plus accuracy and recognition
  • Uses a minimum sample threshold for stability
• Season Trends
  • Line chart for accuracy and recognition by season
  • Stacked volume chart for CC, CNC, IC, INC
• Team Errors
  • Net error balance by team (benefited vs disadvantaged)
  • Includes detailed table: against/favor split and net balance
• Recent Games
  • Most recent games with per-game decision totals
• Players
  • Players most frequently involved in IC and INC events

Project structure

• l2m_app/app.py - Flask app and API endpoints
• l2m_app/data.py - loads the static dataset into an in-memory SQLite database
• l2m_app/templates/index.html - dashboard layout and client-side logic
• l2m_app/static/style.css - dashboard styling
• data/l2m_slim.csv.gz - the dataset the app runs on (committed, ~0.7 MB)
• data/L2M_stats_nba.csv - archival full export, 64 columns (not used at runtime)

Run locally

1. Create and activate an environment (recommended).
2. Install dependencies: pip install -r requirements.txt
3. Start the dashboard: python -m l2m_app.app
4. Open http://127.0.0.1:5000

Set L2M_DEBUG=1 to enable the Flask debug reloader. It is off by default.

How it works

This is a static dashboard. There is no ETL, no scheduled job, and nothing to operate: the app ships one data file and reads it.

On startup, l2m_app/data.py decompresses data/l2m_slim.csv.gz and loads it into an in-memory SQLite database, adding indexes on season, decision, committing_team, disadvantaged_team, and (call, type2). Flask then serves JSON endpoints backed by ordinary SQL:

• /api/meta
• /api/call-types
• /api/decision-breakdown
• /api/season-trends
• /api/team-errors
• /api/recent-games
• /api/top-players

The front-end fetches these and re-renders tables and charts whenever filters change.

Loading takes well under a second and happens once per process, so it is paid on cold start and never again. This is what lets the app run on a read-only, serverless filesystem while keeping every query in SQL.

Each thread gets its own connection onto that one shared in-memory database. A single connection shared across threads returns corrupted results under the parallel fetches the dashboard issues on load.

Regenerating the dataset

data/l2m_slim.csv.gz is a snapshot. To rebuild it, select these 15 columns -- the only ones any endpoint reads -- from the l2m table of the full dataset, ordered by rowid, and write them as UTF-8 CSV compressed with gzip:

gid, date, season, playoff, home, away, home_score, away_score,
call, type2, decision, committing, committing_team, disadvantaged_team, game_details

Every column is TEXT. Keep it that way when reloading: gid values such as 0021400883 lose their leading zeros under a numeric type affinity.

Deployment

Deployed on Vercel, which detects Flask from pyproject.toml and runs it as a serverless function. Relevant configuration:

• pyproject.toml - dependencies, and tool.vercel.entrypoint pointing at l2m_app.app:app
• .python-version - pins Python 3.13
• vercel.json / .vercelignore - keep the archival CSV and local database out of the bundle

Deploying means pushing to the connected Git branch. Refreshing the data means regenerating data/l2m_slim.csv.gz and committing it -- the dataset is baked into each deployment.

Notes and limitations

• L2M only covers a narrow game window (final two minutes of close games), not full-game officiating.
• Findings should be interpreted as high-leverage-situation evidence, not universal refereeing conclusions.
• This project is strongest for directional insights, trend analysis, and exploratory investigation.