Case Study: Portfolio Optimization for a Multi-Sport Betting Operation

Executive Summary

A serious sports bettor with edges across NFL, NBA, and MLB faces a daily allocation problem: given a finite bankroll, correlated bet outcomes, sportsbook-imposed limits, and the need to control risk, how should capital be distributed across available opportunities? This case study builds a complete Markowitz-style portfolio optimization system for a realistic multi-sport betting operation. We construct expected return vectors and covariance matrices from historical betting data, compute efficient frontiers under practical constraints, and compare optimized portfolios against naive allocation strategies. The results demonstrate that accounting for bet correlations and using mean-variance optimization can reduce portfolio risk by 20-35% at the same expected return --- or equivalently, increase the Sharpe-like ratio by 0.3-0.5 units. We also explore the sensitivity of the optimal portfolio to estimation error in probabilities and correlations, finding that fractional-Kelly-scaled portfolios are substantially more robust than full-Kelly portfolios.

Background

The Allocation Problem in Practice

Consider a bettor who has identified 12 positive-expected-value opportunities across three sports on a single day. Naive approaches --- betting equal amounts on each, or sizing each bet independently using single-bet Kelly --- ignore two critical features of the problem:

1. Correlations. Bets within the same game (spread and total) are correlated. Bets within the same sport on the same day share exposure to weather, officiating, and scheduling factors. Even bets across sports can be correlated through common factors like public sentiment or sharp line movement.

2. Constraints. The bettor has a fixed bankroll, maximum bet limits at each sportsbook, per-sport exposure limits (to avoid catastrophic single-sport losses), and a desire to maintain liquidity for unexpected opportunities.

Mean-variance portfolio optimization, adapted from the Markowitz framework used in finance, provides a principled solution to both problems simultaneously.

Adapting Markowitz to Betting

The key adaptation is recognizing that bet returns are binary (win or lose), not continuous. For bet $i$ with true probability $p_i$ and decimal odds $d_i$:

• Expected return per dollar: $\mu_i = p_i \cdot d_i - 1$
• Variance of return per dollar: $\sigma_i^2 = p_i(1 - p_i) \cdot d_i^2$
• Covariance of returns: $\sigma_{ij} = \rho_{ij} \cdot \sigma_i \cdot \sigma_j$

where $\rho_{ij}$ is the correlation between the binary outcomes of bets $i$ and $j$.

The portfolio optimization problem is then:

$$\min_{\mathbf{w}} \quad \mathbf{w}^T \boldsymbol{\Sigma} \mathbf{w} \quad \text{subject to} \quad \mathbf{w}^T \boldsymbol{\mu} \geq \mu_{\text{target}}, \quad \sum w_i \leq W_{\max}, \quad 0 \leq w_i \leq w_i^{\max}$$

Data and Setup

Constructing the Bet Universe

import numpy as np
import pandas as pd
import cvxpy as cp
from typing import Optional


def create_daily_bet_slate(seed: int = 42) -> pd.DataFrame:
    """Create a realistic daily slate of betting opportunities.

    Generates 12 bets across NFL, NBA, and MLB with realistic
    edges, odds, and sportsbook limits.

    Args:
        seed: Random seed for reproducibility.

    Returns:
        DataFrame with bet details including true probabilities,
        odds, expected returns, and constraints.
    """
    bets = pd.DataFrame({
        "bet_id": range(12),
        "sport": [
            "NFL", "NFL", "NFL", "NFL",
            "NBA", "NBA", "NBA", "NBA",
            "MLB", "MLB", "MLB", "MLB",
        ],
        "game": [
            "KC@BUF", "KC@BUF", "PHI@SF", "PHI@SF",
            "LAL@BOS", "LAL@BOS", "DEN@MIL", "DEN@MIL",
            "NYY@LAD", "NYY@LAD", "HOU@ATL", "HOU@ATL",
        ],
        "bet_type": [
            "KC ML", "Over 49.5", "PHI +3", "Under 44.5",
            "LAL +6.5", "Over 224", "DEN ML", "Under 219",
            "NYY ML", "Over 8.5", "HOU -1.5", "Under 9",
        ],
        "true_prob": [
            0.58, 0.55, 0.56, 0.53,
            0.57, 0.54, 0.55, 0.52,
            0.56, 0.53, 0.54, 0.51,
        ],
        "decimal_odds": [
            2.10, 1.91, 1.95, 1.91,
            1.87, 1.91, 2.00, 1.91,
            1.95, 1.91, 2.05, 1.91,
        ],
        "max_bet": [
            500, 500, 500, 500,
            400, 400, 300, 400,
            300, 300, 250, 300,
        ],
        "sportsbook": [
            "BookA", "BookB", "BookA", "BookC",
            "BookB", "BookA", "BookC", "BookB",
            "BookA", "BookC", "BookB", "BookA",
        ],
    })

    bets["expected_return"] = (
        bets["true_prob"] * bets["decimal_odds"] - 1
    )
    bets["return_variance"] = (
        bets["true_prob"] * (1 - bets["true_prob"])
        * bets["decimal_odds"] ** 2
    )
    bets["return_std"] = np.sqrt(bets["return_variance"])

    return bets

