Draft smarter — NFL pick analysis with Deephaven | Blog

The 2026 NFL Draft is days away. Teams have spent months scouting prospects and building their boards. But here's the uncomfortable truth: historically, about half of first-round picks don't live up to their draft position.

Meanwhile, Tom Brady went 199th overall. Richard Sherman was a fifth-rounder. Dak Prescott lasted until the fourth round.

Half of first-round picks don't live up to their draft position. Where does the real value come from?

Where does draft value actually come from? Let's say your team picks 15th this year. Should they stay put, trade up for a quarterback, or trade down and stockpile picks? We'll dig into 20 years of data to find out — and build a system that updates the moment each selection is announced.

The data

We'll combine two datasets:

Pro Football Reference draft history — every pick from 2000-2023, including career stats.
NFL Combine results — measurables for prospects who participated.

from deephaven import read_csv

# Draft history with career outcomes (2000-2023)
draft_raw = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/NFLDraft/csv/nfl_draft_picks.csv"
)

# Cast numeric columns (handle nulls) and filter to 2000+
draft = draft_raw.update(
    [
        "games_played = isNull(games_played) ? 0 : (int)games_played",
        "pro_bowls = isNull(pro_bowls) ? 0 : (int)pro_bowls",
        "all_pro = isNull(all_pro) ? 0 : (int)all_pro",
        "approximate_value = isNull(approximate_value) ? 0 : (int)approximate_value",
    ]
).where("year >= 2000")

# Combine measurables
combine = read_csv(
    "https://media.githubusercontent.com/media/deephaven/examples/main/NFLDraft/csv/nfl_combine.csv"
)

Note

Data sourced from nflverse and hosted in the deephaven/examples repo for easy access.

The draft table includes columns like:

Column	Description
`year`	Draft year
`round`	Round (1-7)
`pick`	Overall pick number
`team`	Drafting team
`player`	Player name
`position`	Position (QB, WR, OT, etc.)
`college`	College
`games_played`	Career games
`pro_bowls`	Pro Bowl selections
`all_pro`	All-Pro selections
`approximate_value`	Pro Football Reference's AV metric

Defining "value"

Before we can analyze the draft, we need to define what "success" means. We'll add boolean columns to flag players who hit certain milestones:

# Add value indicators
draft_with_value = draft.update(
    [
        "is_starter = games_played >= 32",  # Started 2+ seasons
        "is_pro_bowler = pro_bowls >= 1",
        "is_all_pro = all_pro >= 1",
        "is_bust = (round == 1) && (games_played < 32)",  # First-rounder who didn't stick
    ]
).format_row_where("is_bust", "PALE_RED")

Why 32 games for "starter"? That's two full seasons. If a player stuck around that long, he contributed. The "bust" definition is harsher: a first-round pick who couldn't last two years. We highlight those rows in red — scroll through the table and watch the cautionary tales pile up. This formatting propagates to any table derived from draft_with_value, so busts stay visible throughout your analysis.

Approximate Value (AV) is Pro Football Reference's catch-all metric for career production. It isn't perfect, but it lets us compare a linebacker to a kicker.

Pick value by round

Your GM is weighing a trade: move up from 15 to 5 for a quarterback, or trade back to 25 and pick up an extra second-rounder? The conventional wisdom says first-rounders are safer bets. How much safer, exactly?

We'll group all picks by round and compute averages using agg_by:

from deephaven import agg

# Success rates by round
by_round = draft_with_value.update(
    [
        "starter_flag = is_starter ? 1.0 : 0.0",
        "pro_bowl_flag = is_pro_bowler ? 1.0 : 0.0",
    ]
).agg_by(
    [
        agg.count_("picks"),
        agg.avg("avg_games = games_played"),
        agg.avg("avg_av = approximate_value"),
        agg.avg("starter_rate = starter_flag"),
        agg.avg("pro_bowl_rate = pro_bowl_flag"),
    ],
    by=["round"],
)

This gives us one row per round with the count and averages.

Round 1 picks become Pro Bowlers at 15x the rate of Round 7 picks — but they also cost 15x as much in trade value.

The drop-off from Round 1 to Round 2 is steep: Round 1 picks are nearly 50% more likely to become starters. After Round 3, though, the curves flatten. Rounds 5-7 are statistically similar.

Staying at 15 versus moving to 25? Historically, almost no difference. Moving up to 5 costs a fortune in draft capital for a marginal bump in expected value.

Position matters more than you think

Back to your trade decision. That top-5 pick would be for a quarterback — but not all positions carry the same risk.

