Querying the season

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  player_name,
  team,
  SUM(points) AS points,
  SUM(kills) AS kills,
  SUM(attack_attempts) AS attempts,
  SAFE_DIVIDE(SUM(kills), SUM(attack_attempts)) AS kill_pct,
  COUNT(DISTINCT schedule_event_id) AS matches
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY points DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders

Mimi Colyer of Dallas Pulse led the league with 516 points on 455 kills across 28 matches. Her teammate Diaz Maldonado finished second, meaning the league’s two most productive hitters played for the same team all season, a preview of who’d end up cutting down the net in May.

The top ten, by points

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["points"][::-1], color="#2c3e50")
ax.set_xlabel("Points")
ax.set_title("Top 10 Scorers, 2025-26 MLV Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

Digs, aces, and assists

digs_query = """
SELECT player_name, team, SUM(digs) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

assists_query = """
SELECT player_name, team, SUM(assists) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
assists_leader = client.query(assists_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(service_aces) AS total
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE team NOT IN ('Team Launiere', 'Team Meske')
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

Shara Venegas (San Diego Mojo) led all players in digs with 320. Marlie Monserez (San Diego Mojo) ran the offense from the back row, topping the league with 1067 assists. And Natalie Foster (Orlando Valkyries) led in aces.

The best record didn’t win it either

standings_query = """
WITH regular_season AS (
  SELECT * FROM `maydaystats.mlv_volleyball.matches`
  WHERE schedule_event_id NOT IN (637, 638, 639)
),
team_results AS (
  SELECT first_team_name AS team,
    IF(first_team_score > second_team_score, 1, 0) AS win
  FROM regular_season
  UNION ALL
  SELECT second_team_name AS team,
    IF(second_team_score > first_team_score, 1, 0) AS win
  FROM regular_season
)
SELECT team, SUM(win) AS wins, COUNT(*) - SUM(win) AS losses
FROM team_results
GROUP BY team
ORDER BY wins DESC
LIMIT 5
"""

standings = client.query(standings_query).to_dataframe()
standings

Indy Ignite had the best regular-season record in the league at 20-5, good enough for the No. 1 seed in a four-team playoff. It didn’t matter: the No. 4 seed knocked them out in the semifinal, the same shape as this site’s NHL year in review, where Colorado had the league’s best regular season and still lost in the Western Conference Final. The best regular season and the tournament that actually decides the title are two different contests.

The playoffs

import re

playoff_query = """
SELECT schedule_event_id, game_date, first_team_name, first_team_score,
  second_team_name, second_team_score
FROM `maydaystats.mlv_volleyball.matches`
WHERE schedule_event_id IN (637, 638, 639)
ORDER BY game_date
"""
playoffs = client.query(playoff_query).to_dataframe()

# Playoff schedule-events carry a seed prefix in the raw team name
# ("No. 4 Omaha Supernovas") that the regular-season rows don't - strip
# it for display, same cleanup the pipeline itself does before matching
# team names against the PDF text (see fetch.py's _strip_seed).
seed_re = re.compile(r"^No\.\s*\d+\s+")
for col in ("first_team_name", "second_team_name"):
    playoffs[col] = playoffs[col].str.replace(seed_re, "", regex=True)

playoffs

Four teams made the playoffs, seeded 1 through 4 on regular-season record, in a single-elimination bracket: 1-seed vs. 4-seed, 2-seed vs. 3-seed, winners meet in the final. The No. 4 seed Omaha Supernovas beat the No. 1 seed Indy Ignite 3-2 in the semifinal, while the No. 2 seed Dallas Pulse handled the No. 3 seed San Diego Mojo in four sets to reach the final.

semifinal_query = """
SELECT team, SUM(kills) AS kills, SUM(attack_attempts) AS attempts,
  SUM(service_errors) AS service_errors,
  SUM(reception_errors) AS reception_errors, SUM(total_blocks) AS blocks
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE schedule_event_id = 637
GROUP BY team
"""
semifinal_team_totals = client.query(semifinal_query).to_dataframe()
semifinal_team_totals

semifinal_players_query = """
SELECT player_name, team, kills, attack_attempts, total_blocks
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE schedule_event_id = 637
  AND player_name IN ('Leketor Member-Meneh', 'Janice Leao')
"""
semifinal_players = client.query(semifinal_players_query).to_dataframe()
semifinal_players

final_query = """
SELECT player_name, team, kills, points, digs, total_blocks
FROM `maydaystats.mlv_volleyball.boxscores`
WHERE schedule_event_id = 639
ORDER BY points DESC
LIMIT 5
"""
final_box = client.query(final_query).to_dataframe()
final_box

What’s next

This covers the season at a high level: the league leaderboards, the regular-season standings, and the playoff bracket itself. The same table supports much narrower questions too, like a single hitter’s efficiency swings across the two scoresheet eras, or how a team’s block numbers held up on the road. Those are posts for another day, now that a full season of validated data is sitting in BigQuery.

The pipeline code behind this post lives here.

Querying the pipeline’s output

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  pitch_type,
  COUNT(*) AS n_pitches,
  AVG(release_speed) AS avg_release_speed,
  AVG(release_spin_rate) AS avg_spin_rate
FROM `maydaystats.mlb_statcast.pitches`
WHERE pitch_type IS NOT NULL
GROUP BY pitch_type
ORDER BY n_pitches DESC
"""

df = client.query(query).to_dataframe()
df

As of this post, the table holds 4795 pitches across 13 distinct pitch types.

Average release speed by pitch type

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(df["pitch_type"], df["avg_release_speed"], color="#2c3e50")
ax.set_xlabel("Pitch type")
ax.set_ylabel("Average release speed (mph)")
ax.set_title("Average Release Speed by Pitch Type")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

What this confirms, and what’s next

Every number and every bar above came from a live query against mlb_statcast.pitches, which itself only exists because a Cloud Scheduler job triggers a Cloud Run Job every morning that pulls the previous day’s Statcast data. As more days accumulate, this same query pattern (and others like it) becomes the basis for real analysis rather than pipeline validation.

The pipeline code behind this post lives here.

Querying the season

from google.cloud import bigquery

client = bigquery.Client()

query = """
SELECT
  player_name,
  team,
  SUM(goals) AS goals,
  SUM(assists) AS assists,
  SUM(points) AS points,
  COUNT(DISTINCT game_id) AS games_played
FROM `maydaystats.nhl_stats.boxscores`
WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) IN (2, 3)
  AND position_group != 'goalie'
GROUP BY player_name, team
ORDER BY points DESC
LIMIT 10
"""

scorers = client.query(query).to_dataframe()
scorers

N. MacKinnon led the league with 150 points (64 goals, 86 assists) across 93 games, including the playoffs. Connor McDavid finished a close second, and Colorado and Vegas each placed two players in the top ten scorers, more than any other team.

The top ten, by points

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = scorers["player_name"] + " (" + scorers["team"] + ")"
ax.barh(labels[::-1], scorers["points"][::-1], color="#2c3e50")
ax.set_xlabel("Points")
ax.set_title("Top 10 Scorers, 2025-26 Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

The best record didn’t win the Cup

standings_query = """
SELECT
  team,
  COUNTIF(decision = 'W') AS wins,
  COUNTIF(decision = 'L') AS losses
FROM `maydaystats.nhl_stats.boxscores`
WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) = 2
  AND position_group = 'goalie'
  AND decision IS NOT NULL
