name	long-straddle
description	Analyzes long straddle volatility plays with ATM call and put at same strike. Requires numpy>=1.24.0, pandas>=2.0.0, matplotlib>=3.7.0, scipy>=1.10.0. Use when expecting large price movement in either direction, analyzing earnings plays, evaluating volatility opportunities, or assessing binary event outcomes on high IV stocks.

Long Straddle Strategy

Version: 1.0 Last Updated: 2025-12-12

Overview

A long straddle is a neutral volatility strategy that profits from large price movements in either direction. By purchasing both an ATM call and ATM put with the same strike and expiration, the trader benefits from significant moves regardless of direction while accepting high upfront cost and time decay.

Quick Summary: Buy ATM call + Buy ATM put (same strike) = Profit from large moves either way

Strategy Characteristics

Position Structure:

Buy 1 call at-the-money (ATM)
Buy 1 put at-the-money (ATM)
Same strike price (typically ATM)
Same expiration date

Risk Profile:

Maximum Loss: Total premium paid (call + put)
Maximum Profit: Unlimited (stock can move infinitely)
Breakeven Points:
- Upside: Strike + Total premium
- Downside: Strike - Total premium
Best Use: Expect large move but uncertain of direction

Cost Components:

Call premium (debit)
Put premium (debit)
Total premium = Call + Put (significant cost)
Transaction costs: ~$0.65 per contract × 2 legs = $1.30

Quick Start

Calculate long straddle metrics:

from scripts.long_straddle_calculator import LongStraddle

# Example: Earnings play on NVDA at $475
position = LongStraddle(
    underlying_price=475.00,
    strike=475.00,        # ATM strike
    call_premium=22.50,
    put_premium=21.00,
    contracts=1
)

# Key metrics
print(f"Total Cost: ${position.total_cost:.2f}")
print(f"Upper Breakeven: ${position.upper_breakeven:.2f}")
print(f"Lower Breakeven: ${position.lower_breakeven:.2f}")
print(f"Required Move: {position.required_move_percent:.1f}%")

Core Workflow

1. Identify Volatility Opportunity

Look for catalysts that create uncertainty:

Binary Events:

Earnings announcements (quarterly reports)
FDA drug approval decisions
Merger/acquisition outcomes
Legal rulings or regulatory decisions
Major product launches

Market Conditions:

Fed meetings with unclear direction
Geopolitical uncertainty
Technical breakout/breakdown setups
Historical volatility compression

Criteria:

High implied volatility (IV rank >50)
Clear catalyst date
Expected move >10% (sufficient to overcome cost)
Liquid options (tight bid/ask spreads)

See references/volatility-analysis.md.

2. IV Rank and Percentile Analysis

Assess current volatility levels:

from scripts.iv_analyzer import analyze_iv_metrics

metrics = analyze_iv_metrics(
    symbol='NVDA',
    current_iv=0.65,
    lookback_period=252  # 1 year
)

print(f"IV Rank: {metrics['iv_rank']:.0f}")          # 75 (high)
print(f"IV Percentile: {metrics['iv_percentile']:.0f}")  # 82
print(f"Expected Move: {metrics['expected_move']:.1f}%")  # 8.5%

Ideal IV Environment:

IV Rank: 50-90 (elevated but not extreme)
IV Percentile: 60-90
Historical vol < Implied vol (vol expansion expected)

⚠️ Avoid when IV rank >90 (extreme - risk of IV crush)

See references/iv-metrics-guide.md.

3. Expected Move Calculation

Calculate market's implied move:

from scripts.expected_move_calculator import calculate_expected_move

expected = calculate_expected_move(
    underlying_price=475.00,
    total_premium=43.50,  # Straddle cost
    days_to_expiration=3   # Earnings in 3 days
)

print(f"Expected Move: ${expected['dollar_move']:.2f}")  # $40.25
print(f"Expected Move %: {expected['percent_move']:.1f}%")  # 8.5%
print(f"Implied Move Range: ${expected['lower_bound']:.2f} - ${expected['upper_bound']:.2f}")