Here's the same aggregation, now grouped by both position and round, then filtered to first-rounders only:

# Success rate by position and round
by_position = (
    draft_with_value.update(["bust_flag = is_bust ? 1.0 : 0.0"])
    .agg_by(
        [
            agg.count_("picks"),
            agg.avg("avg_games = games_played"),
            agg.avg("bust_rate = bust_flag"),
        ],
        by=["position", "round"],
    )
    .where("round == 1")
)

Quarterbacks bust at nearly twice the rate of offensive linemen. The franchise QB your team wants at pick 5 has a 45% chance of washing out. The tackle at 15 is boring, but he'll probably still be starting in year four.

If your roster is close, draft the lineman. Take the quarterback only if you can afford to be wrong.

Finding the "steal zones"

Where do late-round Pro Bowlers actually come from?

# Pro Bowlers by pick range
pro_bowlers = draft_with_value.where("is_pro_bowler")

pb_by_range = pro_bowlers.update(
    [
        "pick_range = (pick <= 32) ? `1-32` : "
        + "(pick <= 64) ? `33-64` : "
        + "(pick <= 100) ? `65-100` : "
        + "(pick <= 150) ? `101-150` : "
        + "(pick <= 200) ? `151-200` : `201+`"
    ]
).agg_by(
    [
        agg.count_("pro_bowlers"),
    ],
    by=["pick_range"],
)

Over 20% of Pro Bowlers since 2000 came from picks 101 and later. Late rounds aren't lottery tickets. They're where Seattle found Richard Sherman (fifth round) and the Patriots found Tom Brady (sixth).

Trade back from 15 to 25 and pick up an extra fourth-rounder. The numbers favor volume.

Team drafting efficiency

Some franchises consistently find value. Others don't. Here's the efficiency math:

# Total AV per draft pick by team (2010-2020 drafts, enough time to evaluate)
recent_drafts = draft_with_value.where("year >= 2010 && year <= 2020")

team_efficiency = recent_drafts.agg_by(
    [
        agg.count_("total_picks"),
        agg.sum_("total_av = approximate_value"),
        agg.avg("avg_av_per_pick = approximate_value"),
    ],
    by=["team"],
).sort_descending("avg_av_per_pick")

The gap between best and worst drafting teams compounds fast. Seattle built a dynasty on Wilson, Sherman, and Wagner — none of them first-rounders — and their AV per pick sits well above the league median. Some front offices consistently find value where others don't.

Combine metrics vs career success

Do combine measurables predict NFL success?

We'll use natural_join to add combine metrics to each player's draft record. The join matches on player name and year, pulling in measurables like 40-yard dash time:

# Dedupe combine data (some players have duplicate entries)
combine_deduped = combine.first_by(["player", "year"])

# Join draft outcomes with combine data
draft_combine = draft_with_value.natural_join(
    combine_deduped,
    on=["player", "year"],
    joins=[
        "forty_yard",
        "bench_press",
        "vertical",
        "broad_jump",
        "cone_drill",
        "shuttle",
    ],
)

# Correlation: 40 time vs career games for WRs
wr_speed = draft_combine.where("position == `WR`").where("!isNull(forty_yard)")

Now each row has both career outcomes and athletic testing. We filter to receivers with recorded 40 times to check if speed predicts success.

The correlation is weak. Darrius Heyward-Bey ran a 4.30 and barely lasted five years. Anquan Boldin ran a 4.71 and made the Hall of Fame.

# Find "athletic outliers" who busted
athletic_busts = draft_combine.where(["round == 1", "forty_yard < 4.45", "is_bust"])

The stopwatch measures one thing. Football IQ, route running, hands — none of that shows up at the combine.

Trade value analysis

Is trading up worth it? The math is brutal.

The Jimmy Johnson trade value chart assigns point values to each pick: pick 1 is worth 3,000 points, and the value decays exponentially from there. We'll compute each pick's "efficiency": career value divided by trade cost.

# Jimmy Johnson trade value chart: approximate exponential formula
draft_with_trade_value = draft_with_value.update(
    [
        "trade_value = 3000.0 * Math.pow(0.93, pick - 1)",
        "value_efficiency = approximate_value / trade_value * 1000",
        "pick_range = (pick <= 32) ? `1-32` : "
        + "(pick <= 64) ? `33-64` : "
        + "(pick <= 100) ? `65-100` : `101+`",
    ]
)

# Average efficiency by pick range
trade_efficiency = draft_with_trade_value.agg_by(
    [
        agg.avg("avg_efficiency = value_efficiency"),
    ],
    by=["pick_range"],
)