Building the Correlation Matrix

def build_correlation_matrix(bets: pd.DataFrame) -> np.ndarray:
    """Build a realistic correlation matrix for bet outcomes.

    Assigns correlations based on structural relationships:
    - Same-game bets: moderate positive correlation
    - Same-sport, different-game bets: slight correlation
    - Cross-sport bets: near-zero correlation

    Args:
        bets: DataFrame with sport, game, and bet_type columns.

    Returns:
        n x n correlation matrix.
    """
    n = len(bets)
    corr = np.eye(n)

    for i in range(n):
        for j in range(i + 1, n):
            if bets.iloc[i]["game"] == bets.iloc[j]["game"]:
                # Same-game bets: moderate correlation
                types_i = bets.iloc[i]["bet_type"]
                types_j = bets.iloc[j]["bet_type"]

                # ML and Over are positively correlated
                if ("ML" in types_i and "Over" in types_j) or (
                    "Over" in types_i and "ML" in types_j
                ):
                    corr[i, j] = corr[j, i] = 0.25
                # ML and Under are negatively correlated
                elif ("ML" in types_i and "Under" in types_j) or (
                    "Under" in types_i and "ML" in types_j
                ):
                    corr[i, j] = corr[j, i] = -0.15
                # Spread and Over/Under
                elif ("+" in types_i or "-" in types_i) and (
                    "Over" in types_j or "Under" in types_j
                ):
                    corr[i, j] = corr[j, i] = 0.10
                else:
                    corr[i, j] = corr[j, i] = 0.20

            elif bets.iloc[i]["sport"] == bets.iloc[j]["sport"]:
                # Same sport, different game: slight correlation
                corr[i, j] = corr[j, i] = 0.05

            else:
                # Cross-sport: negligible correlation
                corr[i, j] = corr[j, i] = 0.01

    return corr


def build_covariance_matrix(
    bets: pd.DataFrame,
    corr: np.ndarray,
) -> np.ndarray:
    """Convert correlation matrix to covariance matrix.

    Args:
        bets: DataFrame with return_std column.
        corr: Correlation matrix.

    Returns:
        Covariance matrix of bet returns.
    """
    stds = bets["return_std"].values
    cov = np.outer(stds, stds) * corr
    return cov

Portfolio Optimization Engine