Rule of Thumb: Straddle cost ≈ 85% of expected move (1 standard deviation)

See references/expected-move-calculation.md.

4. Strike Selection

ATM Strike (Standard):

Strike nearest to current stock price
Maximum gamma (sensitivity to moves)
Highest theta decay (most expensive)
Example: Stock $475 → Strike $475

Slightly OTM Strikes (Alternative):

Lower cost but wider breakevens
Reduced gamma
Better for extreme volatility
Example: Stock $475 → Call $480 + Put $470 (actually a strangle)

For pure straddle, always use ATM strike.

See references/strike-selection-guide.md.

5. Expiration Timing

Event-Based:

Before event: 1-7 days (earnings, FDA decision)
After event: Benefit from move, but IV crush risk
Standard: Use expiration closest to event (but after)

Time-Based (No specific event):

30-45 days: Standard volatility play
14-21 days: Short-term speculation
60-90 days: Expensive, more time for move

Key: Balance premium cost vs. time for move to develop

See references/expiration-timing.md.

6. Cost-Benefit Analysis

Compare straddle cost to historical moves:

from scripts.historical_analyzer import analyze_historical_moves

analysis = analyze_historical_moves(
    symbol='NVDA',
    event_type='earnings',
    lookback_count=8  # Last 8 earnings
)

print(f"Average Earnings Move: {analysis['avg_move']:.1f}%")
print(f"Max Move: {analysis['max_move']:.1f}%")
print(f"Min Move: {analysis['min_move']:.1f}%")
print(f"Current Straddle Implies: {analysis['current_implied']:.1f}%")

Decision:

If historical avg > implied: Straddle may be underpriced ✅
If historical avg < implied: Straddle may be overpriced ❌

See references/historical-analysis.md.

7. Greeks Analysis

Monitor straddle Greeks:

from scripts.greeks_calculator import calculate_straddle_greeks

greeks = calculate_straddle_greeks(
    strike=475.00,
    underlying_price=475.00,
    call_premium=22.50,
    put_premium=21.00,
    volatility=0.65,
    time_to_expiration=3/365
)

print(f"Delta: {greeks['delta']:.3f}")    # ~0 (neutral)
print(f"Gamma: {greeks['gamma']:.3f}")    # High (sensitive)
print(f"Theta: {greeks['theta']:.3f}")    # Very negative (decay)
print(f"Vega: {greeks['vega']:.3f}")      # Positive (gains from IV)

Key Greeks:

Delta: Near zero at entry (neutral)
Gamma: Very high (rapid delta change with moves)
Theta: Very negative (time decay hurts)
Vega: Very positive (benefits from IV increase)

See references/greeks-guide.md.

8. Position Sizing

Calculate appropriate contracts:

from scripts.position_sizer import calculate_straddle_size

contracts = calculate_straddle_size(
    portfolio_value=100000,
    risk_per_trade=0.03,      # 3% max loss
    straddle_cost=4350         # $43.50 × 100
)
# Returns: 1 contract (max risk $4,350 = 4.35%)

Sizing Rules:

Risk 2-5% of portfolio (straddles are risky)
Account for 100% loss potential
Don't oversize on single event

See references/position-sizing.md.

9. Entry Execution

Order Types:

Straddle Order: Single order for both legs (best pricing)
Limit Order: Set max total premium willing to pay
Market Order: Immediate fill (wider slippage)

Best Practices:

Enter as single straddle order
Set limit at mid-point of bid/ask
Avoid entering immediately before event (IV peak)
Enter 2-5 days before catalyst (balance cost vs. time)

Timing Considerations:

Too Early: Pay for excess time decay
Too Late: IV already elevated, expensive
Optimal: 2-5 days before event (sweet spot)

10. Management and Exit

Profit Targets:

Quick Exit: 20-30% profit (avoid theta decay)
Event Exit: Close day of or after event
Breakeven Exit: Stock reaches breakeven point

Stop Loss:

Time-Based: Close if no move by event
Percentage-Based: Close at 50-70% loss (cut losses)
IV Crush: Exit immediately after event if IV drops

Post-Event Management:

Large Move: Take profits quickly (theta accelerates)
Small Move: Accept loss, exit position
IV Crush: Exit immediately (vega loss)

See references/management-strategies.md.

Scripts

Calculator

# Calculate long straddle metrics
python scripts/long_straddle_calculator.py \
  --underlying NVDA \
  --price 475 \
  --strike 475 \
  --call-premium 22.50 \
  --put-premium 21.00 \
  --contracts 1

IV Analyzer

# Analyze IV rank and percentile
python scripts/iv_analyzer.py \
  --symbol NVDA \
  --current-iv 0.65 \
  --lookback 252

Expected Move Calculator

# Calculate market's expected move
python scripts/expected_move_calculator.py \
  --price 475 \
  --total-premium 43.50 \
  --dte 3

Historical Analyzer

# Analyze historical earnings moves
python scripts/historical_analyzer.py \
  --symbol NVDA \
  --event earnings \
  --lookback 8

References

Core Guides

quickstart-guide.md - 5-minute overview
installation-guide.md - Setup instructions
developer-guide.md - Code standards

Strategy-Specific

volatility-analysis.md - IV rank, percentile, catalysts
iv-metrics-guide.md - Calculate and interpret IV metrics
expected-move-calculation.md - Market's implied move
historical-analysis.md - Compare to past moves
strike-selection-guide.md - ATM strike selection
expiration-timing.md - Optimal entry timing
greeks-guide.md - Delta, gamma, theta, vega
position-sizing.md - Risk management
management-strategies.md - Profit targets, exits
examples.md - Real earnings plays

Dependencies

Required Packages:

numpy>=1.24.0
pandas>=2.0.0
matplotlib>=3.7.0
scipy>=1.10.0
yfinance>=0.2.0  # For historical IV data

Installation:

pip install -r requirements.txt

Python Version: 3.11+

Risk Warnings

⚠️ Key Risks:

High Cost: Straddles are expensive (both legs at ATM)
Time Decay: Theta decay accelerates as expiration approaches
IV Crush: Massive vega loss after event (50-80% drop possible)
Requires Large Move: Need move beyond breakevens to profit
Both Breakevens: Must overcome premium in either direction
Event Risk: If event canceled/delayed, position loses value

Risk Mitigation:

Only use on high-probability volatility events
Exit quickly after event (avoid IV crush)
Size positions appropriately (2-5% portfolio risk)
Set stop loss at 50-70% of premium
Have exit plan BEFORE entering
Avoid holding through weekend/holiday (theta decay)

When to Use Long Straddle

✅ Ideal Scenarios:

Earnings with uncertain outcome
FDA approvals (binary yes/no)
Fed meetings with unclear direction
Technical breakout/breakdown pending
Historical moves >10% (sufficient to profit)
IV rank 50-90 (elevated but not extreme)

❌ Avoid When:

Low volatility environment (IV rank <30)
Extreme IV (>90) - risk of IV crush
No clear catalyst
Sideways market with no expected move
After event (IV already crushed)
Can't accept 100% loss potential

Comparison to Other Strategies

vs. Long Strangle:

❌ Higher cost (both ATM vs. OTM)
✅ Lower breakevens (smaller move needed)
✅ Higher gamma (more responsive)

vs. Iron Condor:

❌ Debit vs. credit (pay upfront)
✅ Unlimited profit potential
❌ Time decay hurts vs. helps

vs. Directional Play (long call/put):

✅ No directional risk
❌ Double the cost
✅ Profit from move either way

Example Trade

Scenario: NVDA earnings, stock at $475, IV rank 75

Setup:

Buy 1 NVDA $475 call @ $22.50
Buy 1 NVDA $475 put @ $21.00
Total cost: $43.50 × 100 = $4,350
Expiration: 3 days (day after earnings)
Expected move: 8.5% ($40.25)