Case Study 1: When the Safety Net Catches You --- A Loss Limit System in Action

Executive Summary

Loss limits are designed to be invisible on good days and indispensable on bad ones. This case study follows Marcus, a semi-professional NBA bettor, through the first year of implementing a comprehensive loss limit system. During that year, Marcus's daily hard stop was triggered fourteen times, his weekly limit three times, and his monthly limit once. Using his detailed journal records and the automated loss limit tracker from Chapter 38, we reconstruct the financial and psychological impact of each trigger event. The data reveals that the loss limit system prevented an estimated $18,700 in excess losses compared to Marcus's projected behavior without limits (based on his pre-limit historical patterns). The case examines three trigger events in detail --- a standard daily stop, a weekly stop that prevented a tilt spiral, and the single monthly stop that forced a comprehensive process overhaul --- and demonstrates that the most valuable function of loss limits is not the money they save on the day they trigger but the behavioral patterns they prevent from forming.

Background

The Bettor Profile

Marcus had been betting on NBA games for three years, specializing in player props and game totals. His track record was respectable: a verified 2.8% ROI over approximately 2,200 bets, with a well-calibrated model built on player tracking data, pace metrics, and injury-adjusted projections. His bankroll had grown from an initial $5,000 to $22,000.

Marcus had two significant weaknesses, both of which he was aware of but had never systematically addressed. First, he was prone to increasing his bet sizes after losing streaks, a classic loss-chasing pattern that he rationalized as "getting more action when the edge is still there." Second, he had no formal stopping rules. On bad days, he would continue betting until either the games ran out or exhaustion set in. His journal showed that his worst 5% of days accounted for 34% of his total lifetime losses --- a clear indicator that tail risk was consuming his edge.

The catalyst for change was a single day in February. Marcus lost seven consecutive bets totaling $4,100 (approximately 19% of his bankroll at the time). The next morning, reviewing his journal, he realized that his last four bets had been placed in a state of increasing agitation, with stake sizes escalating from his normal $440 (2% of bankroll) to $880. The reasoning entries for those final bets were terse: "double down," "have to get some back," "this one's a lock." He recognized these as the hallmarks of tilt that he had studied in Chapter 36.

The Implementation

Designing the System

Marcus implemented the loss limit framework from Section 38.1 with the following parameters, calibrated to his $22,000 bankroll:

He integrated these limits into his Python-based discipline enforcement system, using the LossLimitTracker class from Section 38.1.5. The system checked his current P&L against all limits before every bet and refused to record a bet when any hard stop was triggered.

The Tracking Code

Marcus extended the base tracker with automated logging and post-trigger analysis:

"""Extended loss limit tracker with trigger analysis.

Tracks loss limit triggers over time and computes the estimated
savings from prevented excessive betting.

Author: The Sports Betting Textbook
Chapter: 38 - Risk Management and Responsible Gambling
"""

import json
import os
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass


@dataclass
class TriggerEvent:
    """A single loss limit trigger event.

    Attributes:
        date: Date of the trigger.
        limit_type: Which limit was hit (daily_soft, daily_hard,
            weekly, monthly).
        pl_at_trigger: P&L when the limit was triggered.
        bets_placed: Number of bets placed before the trigger.
        bets_remaining_in_queue: Bets that were in the model
            queue but not placed.
        emotional_state: Self-reported emotional state (1-10).
        compliance: Whether the bettor complied with the stop.
    """

    date: str
    limit_type: str
    pl_at_trigger: float
    bets_placed: int
    bets_remaining_in_queue: int
    emotional_state: int
    compliance: bool