GROUP BY team
ORDER BY wins DESC
LIMIT 5
"""

standings = client.query(standings_query).to_dataframe()
standings

Colorado had the best regular-season record in the league at 58-16, built in part on Nathan MacKinnon’s scoring, and Carolina wasn’t far behind. But the regular season and the playoffs are different tournaments. Colorado swept the Kings in the first round and beat Minnesota 4 games to 1 in the second, then ran into Vegas in the Western Conference Final and lost in a sweep of their own. Carolina kept going all the way to the Stanley Cup Final, where they met that same Vegas team.

What actually happened to Colorado

col_series_query = """
SELECT game_id, team, SUM(goals) AS goals
FROM `maydaystats.nhl_stats.boxscores`
WHERE game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
GROUP BY game_id, team
ORDER BY game_id, team
"""
col_series = client.query(col_series_query).to_dataframe()
col_series

Four games, four Vegas wins: 4-2, 3-1, 5-3, 2-1. It wasn’t a case of Colorado getting run off the ice, three of the four games were decided by a single goal or two, but a sweep is a sweep, and the box scores point at two specific reasons rather than a generic cold streak.

goalie_query = """
SELECT game_id, team, player_name, save_pctg
FROM `maydaystats.nhl_stats.boxscores`
WHERE game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
  AND position_group = 'goalie'
  AND save_pctg IS NOT NULL
