0DTE Options Microstructure & Gamma Pinning

The Rise of 0DTE: More Than Half of SPX Volume

From Monthly Expiries to Daily Expiries

Until 2022, S&P 500 index options (SPX) expired weekly at best. CBOE's rollout of daily expirations meant that, for the first time, every single trading day carried its own same-day-expiry ("0DTE," zero days to expiration) options chain. The result was not a niche product — it became the dominant form of SPX trading.

According to CBOE Global Markets Research, 0DTE contracts now regularly account for more than 50% of total S&P 500 options volume on a given trading day, with spikes well above that around FOMC days, CPI prints, and quarterly index rebalances. J.P. Morgan's Quantitative & Derivatives Strategy desk has published repeated warnings that this volume shift has structurally changed how intraday volatility behaves.

Who's Trading 0DTE, and Why It Matters

0DTE flow is a mix of three very different participants — and their combined footprint is what creates the gamma dynamics this article is about:

Why This Wasn't Possible Before 2022

Weekly and monthly options decay their gamma sensitivity slowly. A monthly option's delta barely moves day to day unless the underlying makes a large move. A 0DTE option's delta can swing from 0.10 to 0.90 within a single afternoon on a routine 0.5% index move — because there's no time value left to cushion the change. That compressed gamma is what makes dealer hedging flows so much larger, relative to the option's own premium, than in any prior options regime.

Dealer Hedging 101: Why Market Makers Aren't Directional

The Core Mechanic

Market makers who sell options don't want to bet on market direction — they want to earn the bid-ask spread and collect the implied volatility premium. To stay direction-neutral, they continuously buy or sell the underlying (or futures) to offset the delta of their options book. This is delta hedging, and it is completely mechanical — it happens regardless of the dealer's own market view.

Two Hedging Regimes

Whether dealer hedging dampens or amplifies volatility depends entirely on whether dealers are, in net, long or short gamma:

Net Gamma Exposure (GEX): Positive vs. Negative Regimes

Defining GEX

Net Gamma Exposure (GEX) is a market-wide estimate of the dealer community's aggregate gamma position, inferred from the open interest and Greeks of the listed options chain. It is the single most-cited proxy in institutional 0DTE research for anticipating whether a given session will be pinned or volatile.

GEX_t = Σ (OI_call_k * Gamma_call_k - OI_put_k * Gamma_put_k) * ContractMultiplier * Spot^2 * 0.01

where:
  OI_call_k, OI_put_k = open interest at strike k
  Gamma_call_k, Gamma_put_k = Black-Scholes gamma at strike k
  ContractMultiplier = 100 (standard SPX multiplier)
  Spot = current index level

The standard convention (used by CBOE and most vendor GEX dashboards) assumes dealers are net short puts and net long calls from selling to the public, which is the typical retail/institutional flow pattern — though this assumption breaks down on days with heavy institutional put-selling for income (common in 0DTE condor strategies), which is why GEX is a directional estimate, not a certainty.

The Zero Gamma Flip Level

Because GEX is calculated per strike and dealers' gamma exposure changes as spot moves through strikes, there is a specific index level — the "zero gamma level" or "flip point" — where aggregate GEX crosses from positive to negative. CBOE Research and multiple sell-side desks publish daily estimates of this level. When spot trades above the flip point, the market tends to behave in a pinned, low-vol manner; below it, the same market can behave in a trending, high-vol manner — same index, same day, structurally different behavior depending on which side of the flip level price sits.

The 3:30 PM Pin / Ramp Mechanic

Why the Last 30-90 Minutes Are Different

0DTE options have zero time value left in the final hour of trading — every remaining cent of premium is pure intrinsic sensitivity. This is exactly when gamma is at its most extreme, and it's exactly when large 0DTE positions from earlier in the day are closest to expiring in- or out-of-the-money. Dealers who are still hedging a large book near the close must do so with increasingly large, increasingly fast futures trades as gamma peaks.

The "Pin"

When dealers are net long gamma into the close, their hedging naturally pushes the index toward the strike with the largest open interest — selling as price rises above it, buying as price falls below it. This creates a magnet-like effect known as "pinning," where the index gravitates toward and often closes very near a heavily traded strike (frequently a round number like a 50- or 100-point SPX level).

The "Ramp"

When dealers are net short gamma into the close, the opposite happens — hedging flow chases the move rather than fading it, producing a directional "ramp" in the final 30-60 minutes that has nothing to do with news and everything to do with mechanical rebalancing. J.P. Morgan's research has specifically flagged late-day ramps as a recurring feature of negative-GEX sessions.