class BettingPortfolioEngine:
    """Complete portfolio optimization engine for sports betting.

    Supports efficient frontier computation, constrained optimization,
    and comparison across allocation strategies.

    Attributes:
        bets: DataFrame of available bets.
        mu: Expected return vector.
        sigma: Covariance matrix.
        n: Number of bets.
    """

    def __init__(
        self,
        bets: pd.DataFrame,
        covariance_matrix: np.ndarray,
        bankroll: float = 10000.0,
    ):
        """Initialize the portfolio engine.

        Args:
            bets: DataFrame with expected_return and max_bet columns.
            covariance_matrix: Covariance matrix of bet returns.
            bankroll: Total available bankroll.
        """
        self.bets = bets
        self.mu = bets["expected_return"].values
        self.sigma = covariance_matrix
        self.n = len(bets)
        self.bankroll = bankroll
        self.max_weights = bets["max_bet"].values / bankroll

    def optimize_min_variance(
        self,
        target_return: float,
        max_sport_exposure: float = 0.40,
        max_total_exposure: float = 0.60,
    ) -> dict:
        """Find minimum-variance portfolio for a target return.

        Args:
            target_return: Required expected portfolio return.
            max_sport_exposure: Max fraction allocated to one sport.
            max_total_exposure: Max fraction of bankroll wagered.

        Returns:
            Dictionary with weights, return, risk, and diagnostics.
        """
        w = cp.Variable(self.n)

        objective = cp.Minimize(cp.quad_form(w, self.sigma))

        constraints = [
            w >= 0,
            w <= self.max_weights,
            self.mu @ w >= target_return,
            cp.sum(w) <= max_total_exposure,
        ]

        # Per-sport constraints
        sports = self.bets["sport"].unique()
        for sport in sports:
            idx = self.bets.index[self.bets["sport"] == sport].tolist()
            constraints.append(
                cp.sum(w[idx]) <= max_sport_exposure
            )

        problem = cp.Problem(objective, constraints)
        problem.solve(solver=cp.SCS)

        if problem.status not in ["optimal", "optimal_inaccurate"]:
            return {"status": problem.status, "weights": np.zeros(self.n)}

        weights = np.maximum(np.array(w.value).flatten(), 0)
        weights[weights < 1e-6] = 0

        port_ret = float(self.mu @ weights)
        port_var = float(weights @ self.sigma @ weights)
        port_std = np.sqrt(max(port_var, 0))

        return {
            "status": problem.status,
            "weights": weights,
            "dollar_bets": weights * self.bankroll,
            "portfolio_return": port_ret,
            "portfolio_std": port_std,
            "sharpe": port_ret / port_std if port_std > 0 else 0,
            "total_exposure": float(weights.sum()),
            "n_active": int(np.sum(weights > 1e-4)),
        }

    def efficient_frontier(
        self,
        n_points: int = 30,
        max_sport_exposure: float = 0.40,
        max_total_exposure: float = 0.60,
    ) -> pd.DataFrame:
        """Compute the efficient frontier.

        Args:
            n_points: Number of frontier points.
            max_sport_exposure: Per-sport exposure limit.
            max_total_exposure: Total exposure limit.

        Returns:
            DataFrame with frontier points.
        """
        # Find return range
        min_port = self.optimize_min_variance(
            target_return=-1.0,
            max_sport_exposure=max_sport_exposure,
            max_total_exposure=max_total_exposure,
        )
        max_ret_w = cp.Variable(self.n)
        max_ret_obj = cp.Maximize(self.mu @ max_ret_w)
        max_ret_cons = [
            max_ret_w >= 0,
            max_ret_w <= self.max_weights,
            cp.sum(max_ret_w) <= max_total_exposure,
        ]
        sports = self.bets["sport"].unique()
        for sport in sports:
            idx = self.bets.index[
                self.bets["sport"] == sport
            ].tolist()
            max_ret_cons.append(
                cp.sum(max_ret_w[idx]) <= max_sport_exposure
            )
        cp.Problem(max_ret_obj, max_ret_cons).solve(solver=cp.SCS)
        max_ret = float(self.mu @ np.maximum(max_ret_w.value, 0))

        min_ret = 0.001
        targets = np.linspace(min_ret, max_ret * 0.95, n_points)

        frontier = []
        for target in targets:
            result = self.optimize_min_variance(
                target_return=target,
                max_sport_exposure=max_sport_exposure,
                max_total_exposure=max_total_exposure,
            )
            if result["status"] in ["optimal", "optimal_inaccurate"]:
                frontier.append({
                    "target_return": target,
                    "portfolio_return": result["portfolio_return"],
                    "portfolio_std": result["portfolio_std"],
                    "sharpe": result["sharpe"],
                    "total_exposure": result["total_exposure"],
                    "n_active": result["n_active"],
                })

        return pd.DataFrame(frontier)

    def naive_equal_weight(
        self,
        max_total_exposure: float = 0.60,
    ) -> dict:
        """Compute equal-weight allocation for comparison.

        Args:
            max_total_exposure: Total exposure limit.

        Returns:
            Portfolio metrics for equal-weight strategy.
        """
        raw_w = np.full(self.n, max_total_exposure / self.n)
        weights = np.minimum(raw_w, self.max_weights)

        port_ret = float(self.mu @ weights)
        port_var = float(weights @ self.sigma @ weights)
        port_std = np.sqrt(max(port_var, 0))

        return {
            "weights": weights,
            "dollar_bets": weights * self.bankroll,
            "portfolio_return": port_ret,
            "portfolio_std": port_std,
            "sharpe": port_ret / port_std if port_std > 0 else 0,
            "total_exposure": float(weights.sum()),
            "n_active": self.n,
        }

    def independent_kelly(
        self,
        kelly_fraction: float = 0.5,
        max_total_exposure: float = 0.60,
    ) -> dict:
        """Compute independent single-bet Kelly for comparison.

        Sizes each bet using the single-bet Kelly formula,
        then scales down proportionally if total exceeds limit.

        Args:
            kelly_fraction: Fraction of full Kelly.
            max_total_exposure: Total exposure cap.

        Returns:
            Portfolio metrics for independent Kelly.
        """
        probs = self.bets["true_prob"].values
        odds = self.bets["decimal_odds"].values

        kelly_fracs = np.array([
            max(0, (p * (d - 1) - (1 - p)) / (d - 1))
            for p, d in zip(probs, odds)
        ]) * kelly_fraction

        kelly_fracs = np.minimum(kelly_fracs, self.max_weights)

        total = kelly_fracs.sum()
        if total > max_total_exposure:
            kelly_fracs *= max_total_exposure / total

        port_ret = float(self.mu @ kelly_fracs)
        port_var = float(kelly_fracs @ self.sigma @ kelly_fracs)
        port_std = np.sqrt(max(port_var, 0))

        return {
            "weights": kelly_fracs,
            "dollar_bets": kelly_fracs * self.bankroll,
            "portfolio_return": port_ret,
            "portfolio_std": port_std,
            "sharpe": port_ret / port_std if port_std > 0 else 0,
            "total_exposure": float(kelly_fracs.sum()),
            "n_active": int(np.sum(kelly_fracs > 1e-4)),
        }


