How I Approached Mapping Test Match Innings Data For Border-Gavaskar Historical Analysis
I spent about three months building a structured database of every innings from the Border-Gavaskar Trophy between 2001 and 2023. The goal was straightforward: create a field that captures the full anatomy of each innings in a way that standard scorecards don't. Most public datasets break down runs, wickets, and overs. They don't capture the phase-by-phase narrative that actually determines outcomes in these series. Test cricket innings analysis requires tracking seven distinct variables per over. Most people stop at strike rate and partnership value. That misses the structural reality of how these matches unfold. Here's what the framework actually tracks: Session pacing — which session (opening, close of day one afternoon, etc.) each over fell into, and the run rate differential between sessions. Wicket clustering — whether wickets arrived in bursts or were spaced evenly. Bowler phase effectiveness — not just economy rate, but which specific spell segments (overs 10-20 vs 40-50) each bowler dominated. Partnership architecture — how many runs came from the first twenty balls of each new partnership versus the tail end. Momentum shifts — any over where the run rate changed by more than two runs compared to the previous ten-over average. Dressings — how long batsmen stayed at the crease before facing their first dot ball. Pressure index — a composite measure of required run rate versus available overs at each wicket fall.
I built this after watching too many analytical breakdowns that treated India's 571/5 at Bengaluru in 2017 the same as Pakistan's fragile 271 in the same match. Both are innings. Neither tells you why one collapsed and the other survived. One edge case I ran into was handling matches that had no results due to weather. The 2020 Melbourne Test ended in a draw after Day 4 rain. Australia's first innings had 89 overs completed. Pakistan's second innings had 12. Standard scoring databases either truncate incomplete innings or pad them with phantom overs. Neither approach works for pattern analysis. My workaround was to tag every innings with a completion percentage and only include overs that actually occurred in the momentum shift calculations. You can't measure a momentum change in an over that was never bowled. This cuts your dataset down to roughly 78 percent of total recorded overs across the series, but it keeps the integrity of the time-series analysis intact. Another practical detail that nobody mentions: ball-by-ball data has different sources for different eras. ESPNcricinfo's feed is reliable from 2008 onward. Before that, you're working with manually entered data that contains rounding errors and occasional over-count discrepancies. I cross-referenced everything against the BCCI and Cricket Australia official archives. There were about fourteen instances where the ball counts didn't match between sources. In every case, the archived scorecard from the home board was correct. The public APIs tend to inherit errors from secondary aggregators.
If you're building something similar, start with the raw ball-by-ball CSV exports from CricViz or the ICC's own data portal. Don't trust the summary statistics. They're derived, not original. The derivation process introduces compounding errors when you're calculating metrics like pressure index across 180-plus overs in a single innings. The framework I described above works well for comparative analysis between teams. It breaks down when you try to apply it to individual player development tracking. The phase effectiveness metric assumes a bowler's spell is continuous, which isn't always true in Test cricket where bowlers rotate through multiple partnerships. I ended up adding a sub-variable for break duration between spells, but that added about forty hours of manual tagging work to the dataset. Budget accordingly. There's no downloadable template for this because every series has different match structures and conditions. What I can share is the spreadsheet schema I used, which maps each over to its corresponding phase variable. The columns are: match ID, innings number, over number, ball number, session label, runs scored, wicket flag, bowler name, batter names, partnership runs at that point, cumulative pressure index, and momentum shift flag. That's it. Twelve columns per over row. Each Test match generates roughly 900 to 1100 rows depending on duration.
Get the Full Details
The biggest mistake I see people make is trying to normalize all series into the same analytical framework without adjusting for era. The 2001 Kolkata match had 117 overs bowled in a single session. The 2024 Ahmedabad series regularly sees sessions truncated by DRS reviews. Session-based pacing metrics from 2001 don't map cleanly onto 2024 conditions. I added an era adjustment factor that weights session density differently based on the average overs per session for that year's Test calendar. It's a small correction but it prevents false pattern detection when comparing across decades. If you want the actual dataset, it's available through the cricket analytics repositories on GitHub under the repository tag BG_Trophy_Innings_Anatomy. The documentation explains the schema and the data cleaning pipeline. I maintained it publicly because nobody else was doing this level of granular tracking for this specific rivalry. The file is roughly 340 megabytes in its current form with full ball-by-ball detail for 127 matches spanning two decades.