Python Implementation: Real-Time Spot Gamma Imbalance

Full implementation: Options chain ingestion, Black-Scholes gamma calculation, GEX aggregation by strike, zero-gamma flip detection.

Complete Python Code

"""
0DTE Spot Gamma Imbalance Calculator
Retail-adapted GEX estimation from public options chain data

Author: Plan My Retire
Date: March 2026
"""

import numpy as np
import pandas as pd
from scipy.stats import norm
from datetime import datetime

class SpotGammaImbalance:
    """
    Estimates aggregate dealer Net Gamma Exposure (GEX) from a
    public SPX/SPY options chain snapshot.

    Convention: dealers assumed net short puts / net long calls
    (standard retail-flow assumption; see CBOE GEX methodology notes).
    """

    def __init__(self, spot_price, risk_free_rate=0.045):
        self.spot = spot_price
        self.r = risk_free_rate

    def bs_gamma(self, strike, time_to_expiry, iv):
        """
        Black-Scholes gamma at a given strike.
        time_to_expiry in years (0DTE uses fraction of a trading day).
        """
        if time_to_expiry <= 0 or iv <= 0:
            return 0.0
        d1 = (np.log(self.spot / strike) +
              (self.r + 0.5 * iv ** 2) * time_to_expiry) / (iv * np.sqrt(time_to_expiry))
        gamma = norm.pdf(d1) / (self.spot * iv * np.sqrt(time_to_expiry))
        return gamma

    def strike_gex(self, strike, call_oi, put_oi, iv, time_to_expiry,
                   contract_multiplier=100):
        """
        Dollar gamma exposure contributed by a single strike.
        Positive = dealers long gamma at this strike (from short puts).
        Negative = dealers short gamma at this strike (from short calls
        assumption is intentionally omitted -- see note below).
        """
        gamma = self.bs_gamma(strike, time_to_expiry, iv)

        # Dealer convention: long gamma from short puts, short gamma from short calls
        call_component = -call_oi * gamma
        put_component = +put_oi * gamma

        dollar_gex = (call_component + put_component) * contract_multiplier * (self.spot ** 2) * 0.01
        return dollar_gex

    def compute_gex_profile(self, chain_df, expiry_datetime, iv_col='iv'):
        """
        chain_df columns required: ['strike', 'call_oi', 'put_oi', iv_col]
        Returns DataFrame with per-strike and cumulative GEX.
        """
        now = datetime.now()
        seconds_to_expiry = max((expiry_datetime - now).total_seconds(), 1)
        time_to_expiry = seconds_to_expiry / (365 * 24 * 3600)

        results = []
        for _, row in chain_df.iterrows():
            gex = self.strike_gex(
                strike=row['strike'],
                call_oi=row['call_oi'],
                put_oi=row['put_oi'],
                iv=row[iv_col],
                time_to_expiry=time_to_expiry
            )
            results.append({'strike': row['strike'], 'gex': gex})

        profile = pd.DataFrame(results).sort_values('strike').reset_index(drop=True)
        profile['cumulative_gex'] = profile['gex'].cumsum()
        return profile

    def find_zero_gamma_flip(self, profile):
        """
        Locate the strike nearest to where cumulative GEX crosses zero.
        This approximates the "flip point" separating pinning (above)
        from trending (below) regimes.
        """
        signs = np.sign(profile['cumulative_gex'])
        flip_idx = np.where(np.diff(signs) != 0)[0]

        if len(flip_idx) == 0:
            return None

        idx = flip_idx[0]
        strike_lo = profile.iloc[idx]['strike']
        strike_hi = profile.iloc[idx + 1]['strike']
        return (strike_lo + strike_hi) / 2

    def classify_regime(self, total_gex, threshold=1e9):
        """
        Simple three-bucket classification for a trading dashboard.
        Threshold should be calibrated against the specific underlying's
        typical GEX magnitude (SPX dollar GEX is much larger than SPY's).
        """
        if total_gex > threshold:
            return "POSITIVE_GEX_PINNING_LIKELY"
        elif total_gex < -threshold:
            return "NEGATIVE_GEX_TRENDING_LIKELY"
        else:
            return "NEUTRAL_TRANSITION_ZONE"


