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 CallCNC - Correct No-CallIC - Incorrect CallINC - 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 endpointsl2m_app/data.py - loads the static dataset into an in-memory SQLite databasel2m_app/templates/index.html - dashboard layout and client-side logicl2m_app/static/style.css - dashboard stylingdata/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
- Create and activate an environment (recommended).
- Install dependencies:
pip install -r requirements.txt
- Start the dashboard:
python -m l2m_app.app
- 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.13vercel.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.