ORDER BY game_id, team
"""
goalies = client.query(goalie_query).to_dataframe()
goalies

Vegas starter Cam Hart never had a bad night: a .947 save percentage in Game 1, .968 in Game 2, .914 in Game 3, .952 in Game 4, four consecutive starts above his own regular-season form. Colorado’s own goaltending was more uneven than collapsed: Scott Wedgewood started the first three games and posted a .908 save percentage across the regular season, but ranged from .889 to .917 to .818 in this series, a rough Game 3 more than a full collapse. Mackenzie Blackwood took over for Game 4 and actually outplayed his own .894 season average, stopping .923. Colorado’s goaltending wasn’t the story on its own. Vegas’s goalie having the series of his season was.

mackinnon_query = """
SELECT COUNT(DISTINCT game_id) AS games, SUM(goals) AS goals,
  SUM(assists) AS assists, SUM(points) AS points
FROM `maydaystats.nhl_stats.boxscores`
WHERE player_name = 'N. MacKinnon' AND team = 'COL'
  AND game_id IN (2025030321, 2025030322, 2025030323, 2025030324)
"""
mackinnon_series = client.query(mackinnon_query).to_dataframe()
mackinnon_series

The bigger story is Nathan MacKinnon, the same player whose scoring this post already credited with carrying Colorado’s regular season. Across 80 regular-season games he scored 57 goals, a .71-goal-per-game pace. Across the four-game sweep against Vegas he scored 0. Zero. Two assists, two total points, in the series that ended his team’s season. Gabriel Landeskog led the team in goals with 3, and tied Nazem Kadri and Devon Toews for the team lead in points at 3 apiece, but a team built around its best player suddenly not scoring, against a goalie who was outplaying his own season averages every single night, is a specific, findable reason a 58-win team went home in May rather than a vague “playoffs are different” shrug.

final_query = """
WITH final_games AS (
  SELECT game_id, game_date, team, SUM(goals) AS team_goals
  FROM `maydaystats.nhl_stats.boxscores`
  WHERE CAST(SUBSTR(CAST(game_id AS STRING), 5, 2) AS INT64) = 3
    AND team IN ('CAR', 'VGK')
  GROUP BY game_id, game_date, team
)
SELECT
  game_date,
  MAX(IF(team = 'CAR', team_goals, NULL)) AS car_goals,
  MAX(IF(team = 'VGK', team_goals, NULL)) AS vgk_goals