class TriggerAnalyzer:
    """Analyzes the impact of loss limit triggers over time.

    Attributes:
        triggers: List of all trigger events.
    """

    def __init__(self, log_path: str = "trigger_log.json"):
        """Initialize with path to the trigger log.

        Args:
            log_path: Path to the JSON trigger log file.
        """
        self.log_path = log_path
        self.triggers = self._load_triggers()

    def _load_triggers(self) -> List[TriggerEvent]:
        """Load trigger history from disk."""
        if os.path.exists(self.log_path):
            with open(self.log_path, "r") as f:
                data = json.load(f)
            return [TriggerEvent(**t) for t in data]
        return []

    def estimate_savings(
        self,
        avg_post_trigger_loss_rate: float = 0.65,
        avg_bet_size: float = 440.0,
    ) -> Dict:
        """Estimate money saved by loss limit compliance.

        Uses historical data showing that bets placed after
        reaching the soft stop threshold have a higher loss
        rate than normal bets.

        Args:
            avg_post_trigger_loss_rate: Estimated loss rate for
                bets that would have been placed without limits.
            avg_bet_size: Average bet size for estimation.

        Returns:
            Dictionary with estimated savings breakdown.
        """
        total_prevented_bets = sum(
            t.bets_remaining_in_queue for t in self.triggers
            if t.compliance
        )

        # Estimate: without limits, each prevented bet has a
        # higher loss rate due to emotional state
        expected_loss_per_bet = avg_bet_size * avg_post_trigger_loss_rate
        normal_loss_per_bet = avg_bet_size * 0.48  # Normal loss rate
        excess_per_bet = expected_loss_per_bet - normal_loss_per_bet
        total_estimated_savings = total_prevented_bets * excess_per_bet

        return {
            "total_triggers": len(self.triggers),
            "complied": sum(1 for t in self.triggers if t.compliance),
            "total_prevented_bets": total_prevented_bets,
            "estimated_savings": round(total_estimated_savings, 2),
            "avg_emotional_state_at_trigger": round(
                sum(t.emotional_state for t in self.triggers)
                / max(len(self.triggers), 1), 1
            ),
        }

    def trigger_summary(self) -> Dict:
        """Generate a summary of all trigger events.

        Returns:
            Dictionary with trigger counts by type and month.
        """
        by_type: Dict[str, int] = {}
        by_month: Dict[str, int] = {}

        for t in self.triggers:
            by_type[t.limit_type] = by_type.get(t.limit_type, 0) + 1
            month = t.date[:7]
            by_month[month] = by_month.get(month, 0) + 1

        return {
            "by_type": by_type,
            "by_month": dict(sorted(by_month.items())),
            "total": len(self.triggers),
        }

The Timeline

Year 1: Fourteen Daily Stops, Three Weekly Stops, One Monthly Stop

Over twelve months, Marcus placed 2,840 bets with a final ROI of 3.2% --- an improvement over his pre-limit 2.8%. The loss limit system was triggered as follows:

Detailed Trigger Analyses

Event 1: A Standard Daily Stop (March 15)

Marcus lost three consecutive NBA totals bets in the early afternoon. His P&L for the day hit -$920, triggering the daily hard stop at $880 (he had exceeded it slightly because the third loss pushed him past the threshold). His model had four more qualifying bets queued for the evening. His emotional state at the trigger was 4/10 --- frustrated but still rational.

He complied with the stop, closed his apps, and went to the gym. The next morning, he reviewed the four bets he had missed. Two won and two lost, for a net gain of $38. The limit had not cost him significant profit, but more importantly, it had interrupted the trajectory of frustration that, based on his historical patterns, might have led to stake escalation.

His journal entry: "The limit caught me before I started making bad decisions. Three losses is exactly when I historically start increasing size. The system did its job."

Event 2: A Weekly Stop That Prevented a Spiral (June 18)

This was the most consequential trigger of the year. Marcus had hit his daily stop on June 14 and again on June 16. By June 18, his weekly P&L stood at -$2,100 with a thinning margin before the weekly limit of $2,200. He placed one more bet --- a $440 wager that lost --- and the weekly limit triggered at -$2,540.

Marcus's emotional state at this trigger was 2/10. His journal shows the hallmarks of early tilt: "These lines are wrong. The market is mispricing everything. I should be doubling my action, not stopping." These entries closely mirror Priya's pre-spiral language in Chapter 37's Case Study 2.

He complied with the stop, but described the compliance as "the hardest thing I have done in three years of betting." He spent the remaining three days of the week reviewing his model and discovered that a data pipeline issue had introduced stale injury data for two days, degrading his projections. Without the weekly stop, he would have continued betting on flawed projections in an escalating emotional state.