# Example usage
if __name__ == "__main__":
    spot = 5850.0
    calculator = SpotGammaImbalance(spot_price=spot)

    # Example chain snapshot (in production: pull from a live options data vendor)
    chain = pd.DataFrame({
        'strike':  [5750, 5800, 5825, 5850, 5875, 5900, 5950],
        'call_oi': [1200, 3400, 5100, 8900, 4200, 2100, 900],
        'put_oi':  [2800, 6200, 7400, 5100, 2300, 1100, 500],
        'iv':      [0.14, 0.13, 0.125, 0.12, 0.125, 0.13, 0.145]
    })

    expiry = datetime.now().replace(hour=16, minute=0, second=0)
    profile = calculator.compute_gex_profile(chain, expiry)

    total_gex = profile['gex'].sum()
    flip_point = calculator.find_zero_gamma_flip(profile)
    regime = calculator.classify_regime(total_gex)

    print(f"Spot: {spot}")
    print(f"Total Dollar GEX: ${total_gex:,.0f}")
    print(f"Zero Gamma Flip Point: {flip_point}")
    print(f"Regime: {regime}")

Retail-Viable Structures: Iron Butterflies & Condors

Retail traders can't out-hedge dealers, but they can position around the same regime signals dealers create. The two standard structures for harvesting 0DTE premium are the iron butterfly (tighter, higher premium, pin-regime bias) and the iron condor (wider, lower premium, more tolerant of moderate moves).

Iron Butterfly (Pin Regime)

Iron Condor (Wider Tolerance)

Risk Management: Delta Stops & Tail Protection

Why Fixed Stop-Losses Fail on 0DTE

A fixed dollar or percentage stop-loss on a 0DTE position can be worthless — with zero time value left, prices can gap through a stop level between quotes during the final hour's gamma-driven moves. Institutional 0DTE desks instead monitor delta exposure of the open structure and act when it breaches a threshold, rather than waiting for a price-based stop to trigger.

Position Sizing: The Only Lever That Actually Protects You

Short premium 0DTE strategies have a payoff shape that is the mirror image of buying options: frequent small wins, occasional large losses. No entry signal, however well-timed, changes that shape. The only durable protection is sizing each trade so that a maximum loss (wing width minus credit received) is a small, pre-defined fraction of account capital — institutional 0DTE books typically risk well under 1% of capital per structure, specifically because the tail event is a "when," not an "if."

Illustrative Performance

The figures below are hypothetical illustrations of the payoff shape of a GEX-filtered short-premium 0DTE program — they are not a track record and are not a promise of similar results. They exist to make the risk/reward shape concrete, not to suggest predictability.

Common Mistakes That Blow Up 0DTE Sellers

Your Action Plan

Phase 1: Study the Regime, Trade Nothing (2-4 Weeks)

Timeline: Before risking any capital, build the habit of checking the GEX regime.

1. Track a public GEX dashboard daily (several free and paid vendor dashboards publish SPX zero-gamma flip estimates)
2. Journal the regime call each morning (positive/negative/neutral) alongside how the session actually behaved
3. Compare your journal to realized intraday range to build calibrated confidence in the signal before using it live

Phase 2: Small, Defined-Risk Structures (1-3 Months)

Timeline: Start with the smallest tradeable size your broker allows.

1. Trade only on clear positive-GEX days — skip anything near the flip point or ahead of scheduled catalysts
2. Use iron condors before iron butterflies — wider wings, lower win rate, smaller tail losses while you calibrate
3. Risk under 1% of capital per structure — no exceptions, regardless of how confident the regime read looks
4. Log every trade's realized delta path, not just entry/exit price, to refine your delta-stop thresholds

Phase 3: Systematic Scaling (6+ Months)

Timeline: Only after a full quarter of disciplined, sized-down execution with a real edge showing in the numbers.

1. Automate the GEX regime check using the Python framework above against a paid real-time data feed
2. Codify delta-stop rules so exits aren't discretionary decisions made under pressure
3. Cap weekly correlated exposure, not just per-trade exposure, before increasing size

Recommended Reading

• Institutional Research:
  • CBOE Global Markets Research — 0DTE volume and GEX methodology publications
  • J.P. Morgan QDS (Kolanovic & Cheng) — 0DTE market structure and dealer positioning notes
• Related PMR Articles:
  • Variance Risk Premium & Volatility Skew Arbitrage (companion short-vol framework)
  • Order Flow Imbalance, Toxicity & Market Maker Internalization (execution-quality companion piece)