FROM final_games
GROUP BY game_date
HAVING car_goals IS NOT NULL AND vgk_goals IS NOT NULL
ORDER BY game_date
"""

final = client.query(final_query).to_dataframe()
final

The Final went six games, and three of them (Games 1 through 3) were decided by a single goal. Carolina closed it out on June 14 with a 3-0 shutout, taking the series 4 games to 2. Vegas rode Cam Hart the entire playoffs, all 22 games across all four rounds, all the way through the Final loss. Carolina’s path in goal was less steady: Frederik Andersen started most of the postseason, including the first two games of the Final, but Carolina turned to Brandon Bussi for Game 3, which Bussi lost, before he settled in and won Games 4, 5, and 6 to close out the series. Neither goalie led the league in wins during the regular season; that distinction was an exact tie between Tampa Bay’s Andrei Vasilevskiy and Utah’s Karel Vejmelka, both at 39.

What’s next

This post covers the season at a high level: scoring, standings, and the playoff run. The same table supports much narrower questions too, like how a specific team’s goaltending held up across back-to-backs, or how a rookie’s production changed after the Olympic break. Those are posts for another day, now that a full season of clean data is sitting in BigQuery.

The pipeline code behind this post lives here.

Querying the season

from google.cloud import bigquery

client = bigquery.Client()

# NCAA's API returns team as its own 6-character code (e.g. "PEPPER"), not
# a school name. Tables and charts below keep the raw code as-is (matches
# how the hockey post's chart also uses raw team codes); this mapping is
# only used to spell out real school names in the prose. A code not in
# this dict falls back to showing the raw abbreviation rather than
# failing, in case a future re-render surfaces a school not covered yet.
TEAM_NAMES = {
    "PEPPER": "Pepperdine",
    "UC IRV": "UC Irvine",
    "BALLST": "Ball State",
    "CATAWB": "Catawba",
    "PENNST": "Penn State",
    "MCKEND": "McKendree",
    "EMMAN": "Emmanuel (Ga.)",
    "LEWIS": "Lewis",
    "HAWAII": "Hawaii",
    "UCLA": "UCLA",
    "USC": "USC",
}


def team_name(code):
    return TEAM_NAMES.get(code, code)


query = """
SELECT
  player_name,
  team,
  SUM(CAST(kills AS INT64)) AS kills,
  SUM(CAST(attack_attempts AS INT64)) AS attempts,
  SAFE_DIVIDE(
    SUM(CAST(kills AS INT64)) - SUM(CAST(attack_errors AS INT64)),
    SUM(CAST(attack_attempts AS INT64))
  ) AS hitting_pct,
  COUNT(DISTINCT game_id) AS games
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
HAVING attempts >= 200
ORDER BY kills DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders

Cole Hartke of Pepperdine led the country with 452 kills, on a 0.352 hitting percentage across 29 matches. UC Irvine’s Andrej Jokanovic finished a close second in raw kills, but needed about 60 more swings to get there, a volume-over-efficiency trade that shows up again later in his team’s championship match.