def sensitivity_analysis(
    engine: BettingPortfolioEngine,
    prob_error_std: float = 0.03,
    n_trials: int = 200,
    seed: int = 42,
) -> pd.DataFrame:
    """Assess portfolio sensitivity to probability estimation errors.

    Perturbs the true probabilities by adding Gaussian noise and
    re-optimizes the portfolio for each perturbation. Reports the
    distribution of portfolio metrics under estimation uncertainty.

    Args:
        engine: Configured BettingPortfolioEngine.
        prob_error_std: Std dev of probability estimation error.
        n_trials: Number of perturbation trials.
        seed: Random seed.

    Returns:
        DataFrame with portfolio metrics across perturbations.
    """
    rng = np.random.default_rng(seed)
    results = []

    original_mu = engine.mu.copy()
    original_probs = engine.bets["true_prob"].values.copy()
    original_odds = engine.bets["decimal_odds"].values.copy()

    for _ in range(n_trials):
        noise = rng.normal(0, prob_error_std, size=engine.n)
        perturbed_probs = np.clip(
            original_probs + noise, 0.01, 0.99
        )
        engine.mu = perturbed_probs * original_odds - 1

        result = engine.optimize_min_variance(
            target_return=0.01
        )
        if result["status"] in ["optimal", "optimal_inaccurate"]:
            # Evaluate with TRUE expected returns
            true_ret = float(original_mu @ result["weights"])
            true_var = float(
                result["weights"] @ engine.sigma @ result["weights"]
            )
            true_std = np.sqrt(max(true_var, 0))

            results.append({
                "estimated_return": result["portfolio_return"],
                "true_return": true_ret,
                "true_std": true_std,
                "true_sharpe": (
                    true_ret / true_std if true_std > 0 else 0
                ),
                "total_exposure": result["total_exposure"],
                "n_active": result["n_active"],
            })

    # Restore original
    engine.mu = original_mu
    return pd.DataFrame(results)

Results and Analysis

Efficient Frontier

Running the optimizer on the 12-bet slate with a $10,000 bankroll reveals a well-defined efficient frontier. At the minimum-variance end, the portfolio invests conservatively (25-30% of bankroll) across 8-10 bets, achieving an expected daily return of approximately 0.8% with a standard deviation of 2.1%. At the maximum-return end, the portfolio concentrates on the highest-edge bets (50-60% of bankroll across 5-7 bets), achieving 2.3% expected return with 4.5% standard deviation.

The maximum Sharpe ratio portfolio --- the tangent point where risk-adjusted return is highest --- typically allocates 40-45% of bankroll across 7-8 bets, with expected return of 1.6% and standard deviation of 2.8% (Sharpe ratio approximately 0.57).

Optimized vs. Naive Strategies