Post-mortem estimate: Based on his pre-limit behavior patterns during comparable weeks (identified by similar P&L trajectories and emotional state ratings), Marcus estimated that without the weekly stop, he would have placed approximately 18 additional bets at inflated stakes, with an expected excess loss of $3,200-$5,800 beyond normal variance.

Event 3: The Monthly Stop (September 28)

September was Marcus's worst month. A combination of model underperformance, an NBA season-opening schedule that differed from historical patterns, and two consecutive weekly stops culminated in the monthly hard stop triggering at -$4,400.

The monthly stop forced a comprehensive review. Marcus spent five days off from betting, during which he:

1. Conducted a full model audit, discovering that his pace adjustment factors were miscalibrated for the early season.
2. Identified that his emotional state ratings had been declining steadily since June, suggesting accumulated psychological fatigue.
3. Recognized that he had been betting on a new prop market (player assists) without sufficient model validation.
4. Reviewed his journal entries and found that the word "lock" had appeared in his reasoning text eleven times in September, compared to zero in his first six months.

The remediation plan included model recalibration, elimination of the unvalidated assists market, a mandatory one-week break every eight weeks, and the addition of language-based warnings in his journal system (flagging entries containing words like "lock," "certain," or "guaranteed").

Quantified Impact

Marcus's trigger analysis estimated the total savings from his loss limit system over the year:

The estimated $18,700 in prevented losses was calculated using Marcus's pre-limit behavioral patterns: his historical loss rate on bets placed after reaching the equivalent of his soft stop threshold was 65% (vs. 48% normally), with average stakes 40% above his baseline. The $2,300 in sacrificed profit represents the expected value of the 94 bets he was prevented from placing, at his normal edge.

Key Lessons

1. The most valuable function of limits is behavioral, not financial. The $18,700 in prevented losses came not from avoiding bad luck but from interrupting destructive behavioral patterns. The limit system's primary value was preventing Marcus from reaching the emotional states where loss-chasing and stake escalation occur.

2. Weekly limits catch what daily limits miss. The June weekly stop was the most consequential trigger of the year. Daily stops are essential, but a bettor can have a series of bad-but-not-terrible days that individually stay within the daily limit while cumulating into a dangerous weekly trajectory. The weekly limit caught this pattern.

3. The monthly limit forces systemic review. The September monthly stop revealed model issues, market overextension, and psychological fatigue that would not have been detected by daily or weekly stops alone. The forced comprehensive review was worth far more than any single trading day.

4. Compliance is hardest when it matters most. Marcus described the June weekly stop as "the hardest thing" he had done in three years. This is precisely the point: the moments when compliance feels most painful are the moments when the bettor is most at risk of destructive behavior. Hard stops must be automated and unoverridable because willpower is depleted exactly when it is most needed.

5. The cost of limits is small relative to the benefit. Marcus sacrificed an estimated $2,300 in expected value from missed bets. He saved an estimated $18,700 in prevented excess losses. The return on the loss limit system was approximately 8:1.

Discussion Questions

1. Marcus's trigger analysis assumes that bets placed after reaching the soft stop threshold have a 65% loss rate. How would you validate this assumption? What data would you need, and what biases might affect the estimate?

2. The monthly stop in September revealed a model calibration issue that had persisted for weeks. Should the loss limit system be supplemented with a separate "model health" monitoring system? If so, what metrics would it track?

3. Marcus described the June weekly stop as "the hardest thing he had done." How should a bettor prepare psychologically for the experience of complying with a loss limit during a period of high frustration? What specific pre-commitment strategies might help?

4. The cost-benefit analysis shows an 8:1 return on the loss limit system. How sensitive is this estimate to the assumed post-trigger loss rate? At what post-trigger loss rate would the cost of limits exceed the benefit?

5. Marcus's limits are set as percentages of bankroll and recalculated dynamically. An alternative approach is to set fixed dollar limits that do not change with bankroll fluctuations. What are the advantages and disadvantages of each approach?