Higher efficiency means more career value per trade point spent. The data suggests the late first round and early second round — picks 20-40 — offer the best return on investment: first-round talent at second-round prices. Teams trading up into the top 5? They're often overpaying.

So what should your team do at 15? The math says: trade back. Pick up extra picks in the 20-40 range where value efficiency peaks — unless you've genuinely found your franchise quarterback.

Real-time draft tracking

Historical analysis is useful prep work. When you're on the clock, though, yesterday's numbers don't tell you what just happened two picks ago.

The same tables that power your historical analysis work live on draft night. Swap the data source and your analysis updates automatically. With function_generated_table, you can poll a draft API and update your analysis in real time:

import requests

from deephaven import function_generated_table, new_table
from deephaven.column import int_col, string_col


def fetch_live_picks():
    """Fetch latest draft picks from API."""
    # Replace with actual draft API (ESPN, NFL, etc.)
    response = requests.get("https://api.example.com/draft/2026/picks")
    picks = response.json()
    return new_table(
        [
            int_col("pick", [p["pick"] for p in picks]),
            string_col("player", [p["player"] for p in picks]),
            string_col("position", [p["position"] for p in picks]),
            string_col("team", [p["team"] for p in picks]),
        ]
    )


# Refreshes every 30 seconds during the draft
live_picks = function_generated_table(
    table_generator=fetch_live_picks,
    refresh_interval_ms=30 * 1000,
)

Now join live picks against your historical analysis:

# Build a lookup table from your historical analysis
historical_value = by_position.view(["position", "bust_rate"]).update(
    ["pick_range = `1-32`", "expected_av = 25.0", "pro_bowl_rate = 0.15"]
)

# Real-time draft grades based on historical value
live_with_grades = live_picks.natural_join(
    historical_value,
    on=["position", "pick_range"],
    joins=["expected_av", "bust_rate", "pro_bowl_rate"],
).update(
    [
        "grade = expected_av > 20 ? `A` : expected_av > 15 ? `B` : expected_av > 10 ? `C` : `D`"
    ]
)

Live Draft Tracking

Every table downstream updates automatically. Your draft board, grades, and comparisons refresh as picks are announced.

Ask questions in plain English

Draft night moves fast, and you don't have time to write a query for every question you have. Connect Claude, Cursor, or Windsurf to your Deephaven session via MCP and ask questions in plain English.

Note

See the MCP setup guide for installation and Claude Desktop configuration.

You: "Which positions have the highest bust rate in the first round?"

Claude: I'll query the draft data and rank positions by first-round bust rate.

Result:

First-round bust rates by position:
- QB: 44.9% — highest risk
- RB: 38.7%
- CB: 33.0%
- WR: 32.7%
- OT: 22.1% — safest bet
- G/C: 18.5% — lowest bust rate

You: "Show me the best Day 3 picks of the last decade."

Claude: I'll filter for rounds 4-7 since 2014, sorted by career value.

Result:

day3_stars = draft_with_value.where(
    ["round >= 4", "year >= 2014", "pro_bowls >= 3"]
).sort_descending("approximate_value")

Claude writes the query and executes it against your live table. You focus on the draft, not syntax.

Interactive exploration with filters

Right-click any column header and choose Quick Filter. Want just quarterbacks? Filter the position column to "QB" and the table updates instantly. Filter college to "Alabama" to see every Crimson Tide pick and their outcomes.

Quick Filter

Ask any question that comes up and get the answer before the next pick is in.

Draft day takeaways

Based on 20+ years of data:

Offensive linemen are the safest first-round picks — 22% bust rate, half that of quarterbacks.
Quarterbacks are the riskiest — nearly 45% of first-round QBs don't stick for two seasons, but the ones who do define franchises.
Rounds 4-7 aren't throwaway picks. One in five Pro Bowlers in this dataset was a Day 3 selection. The teams that know this win the draft without winning the lottery.
Combine numbers are overrated — measurables explain less career variance than you'd expect.
Trading down usually wins — picks 20-40 return more career value per draft capital spent than any other range.

Try it yourself

Try it in the browser — no install required.
Install Deephaven — free, takes five minutes.
Connect an AI assistant — ask draft questions in plain English.

Load your team's last decade of picks. Sort by AV. Look at where the hits actually came from.

The answer is usually not where the fanbase thinks. And when your GM makes a move you don't understand, you'll have the data to know whether to trust it.

Questions or want to share your analysis? Join us on Slack.

Draft smarter — NFL pick analysis with Deephaven

Tom Brady went 199th. Where do Pro Bowlers actually come from? We analyzed 20 years of draft data to find out