Adjusting Option Spreads: Rolling Strategies

1. What is "Rolling" a Credit Spread?

At its core, "rolling" is the simultaneous process of closing your existing credit spread and opening a new one on the same underlying asset. This new spread will have different parameters—typically a later expiration date and/or different strike prices.

The primary goals of rolling a defensive trade are:

1. Extend Duration: Give the trade more time to work out by moving to a later expiration date ("rolling out").
2. Improve Position: Move the strike prices further away from the underlying asset's price to reduce directional risk, i.e., to lower the position's delta ("rolling up" or "rolling down").
3. Improve Risk/Reward: Execute the entire roll for a net credit, which increases your total potential profit and reduces your total potential loss.

To get a solid grasp of this concept, let's watch a video that explains it clearly.

As the video explains, by collecting a net credit, you are essentially getting paid to extend the trade and improve its characteristics. If you were to roll for a debit, you would be paying to stay in the trade, increasing your total risk. The golden rule of defensive rolling is: always try to roll for a credit.

2. The Triggers: When Should You Roll?

Knowing how to roll is one thing; knowing when is another. A systematic approach requires predefined triggers. Rolling isn't something you do on a whim; it's a calculated response to specific market conditions and changes in your position's risk profile.

The most common triggers for adjusting a credit spread are:

• Time-Based Trigger (DTE): As a spread gets closer to expiration (e.g., under 21 Days To Expiration), gamma risk increases dramatically. This means the position's delta can change very rapidly with small movements in the underlying price. Rolling out to a further expiration pushes you back out on the time decay curve where theta is your friend and gamma is less of a threat.
• Delta-Based Trigger: The delta of your spread tells you its directional exposure. For a bull put spread, the delta is positive. As the underlying price falls and challenges your short put strike, the delta of the spread will increase, signaling greater risk. You can set a threshold (e.g., if net delta > 0.50) to trigger an adjustment. This is the core of "managing the position's delta."

Let's watch another segment of the video, which details these conditions.

Based on this, our adjustment logic will be triggered when both the DTE is below a certain threshold and the delta has exceeded its risk limit.

3. Implementing Adjustment Logic in Our Framework

Now, let's translate this into code. We will modify the manage_position method in our strategy class. Currently, it returns 'CLOSE_PROFIT', 'CLOSE_STOPLOSS', or 'HOLD'. We will add a new return value: 'ADJUST'.

The main event loop will interpret this 'ADJUST' signal. It will instruct the ExecutionHandler to close the current position. Because the position is now closed, on the next loop iteration, the strategy will naturally look for a new trade opportunity, effectively "rolling" into a new position if one meets the entry criteria. This design keeps the strategy's role focused on decision-making, while the framework's main loop orchestrates the actions.

Here is the updated BullPutSpread class with adjustment parameters and logic. You'll notice we are re-purposing the idea of a delta threshold, similar to what the Alpaca Markets article on the Bull Put Spread mentions, but as an adjustment trigger instead of a hard stop.

# In framework/strategies.py

# ... other imports from previous lessons ...
from framework.interfaces import Strategy, AnalyticsEngine