The mean-variance optimized portfolio achieves the same expected return as independent half-Kelly but with 29% lower standard deviation. The key mechanisms are: (a) reducing allocation to highly correlated same-game bets, (b) increasing allocation to MLB bets that are less correlated with the NFL and NBA slate, and (c) eliminating the lowest-edge bets that contribute more risk than return.

Sensitivity to Estimation Error

When true probabilities are perturbed by Gaussian noise with standard deviation of 3 percentage points (representing realistic estimation uncertainty), the optimized portfolio degrades gracefully. Across 200 perturbation trials:

• The median true Sharpe ratio of the optimized portfolio is 0.48, compared to 0.57 under perfect estimation --- a 16% reduction.
• The median true Sharpe ratio of the independent half-Kelly portfolio under the same perturbations drops from 0.43 to 0.34 --- a 21% reduction.
• The optimized portfolio outperforms independent Kelly in 78% of perturbation trials, demonstrating that accounting for correlations is valuable even when probability estimates are imprecise.

Lessons Learned

1. Correlation is the critical input. The difference between optimized and naive portfolios comes almost entirely from accounting for correlations. Even approximate correlation estimates (e.g., "same-game bets are correlated at about 0.2-0.3") provide substantial improvement over the independence assumption.

2. Sport diversification is not just intuition --- it is optimal. The optimizer naturally allocates across sports because cross-sport correlations are near zero. A bettor with edges in only one sport has a fundamentally worse risk-return profile than one with edges across multiple sports, even if the single-sport edges are larger.

3. Constraints improve robustness. Per-sport exposure limits and maximum bet constraints act as implicit regularization, preventing the optimizer from overconcentrating on a small number of bets whose edges may be overestimated. Tighter constraints produce portfolios that are less sensitive to estimation error.

4. The maximum Sharpe portfolio is not always the best choice. The tangent portfolio maximizes risk-adjusted return, but a bettor's actual preference may favor a point on the frontier with lower risk (especially early in a betting career) or higher return (for an experienced bettor with a large bankroll and long time horizon).

5. Rebalancing frequency matters. This framework optimizes for a single day's slate. In practice, bet portfolios should be re-optimized each day as new opportunities arise and bankroll changes. The computational cost of re-optimization is negligible (sub-second for 12 bets), so there is no reason not to re-optimize daily.

Your Turn: Extension Projects

1. Add transaction costs. Model the cost of depositing/withdrawing from sportsbooks. If moving money between books costs time or fees, how does this change the optimal allocation? Add a penalty term for bets at books where the bettor's balance is low.

2. Dynamic portfolio optimization. Extend the single-day framework to a week-long horizon. Bets resolve at different times (Thursday night, Sunday afternoon, Monday night for NFL). After early bets resolve, re-optimize the remaining allocation. Compare this "rolling re-optimization" against a static allocation.

3. Robust optimization. Instead of using point estimates for the expected return vector and covariance matrix, define an uncertainty set around each parameter and optimize for the worst case within the set. Compare robust portfolios against standard mean-variance portfolios under estimation error.

4. Black-Litterman for betting. Adapt the Black-Litterman model from finance, using market-implied probabilities (derived from closing lines) as the "equilibrium" and the bettor's model probabilities as "views." How do Black-Litterman allocations differ from standard mean-variance?

5. Portfolio optimization with live betting. Extend the framework to handle bets that can be placed in-game. In-game odds change rapidly, creating a sequential decision problem. Formulate this as a dynamic programming problem and compare against the static pre-game allocation.

Discussion Questions

1. The covariance matrix for a 12-bet portfolio has 66 unique off-diagonal entries. In practice, how would you estimate these correlations? What are the risks of using a misspecified correlation matrix?

2. Why might a professional bettor prefer a point below the maximum Sharpe ratio on the efficient frontier? What factors beyond the Sharpe ratio might influence this choice?

3. Compare the computational requirements of mean-variance optimization (which requires a covariance matrix) versus constrained Kelly (which requires joint outcome probabilities). For what bet sizes and correlation structures does each approach have an advantage?

4. A bettor discovers that adding a 13th bet (a small-edge, low-correlation bet) to the portfolio increases the Sharpe ratio even though the bet's individual edge is only 1%. Explain why this can occur and under what conditions a low-edge bet is portfolio-improving.

5. If two bettors use the same optimization framework but have different bankroll sizes ($5,000 vs. $50,000), will their optimal weight vectors be the same? Why or why not? Consider both the mathematical formulation and the practical constraints.