The top ten, by kills

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["kills"][::-1], color="#2c3e50")
ax.set_xlabel("Kills")
ax.set_title("Top 10 Kills Leaders, 2025-26 Men's Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

Digs, blocks, and aces

digs_query = """
SELECT player_name, team, SUM(CAST(digs AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

blocks_query = """
SELECT player_name, team, SUM(CAST(total_blocks AS FLOAT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
blocks_leader = client.query(blocks_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(CAST(service_aces AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

Nico Paula (Lewis) led all players in digs with 264. Owen Rose (Penn State) topped the block chart with 156, well clear of the field. And Andrew Rowan (UCLA) led in aces with 57.

The championship: Hawaii over UC Irvine

final_query = """
SELECT player_name, team, kills, attack_attempts, hitting_percentage, total_blocks
FROM `maydaystats.ncaa_volleyball_men.boxscores`
WHERE game_id = '6598557'
  AND CAST(kills AS INT64) > 0
ORDER BY team, CAST(kills AS INT64) DESC
"""
final_box = client.query(final_query).to_dataframe()
final_box

Hawaii beat UC Irvine 3-1 on May 11, 2026 to win the national championship. Kristian Titriyski led the way with 16 kills on a .387 hitting percentage, with Adrien Roure adding 15 more. Louis Sakanoko went 12-for-20 (.500) with 3 blocks off the bench, the best hitting percentage of anyone with real volume in the match (two Hawaii players posted a higher percentage on much smaller sample sizes, 5-for-7 and 7-for-10).

UC Irvine’s offense leaned almost entirely on Andrej Jokanovic, the same volume hitter who finished second nationally in kills for the season. He had a team-high 13 kills in the final, but needed 35 attempts to get there, a .229 hitting percentage that never let UC Irvine pull away the way Hawaii’s more balanced, more efficient attack did.

What’s next

This covers the season at a high level: the national leaderboards and the championship match itself. The same table supports much narrower questions too, like a single team’s hitting efficiency by conference opponent, or how a freshman’s role grew over the season. Those are posts for another day, now that a full season of clean data is sitting in BigQuery.

The pipeline code behind this post lives here.

Querying the season

from google.cloud import bigquery

client = bigquery.Client()

# NCAA's API returns team as its own code (e.g. "STFRPA"), not a school
# name. Tables and charts below keep the raw code as-is (matches how the
# hockey post's chart also uses raw team codes); this mapping is only
# used to spell out real school names in the prose. A code not in this
# dict falls back to showing the raw abbreviation rather than failing,
# in case a future re-render surfaces a school not covered yet.
TEAM_NAMES = {
    "MIAMI": "Miami",
    "PITT": "Pittsburgh",
    "PENNST": "Penn State",
    "JMU": "James Madison",
    "WISC": "Wisconsin",
    "STFRPA": "Saint Francis (PA)",
    "PURDUE": "Purdue",
    "SAC ST": "Sacramento State",
    "UK": "Kentucky",
    "TCU": "TCU",
    "UALR": "Little Rock",
    "UT VAL": "Utah Valley",
    "TX A&M": "Texas A&M",
}


def team_name(code):
    return TEAM_NAMES.get(code, code)


query = """
SELECT
  player_name,
  team,
  SUM(CAST(kills AS INT64)) AS kills,
  SUM(CAST(attack_attempts AS INT64)) AS attempts,
  SAFE_DIVIDE(
    SUM(CAST(kills AS INT64)) - SUM(CAST(attack_errors AS INT64)),
    SUM(CAST(attack_attempts AS INT64))
  ) AS hitting_pct,
  COUNT(DISTINCT game_id) AS games
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
HAVING attempts >= 200
ORDER BY kills DESC
LIMIT 10
"""

leaders = client.query(query).to_dataframe()
leaders

Flormarie Heredia Colon of Miami led the country with 687 kills across 28 matches. Miami shows up twice in the national leaderboards this season: the same team that produced the kills leader also produced the national leader in aces, a rare two-way offensive season for one program.

The top ten, by kills

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(9, 5))
labels = leaders["player_name"] + " (" + leaders["team"] + ")"
ax.barh(labels[::-1], leaders["kills"][::-1], color="#2c3e50")
ax.set_xlabel("Kills")
ax.set_title("Top 10 Kills Leaders, 2025 Women's Season")
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout()
plt.show()

Digs, blocks, and aces

digs_query = """
SELECT player_name, team, SUM(CAST(digs AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
digs_leader = client.query(digs_query).to_dataframe()

blocks_query = """
SELECT player_name, team, SUM(CAST(total_blocks AS FLOAT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
blocks_leader = client.query(blocks_query).to_dataframe()

aces_query = """
SELECT player_name, team, SUM(CAST(service_aces AS INT64)) AS total
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE player_name != ''
GROUP BY player_name, team
ORDER BY total DESC
LIMIT 1
"""
aces_leader = client.query(aces_query).to_dataframe()

Andrea Roman (Little Rock) led all players in digs with 632. Bella Wooden of Utah Valley led the country in individual blocks with 188. And Ariana Rodriguez (Miami) topped the ace leaderboard with 77, the same program that produced the season’s kills leader.

The championship: Texas A&M sweeps Kentucky

final_query = """
SELECT player_name, team, kills, attack_attempts, hitting_percentage, digs
FROM `maydaystats.ncaa_volleyball_women.boxscores`
WHERE game_id = '6500718'
  AND CAST(kills AS INT64) > 0
ORDER BY team, CAST(kills AS INT64) DESC
"""
final_box = client.query(final_query).to_dataframe()
final_box

Texas A&M swept Kentucky 3-0 on December 21, 2025 to win the national championship. Logan Lednicky led the Aggies with 11 kills on a .250 hitting percentage, with Kyndal Stowers adding 10 more on .304 hitting, a balanced attack across multiple hitters rather than one player carrying the offense.

Kentucky’s Eva Hudson, who finished among the national top ten in kills for the season, led all players in the match with 13 kills, but needed 45 attempts to get there, a .200 hitting percentage. By far the highest attempt count on the floor, it meant Kentucky’s offense ran through one hitter without the efficiency to match the volume, the same volume-over- efficiency pattern that showed up in the men’s championship match.

What’s next

This covers the season at a high level: the national leaderboards and the championship match itself. The same table supports much narrower questions too, like how a team’s blocking efficiency changed after a lineup shift, or a transfer’s production before and after switching programs. Those are posts for another day, now that a full season of clean data is sitting in BigQuery.

The pipeline code behind this post lives here.

Three research questions

The first deliverable checked the data for major quality problems before any modeling started, a missing-values audit across all five joined tables, shown below by column. Nothing in that audit compromised any of the three analyses that follow.

Does a pitcher’s pitch mix change the third time through the order? A chi-square test of independence on pitch type versus times through the order came back significant (chi-square = 41,249.35, df = 10, p < 0.001), but Cramer’s V was 0.0895, a small effect by any standard cutoff. Pitchers do shift their mix as a game goes on, just not by much.

Does spin rate on a four-seam fastball predict a whiff? A one-sided Mann-Whitney U test found whiffs came on pitches with a higher median spin rate (2,209.1 RPM) than pitches put in play (2,179.7 RPM), and the difference was significant (p = 8.82e-105). The rank-biserial effect size was 0.0462, again small. A follow-up OLS regression of whiff rate on average four-seam spin rate (n = 928 pitchers with at least 100 four-seamers) found a significant positive slope (0.000016 per RPM, p = 1.82e-06), but the model explained just 2.4% of the variance in whiff rate (R-squared = 0.0243). Spin rate matters, but it’s one input among many.

Does average fastball velocity predict strike-zone rate in high-leverage innings (7th-9th)? This is the one question where the data didn’t clear the bar. Pearson correlation between average four-seam velocity and zone percentage came back essentially flat (r = 0.0379, p = 0.276, n = 830 pitchers with at least 50 late-inning fastballs), so this test failed to reject the null. A secondary Spearman rank correlation was technically significant (rho = 0.0727, p = 0.036), but at that size it’s not a finding to build anything on.

The velocity creep that is real, and tiny

The final analysis ran a one-way ANOVA on four-seam fastball velocity across all four seasons in the dataset:

The ANOVA rejected the null outright (F = 4,942.80, p < 0.001), and every pairwise comparison came back significant under a Bonferroni correction, including 2017 versus 2018, a 0.057 mph difference. League-average fastball velocity really did climb across this window, about three quarters of a mile per hour from 2015 to 2017 before leveling off. It’s a real trend. It’s also a small one, and the effect size confirms it: eta squared came out to 0.0144, meaning season explains under 2% of the variation in any single pitch’s velocity.

Whiff rate by pitch type

One more result worth surfacing on its own, a 95% Wilson confidence interval on whiff rate for each pitch type across the full 2.87 million pitches:

At this sample size the confidence intervals are tight enough that every pitch type is distinguishable from every other, changeups and sliders generate whiffs at roughly the same rate and both clear fastballs by nearly double.

Why this belongs next to the pipeline posts

The throughline across all five analyses is the same: with millions of pitches, almost any real difference clears the p < 0.05 bar, so the question that actually matters is how big the effect is, not whether it exists. That’s a distinction worth being explicit about on a site built around real data, and it’s the main thing this project set out to demonstrate.

Full write-up, slide deck, and all analysis code:

• GRAD_505_PROJECT on GitHub
• Written report (PDF)
• Presentation slides (PDF)