class BullPutSpread(Strategy):
    def __init__(self, symbol: str, params: dict):
        super().__init__(name=f"BullPutSpread_{symbol}")
        self.symbol = symbol
        # Entry parameters
        self.min_dte = params.get('min_dte', 21)
        self.max_dte = params.get('max_dte', 60)
        # ... other entry params ...
        
        # Position Management Parameters
        self.profit_target_pct = params.get('profit_target_pct', 0.50)
        self.stop_loss_multiplier = params.get('stop_loss_multiplier', 2.0)
        
        # --- NEW Adjustment Parameters ---
        self.allow_adjustments = params.get('allow_adjustments', True)
        self.adjustment_dte_trigger = params.get('adjustment_dte_trigger', 21)
        self.adjustment_delta_trigger = params.get('adjustment_delta_trigger', 0.50)

    # ... find_trade_opportunity and other methods remain unchanged ...

    def manage_position(
        self, 
        position: dict, 
        data_handler, 
        analytics_engine: AnalyticsEngine
    ) -> str:
        """
        Checks if the position should be closed, adjusted, or held.
        Returns 'CLOSE_PROFIT', 'CLOSE_STOPLOSS', 'ADJUST', or 'HOLD'.
        """
        # 1. Extract necessary info and get current data
        short_leg_symbol = position['short_leg']['symbol']
        long_leg_symbol = position['long_leg']['symbol']
        initial_credit = position['initial_credit']
        
        short_leg_quote = data_handler.get_latest_quote(short_leg_symbol)
        long_leg_quote = data_handler.get_latest_quote(long_leg_symbol)
        
        if not short_leg_quote or not long_leg_quote:
            print(f"Could not retrieve current quotes for {self.symbol} position. Holding.")
            return 'HOLD'

        # 2. Calculate current state
        cost_to_close = short_leg_quote['ask_price'] - long_leg_quote['bid_price']
        
        # Assume analytics_engine can calculate these. We'll build this in a future lesson.
        # For now, imagine these functions exist and work.
        greeks = analytics_engine.calculate_spread_greeks(position)
        net_delta = greeks['delta']
        dte = analytics_engine.calculate_dte(position['short_leg']['expiry'])

        # 3. Check for Profit Target
        target_cost_to_close = initial_credit * (1 - self.profit_target_pct)
        if cost_to_close <= target_cost_to_close:
            return 'CLOSE_PROFIT'

        # 4. Check for Stop-Loss
        stop_loss_price = initial_credit * self.stop_loss_multiplier
        if cost_to_close >= stop_loss_price:
            return 'CLOSE_STOPLOSS'
        
        # 5. --- NEW: Check for Adjustment Trigger ---
        if self.allow_adjustments:
            is_delta_breached = net_delta >= self.adjustment_delta_trigger
            is_time_to_roll = dte <= self.adjustment_dte_trigger
            
            if is_delta_breached and is_time_to_roll:
                print(
                    f"ADJUSTMENT TRIGGERED for {self.symbol}. "
                    f"Net Delta ({net_delta:.2f}) breached threshold ({self.adjustment_delta_trigger}) "
                    f"AND DTE ({dte}) is at or below trigger ({self.adjustment_dte_trigger}). "
                    f"Signaling to roll position."
                )
                return 'ADJUST'
                
        # 6. If no other condition is met, hold
        return 'HOLD'

The logic is now prioritized: check for a win, check for a hard loss, and only then check for a potential adjustment. If none of these conditions are met, we hold the position.

4. The Challenges of Rolling: No Free Lunch

Rolling is a powerful tool, but it's not a magical fix. It's crucial to understand its limitations.

1. You Can't Always Roll for a Credit: As a trade moves deeper in the money, the cost to close the existing spread skyrockets. At some point, the credit you can get from opening a new spread is not enough to offset this cost, and you would have to roll for a debit. This is where your hard stop-loss becomes essential.

2. Volatility Skew Can Work Against You: For equity indexes like SPY, there is typically a "put skew," meaning out-of-the-money puts have higher implied volatility than out-of-the-money calls. When rolling a bull put spread, you are closing your existing puts and opening new ones. This skew can sometimes make it harder to get a favorable credit compared to rolling a bear call spread, where you are dealing with calls that have relatively lower IV.

To understand these challenges in more detail, let's watch one more clip.

The takeaway is that adjustment is a tool to be used within a specific window of opportunity. Once a trade has gone too far against you, the best course of action is often to accept the loss and move on, as dictated by your stop-loss rule.

Conclusion

Excellent work today. You have now integrated a sophisticated adjustment technique into your strategy's logic. By moving beyond a simple hold-or-close dichotomy, you are building a system that can adapt to changing market conditions and actively manage risk.

Key Takeaways:

• Rolling is an adjustment technique that involves closing a position and opening a new one with a later expiration and/or different strikes.
• The primary goals are to give a trade more time, reduce its directional risk (delta), and collect a net credit.
• We implemented adjustment logic based on triggers for DTE and net delta, adding an 'ADJUST' signal to our manage_position method.
• Adjustments are not always possible; if a trade is too far gone, you may not be able to roll for a credit, and the stop-loss remains your final line of defense.

Preview of the Next Lesson:
Our manage_position method now relies on having up-to-date information like P&L, DTE, and the Greeks. But how does it get this information? In the next lesson, we will focus on the mechanism for this: Create a function to continuously monitor the Profit & Loss (P&L) and Greeks of open positions. This will provide the critical data feed for all our position management decisions.