Short Jade Lizard Strategy: Premium Capture with Controlled Risk

Looking to generate consistent income in a neutral-to-slightly bullish market? The Short Jade Lizard strategy is designed for scenarios where the underlying asset is expected to remain stable or move moderately higher. By combining a short put with a call spread, this strategy allows traders to collect premium while structuring the position to eliminate upside risk and manage downside exposure.

In this blog, we’ll explore how the Short Jade Lizard works, its entry and exit conditions, key risk considerations and how it performs across different market scenarios.

Understanding the Short Jade Lizard Strategy

The Short Jade Lizard is a multi-leg options strategy constructed using both puts and calls. It is typically established for a net credit and is designed to benefit from time decay when the market stays within a range while also accommodating a moderate upward move in the underlying.

The strategy benefits from:

• stable or range-bound price movement
• time decay (theta decay)
• only downside exposure with no upside risk (when structured correctly)

Structure of a Short Jade Lizard

The standard structure involves:

• Sell 1 Out-of-the-Money (OTM) Put Option
• Sell 1 Out-of-the-Money (OTM) Call Option
• Buy 1 Further Out-of-the-Money (OTM) Call Option

(This creates a short put combined with a bear call spread. The structure is typically set such that the total premium received exceeds the width of the call spread, eliminating upside risk.)

How the Short Jade Lizard Strategy Works

1. Entry Criteria

Eligible Markets: The Short Jade Lizard is best suited for markets where price is expected to remain relatively stable or move within a defined range, with a slight bullish bias. It performs well in conditions where large directional moves are unlikely and time decay can be effectively captured.

Ideal instruments include:

• Indices: NSE’s NIFTY 50, FIN NIFTY and US-based indices such as the S&P 500 (SPX) and Nasdaq 100 (QQQ).
• Stocks: Indian large-cap stocks with active options markets, such as RELIANCE, INFY and HDFCBANK, along with US large-cap stocks such as AAPL, TSLA, NFLX and JNJ.

Strike Price Selection: The Short Jade Lizard is typically constructed by selling an OTM put, selling an OTM call and buying a farther OTM call for upside protection. Strike selection plays an important role in balancing premium collection, probability of profit and overall risk exposure:

• OTM Short Put: A short put strike closer to the underlying price increases premium collection but also increases downside exposure if the market declines sharply. Selecting a farther OTM put reduces downside risk at the cost of lower premium income.
• OTM Short Call: The short call strike is generally placed above the underlying price to collect additional premium while maintaining room for moderate upside movement. A closer short call increases premium collection but reduces upside tolerance.
• Farther OTM Long Call: The long call strike is selected above the short call strike to hedge upside exposure. The distance between the short and long call strikes affects hedge cost, retained premium and the extent to which upside risk is reduced or eliminated.

Expiry Selection: Expiry choice affects time decay, premium collection and overall position behaviour:

• Weekly Expiry: Suitable for short-term premium collection strategies where the underlying is expected to remain stable over the near term. However, faster time decay and sudden volatility spikes should be monitored carefully.

• Monthly Expiry: Provides more time for option premiums to decay gradually, resulting in smoother position behaviour and lower sensitivity to short-term market fluctuations.

Lot Size & Positioning: Position sizing should align with the trader’s risk tolerance and capital allocation. While the strategy eliminates or significantly reduces upside risk when structured correctly, downside exposure from the short put remains substantial during sharp bearish moves. Proper position sizing helps maintain controlled drawdowns during volatile market conditions.

Timeframes: The Short Jade Lizard can be deployed across multiple timeframes, typically ranging from 1 to 60 minutes for systematic setups.

• Lower timeframes allow more active position monitoring and quicker adjustments to changing market conditions.
• Higher timeframes are better suited for identifying stable, range-bound environments with lower directional momentum.

For intraday premium-selling strategies, lower timeframes such as 1-minute and 5-minute intervals can be effective when combined with disciplined entry conditions and risk controls.

2. Exit Rules & Re-Entry Strategy

The Short Jade Lizard follows structured exit and re-entry rules to manage downside exposure while continuing to benefit from time decay in stable market conditions.

The strategy exits an active position under the following scenarios:

• Profit Target Reached:
  The position is closed when the predefined profit target is achieved based on the net premium collected or mark-to-market gains. This allows profits from time decay and stable price movement to be systematically locked in rather than exposed to sudden market reversals.
• Stop-Loss Triggered:
  If the strategy’s net premium or mark-to-market loss breaches the configured stop-loss threshold, all legs are exited to limit downside risk. This becomes especially important during sharp bearish moves, where losses from the short put position can increase rapidly.
• Strategy-Level P&L Exit:
  The strategy exits the entire position structure once the combined strategy profit or loss reaches predefined thresholds, helping maintain disciplined risk management.

Re-Entry Logic

The strategy allows re-entry after the existing position structure has been fully exited. Following a profit target exit or a stop-loss exit, a new Short Jade Lizard position can be initiated provided no active position is currently open.

This approach allows the strategy to continue participating in favourable premium-selling conditions while maintaining a structured and systematic execution process.

Alternative Exit Strategies

• Short-Leg Stop-Loss Exit:
  A stop-loss can be applied specifically to the short option legs to limit adverse directional or volatility-driven expansion in option premiums. This is particularly useful since the strategy carries a mildly directional bias and can become vulnerable during strong moves against the expected market direction. If the price of a short leg rises beyond the configured stop-loss threshold, the strategy exits all associated positions to prevent uncontrolled risk and maintain the defined-risk structure.
• Trailing Stop-Loss:
  Instead of a fixed options-premium stop-loss, a trailing stop-loss can be applied at either the options premium or strategy level. As the position moves into profit through premium decay, the stop dynamically adjusts to lock in gains while allowing continued participation in favourable market conditions.
  If the trailing threshold is breached at the strategy level, the entire strategy exits and stops further execution. If the trailing threshold is breached only at the options net-premium level, the open positions are exited while still allowing the strategy to re-enter later if fresh entry conditions are satisfied again.
• Time-Based Exit:
  Positions may be closed after a predefined portion of the expiry cycle has elapsed, particularly if sufficient premium decay has already occurred or if market conditions become increasingly volatile. This helps manage overnight risk and frees capital for new opportunities.

Figure 1: Short Jade Lizard Strategy Execution Flowchart (Values align with the first sample in the upcoming Profit & Loss Calculations section).

This section details the Python implementation of a Short Jade Lizard strategy with fixed strike spacing, target/stop-loss based premium exits and automated re-entry logic.

Selecting Instruments and Strikes for Entry

def strategy_select_instruments_for_entry(self, candle, instruments_bucket):
   selected_instruments, meta = [], []

   for instrument in instruments_bucket:
       self.logger.debug(
           f"Checking entry conditions for base instrument: {instrument} | "
           f"Determining OTM option instruments and verifying if CE/PE orders are already placed."
       )

       # Define a list of tuples for managing legs, their types, and relevant orders
       leg_wise_list = [
           ("leg_ce_sell_otm", "CE", self.number_of_strikes_otm_ce_sell, "SELL", self.child_instrument_main_orders.get(instrument, {}).get('leg_ce_sell_otm')),
           ("leg_ce_buy_otm", "CE", self.number_of_strikes_otm_ce_buy, "BUY", self.child_instrument_main_orders.get(instrument, {}).get('leg_ce_buy_otm')),
           ("leg_pe_sell_otm", "PE", self.number_of_strikes_otm_pe_sell, "SELL", self.child_instrument_main_orders.get(instrument, {}).get('leg_pe_sell_otm'))
       ]

       # Initialize re-entry count for this base instrument, else decrement remaining re-entries
       if self.reentry_left.get(instrument) is None:
           self.reentry_left[instrument] = self.reentry_count
       elif self.reentry_left[instrument] > 0:
           self.reentry_left[instrument] -= 1
       else:
           self.logger.debug(f"No more reentries left for {instrument}")
           if not any(self.reentry_left.values()):
               self.execution_complete = True
           continue

       # Proceed only if no open orders or if there are reentries left
       if not self.child_instrument_main_orders.get(instrument):
           current_underlying_price = self.broker.get_ltp(instrument)
           for leg, tradingsymbol_suffix, no_of_strikes, action, main_order in leg_wise_list:
               self.options_instruments_set_up_all_expiries(instrument, tradingsymbol_suffix, current_underlying_price)
               child_instrument = self.get_child_instrument_details(instrument, tradingsymbol_suffix, OptionsStrikeDirection.OTM.value, no_of_strikes)  # Retrieve child base_instrument details for the given base_instrument
               self.instruments_mapper.add_mappings(instrument, child_instrument)  # Maps each base_instrument to its child in the instruments' mapper for further processing.
               selected_instruments.append(child_instrument)
               meta.append({"leg": leg, "action": action, "base_instrument": instrument})

   return selected_instruments, meta

Code Explanation:

1. Multi-Leg Structure

leg_wise_list = [
    ("leg_ce_sell_otm", "CE", self.number_of_strikes_otm_ce_sell, "SELL", ...),
    ("leg_ce_buy_otm", "CE", self.number_of_strikes_otm_ce_buy, "BUY", ...),
    ("leg_pe_sell_otm", "PE", self.number_of_strikes_otm_pe_sell, "SELL", ...)
]

The Short Jade Lizard structure is defined programmatically using a leg-wise configuration list.

Each tuple specifies:

• Leg identifier
• Option type (CE / PE)
• Strike distance
• Transaction type (BUY / SELL)
• Existing order reference

This modular structure simplifies leg-wise order placement and management while allowing strike distances and leg configurations to remain parameter-driven.

2. Re-Entry Management Logic

if self.reentry_left.get(instrument) is None:
    self.reentry_left[instrument] = self.reentry_count
elif self.reentry_left[instrument] > 0:
    self.reentry_left[instrument] -= 1

The strategy tracks remaining re-entries for each base instrument. Once the configured re-entry count is exhausted, no further positions are allowed for that instrument.

This helps:

• Prevent excessive repeated entries
• Control exposure during volatile conditions
• Maintain disciplined execution behaviour

3. Preventing Duplicate Active Positions

if not self.child_instrument_main_orders.get(instrument):

New positions are created only if no active child orders already exist for the base instrument.

This prevents:

• Duplicate entries
• Overlapping option structures
• Unintended risk amplification

4. Fetching Underlying Price Once

current_underlying_price = self.broker.get_ltp(instrument)

The latest traded price (LTP) of the base instrument is retrieved once and reused across all option-leg strike calculations.

This ensures:

• Consistent strike selection using the same market snapshot
• Reduced unnecessary broker/API calls
• Avoidance of minor price discrepancies between legs during fast market movement

This is especially important in multi-leg option strategies where all legs should be constructed using a synchronized underlying price reference.

5. Option Chain Setup Before Strike Selection

self.options_instruments_set_up_all_expiries(
    instrument,
    tradingsymbol_suffix,
    current_underlying_price
)

Before selecting strikes, the system ensures option instruments for the required option type and available expiries are initialized and cached.

This guarantees:

• Valid strike availability
• Correct expiry selection
• Reliable instrument lookup

By default, the strategy selects the nearest monthly expiry unless configured otherwise.

It acts as a preparation step before constructing the option legs.

6. Dynamic Strike Selection

child_instrument = self.get_child_instrument_details(
    instrument,
    tradingsymbol_suffix,
    OptionsStrikeDirection.OTM.value,
    no_of_strikes
)

Option strikes are selected dynamically using:

• Current underlying price
• Option type (CE/PE)
• Configured OTM strike distance
• Selected expiry type (monthly expiry by default)

This allows the strategy structure to automatically adapt to changing market prices instead of relying on hardcoded strikes.

7. Instrument Mapping and Execution Metadata

self.instruments_mapper.add_mappings(instrument, child_instrument)

selected_instruments.append(child_instrument)

meta.append({
    "leg": leg,
    "action": action,
    "base_instrument": instrument
})

Each option leg is mapped to its parent instrument, while execution metadata is stored separately.

This enables:

• Structured multi-leg order management
• Leg-wise tracking and monitoring
• Coordinated execution and exits across the strategy structure

Creating an Order for a Position

def strategy_enter_position(self, candle, instrument, meta):
   _order = None
   child_instrument = instrument
   base_instrument = self.instruments_mapper.get_base_instrument(child_instrument)
   ltp_current = self.broker.get_ltp(child_instrument)
   quantity = self.number_of_lots * child_instrument.lot_size
   _order = self.broker.OrderRegular(
       child_instrument, meta['action'], order_code=self.order_code, order_variety=BrokerOrderVarietyConstants.LIMIT, position=BrokerExistingOrderPositionConstants.ENTER, price=ltp_current, quantity=quantity
   )
   if check_order_placed_successfully(_order) and check_order_complete_status(_order):
       self.child_instrument_main_orders.setdefault(base_instrument, {})[meta['leg']] = _order
   else:
       # Protection logic incase any of the legs fail to get placed - this will help avoid having naked positions
       self.logger.critical('Order placement failed for one of the legs. Exiting position for other legs...')
       self.exit_all_positions_for_base_instrument(base_instrument)
   return _order

Code Explanation:

1. Base-to-Child Instrument Mapping

base_instrument = self.instruments_mapper.get_base_instrument(child_instrument)

Before placing the order, the strategy resolves the parent instrument corresponding to the option leg.

This mapping is essential for:

• Grouping all Jade Lizard legs under a single underlying
• Coordinated multi-leg position management
• Structured exit handling across all legs

It ensures the complete strategy structure remains logically connected.

2. Dynamic Quantity Calculation

quantity = self.number_of_lots * child_instrument.lot_size

Order quantity is calculated dynamically using:

• Configured number of lots
• Exchange-defined lot size

This makes the strategy:

• Parameter-driven
• Easily scalable
• Consistent across different instruments and expiries

3. Order Placement and Fill Confirmation

if check_order_placed_successfully(_order) and check_order_complete_status(_order):

The strategy validates both:

• Successful order placement
• Successful order completion/fill status

before considering a leg as active.

This is important in multi-leg option strategies because:

• A placed order may remain partially filled or unfilled
• Incomplete fills can distort the intended payoff structure
• Subsequent legs should only be tracked after confirmed execution

This additional validation helps maintain execution consistency across the complete Short Jade Lizard structure.

4. Order Tracking Upon Successful Placement

self.child_instrument_main_orders.setdefault(base_instrument, {})[meta['leg']] = _order

Once an order is successfully placed and completed, it is stored in the strategy’s tracking structure using the leg identifier.

This enables:

• Leg-wise position tracking
• Coordinated exits across the Jade Lizard structure
• Monitoring of active BUY and SELL legs independently
• Detection of incomplete or partially exited structures

Using setdefault() also ensures safe initialization of the nested tracking dictionary.

5. Protection Against Partial Strategy Execution

if check_order_placed_successfully(_order) and check_order_complete_status(_order):
    self.child_instrument_main_orders.setdefault(base_instrument, {})[meta['leg']] = _order
else:
    self.logger.critical(
        'Order placement failed for one of the legs. Exiting position for other legs...'
    )
    self.exit_all_positions_for_base_instrument(base_instrument)

If any leg fails to place successfully or remains incomplete, the strategy immediately exits all other legs associated with the base instrument.

This protection mechanism prevents:

• Partial multi-leg structures
• Accidental naked option exposure
• Unhedged directional risk

It ensures the Short Jade Lizard maintains its intended defined-risk structure at all times.
Exit Condition Checks

def check_exit_condition(self, base_instrument, main_orders):
   """ Determines if the strategy should exit based on Target/Stoploss Net Premium. Returns True if exit condition is met. """
   ott_multiplier = {"BUY": 1, "SELL": -1}

   # Target/Stoploss Net Premium Check
   current_net_premium = sum([ott_multiplier[order.order_transaction_type.value] * self.broker.get_ltp(order.instrument) for order in main_orders])
   if not self.entry_net_premium.get(base_instrument):
       self.entry_net_premium[base_instrument] = sum(
           ott_multiplier[order.order_transaction_type.value] * order.entry_price for order in main_orders) if not self.entry_net_premium else self.entry_net_premium
       self.stoploss_premium[base_instrument] = self.entry_net_premium[base_instrument] * (1 + self.stoploss_percentage / 100)
       self.target_premium[base_instrument] = self.entry_net_premium[base_instrument] * (1 - self.target_percentage / 100)

   self.logger.debug(f"For {base_instrument}: "
                     f"Net Entry Premium: {self.entry_net_premium[base_instrument]:.2f} | Current Net Premium: {current_net_premium:.2f} | Stoploss Threshold: {self.stoploss_premium[base_instrument]:.2f} | Target Threshold: {self.target_premium[base_instrument]:.2f}")

   target_profit_condition = current_net_premium > self.target_premium[base_instrument]
   if target_profit_condition:
       self.logger.debug(f"For {base_instrument}: Net Premium Target profit reached - Current Net Premium ({current_net_premium:.2f}) dropped below Target Threshold ({self.target_premium[base_instrument]:.2f}). Exiting positions...")
       return True

   stop_loss_condition = current_net_premium < self.stoploss_premium[base_instrument]
   if stop_loss_condition:
       self.logger.debug(f"For {base_instrument}: Net Premium Stoploss triggered - Current Net Premium ({current_net_premium:.2f}) exceeded Stoploss Threshold ({self.stoploss_premium[base_instrument]:.2f}). Exiting positions...")
       return True

   return False

Code Explanation:

1. Net Premium Calculation Using Leg Direction Multipliers

ott_multiplier = {
    BrokerOrderTransactionTypeConstants."BUY": 1,
    BrokerOrderTransactionTypeConstants."SELL": -1
}

current_net_premium = sum([
    ott_multiplier[order.order_transaction_type.value] *
    self.broker.get_ltp(order.instrument)
    for order in main_orders
])

The strategy calculates the live net premium of the complete Short Jade Lizard structure using transaction-type multipliers.

Logic:

• BUY legs contribute positively, representing premium outflow
• SELL legs contribute negatively, representing premium inflow

This produces the true mark-to-market premium value of the overall strategy rather than evaluating each leg independently.

This is important because:

• Multi-leg risk is assessed collectively
• Real spread exposure is captured accurately
• Exit decisions reflect actual strategy-level P&L dynamics

2. One-Time Entry Premium Initialization

if not self.entry_net_premium.get(base_instrument):
    self.entry_net_premium[base_instrument] = sum(
        ott_multiplier[order.order_transaction_type.value] *
        order.entry_price for order in main_orders
    )

The net entry premium is calculated and stored only once during the trade lifecycle.

This entry reference acts as the baseline for:

• Stop-loss threshold calculation
• Profit-target calculation
• Future premium comparisons

Storing it once prevents:

• Threshold drift
• Dynamic recalibration during live trades
• Inconsistent exit behaviour

3. Dynamic Construction of Target and Stop-Loss Thresholds

self.stoploss_premium[base_instrument] = (
    self.entry_net_premium[base_instrument] *
    (1 + self.stoploss_percentage / 100)
)

self.target_premium[base_instrument] = (
    self.entry_net_premium[base_instrument] *
    (1 - self.target_percentage / 100)
)

Target and stop-loss thresholds are derived dynamically from the original entry net premium.

Behaviour:

• Net premium expansion → stop-loss condition
• Net premium contraction → profit target condition

This aligns naturally with premium-selling strategies like the Short Jade Lizard, where:

• Profit is generated through premium decay
• Risk increases when premium expands

The thresholds remain fully parameter-driven and adaptable.

4. Real-Time Net Premium Monitoring

target_profit_condition = (
    current_net_premium >
    self.target_premium[base_instrument]
)

stop_loss_condition = (
    current_net_premium <
    self.stoploss_premium[base_instrument]
)

The strategy continuously compares the live net premium against predefined thresholds.

Since the Short Jade Lizard is a net credit strategy, the combined net premium values remain negative. As option premiums decay in favour of the strategy, the net premium moves closer to zero, while adverse movement causes the net premium to expand further negatively.

Exit conditions trigger when:

• Net Premium contracts to the target threshold → profit booked
• Net Premium expands to the stop-loss threshold → risk capped

This provides:

• Continuous trade-level risk monitoring
• Structured premium-based exits
• Consistent strategy behaviour across market conditions

5. Threshold Storage Per Base Instrument

self.stoploss_premium[base_instrument] = ...
self.target_premium[base_instrument] = ...

The strategy stores target and stop-loss thresholds separately for each base instrument.

This is important because:

• Multiple instruments may run simultaneously
• Each strategy instance maintains independent premium levels
• Exit thresholds remain isolated per underlying instrument

This design prevents threshold overlap between instruments and enables clean multi-instrument strategy execution.
Validation in Short Jade Lizard

def validate_parameters(self):
   """ Validates required strategy parameters. """

   # Validate number of options strikes and re-entry parameters
   for param in (self.number_of_strikes_otm_ce_sell, self.number_of_strikes_otm_ce_buy, self.number_of_strikes_otm_pe_sell, self.reentry_count):
       check_argument(param, "extern_function", is_positive_int, "NUMBER_OF_STRIKES_OTM_* or REENTRY_COUNT parameter should be positive integers (> 0)")

   # Validate target and stoploss percentage parameters
   for param in (self.target_percentage, self.stoploss_percentage):
       check_argument(param, "extern_function", is_nonnegative_int_or_float, "Value should be >0.0")

Code Explanation:

The validate_parameters function ensures all required strategy inputs are present and logically valid before any trading logic executes. This prevents runtime failures and protects the integrity of the strategy configuration.

Failure Case 1: Invalid Strike Distance or Re-Entry Parameters

self.number_of_strikes_otm_ce_sell = 0
self.number_of_strikes_otm_ce_buy = -2
self.number_of_strikes_otm_pe_sell = "3"
self.reentry_count = -1

validate_parameters()

Error:

NUMBER_OF_STRIKES_OTM_* or REENTRY_COUNT parameter should be positive integers (> 0)

Reason:

The following parameters must be strictly positive integers (> 0):

• number_of_strikes_otm_ce_sell
• number_of_strikes_otm_ce_buy
• number_of_strikes_otm_pe_sell
• reentry_count

Invalid inputs include:

• Zero values
• Negative values
• Non-integer types

These parameters control:

• OTM strike selection
• Multi-leg structure construction
• Re-entry behaviour

Improper values could result in invalid option selection or inconsistent strategy execution

Failure Case 2: Invalid Target or Stop-Loss Percentage Inputs

self.target_percentage = -5
self.stoploss_percentage = "ten"

validate_parameters()

Error:

Value should be >0.0

Reason:

The following parameters must be non-negative numeric values:

• target_percentage
• stoploss_percentage

Invalid inputs include:

• Negative percentages
• Non-numeric values

These parameters directly control:

• Premium target exits
• Stop-loss thresholds
• Overall strategy-level risk management

Invalid values could distort exit calculations and compromise the strategy’s defined-risk behaviour.

💡 Want to see the complete strategy? Check out the full implementation here.

Ideal Market Conditions for Short Jade Lizard
When to Use

The Short Jade Lizard works best when the market is expected to remain relatively stable or move within a defined range, with a mildly bullish outlook. The strategy is designed to benefit from time decay, making it most effective when the underlying is unlikely to experience sharp moves in either direction.

Typical scenarios include:

• Range-Bound Markets: After a period where price is moving within a defined range without strong directional momentum, allowing option premiums to decay over time.
• Post-Consolidation Phases: After a directional move, when the market stabilises and begins to trade sideways, reducing the likelihood of immediate large price swings.
• Low Volatility Environments: Markets with relatively low implied volatility, that are expected to remain stable or gradually decline, supporting consistent premium decay.
• Mildly Bullish Conditions: When the underlying shows a slight upward bias without signs of a strong breakout, allowing the strategy to benefit from both time decay and limited upward movement.

Interpreting the Short Jade Lizard Payoff Structure

The following payoff diagram illustrates the profit and loss dynamics of a Short Jade Lizard strategy. The values used correspond to those depicted in the flowchart.

Figure 2: Profit and Loss Diagram

The green curve represents the profit zone of the strategy. In a Short Jade Lizard, the position benefits when the underlying remains within a stable range and avoids sharp downside movement. The strategy primarily profits from time decay, allowing the collected option premium to gradually erode in favour of the trader as expiration approaches. Maximum profit is achieved when the underlying remains above the short put strike while staying below the short call strike at expiry, allowing all options to expire worthless.

Unlike directional breakout strategies, the Short Jade Lizard is structured to perform best in stable or mildly bullish market conditions rather than during highly volatile price swings. The dotted green line marks the target profit level, where traders may choose to exit systematically and lock in gains once sufficient premium decay has occurred.

The red curve represents the loss region, which is concentrated on the downside due to the short put exposure. If the underlying declines sharply below the lower breakeven level, losses begin to increase progressively. However, upside risk remains eliminated due to the call spread structure, causing the payoff to flatten beyond the long call strike instead of creating unlimited losses. The red dashed stop-loss line highlights the predefined risk threshold used for disciplined trade management.

Key dashed markers highlight the important price reference points:

• Lower breakeven marks the level where the payoff transitions from profit to loss on the downside.
• Short put strike identifies the level above which the strategy achieves maximum profit at expiry.
• Short call strike indicates the beginning of the call spread region.
• Long call strike represents the hedge level where upside risk becomes capped.
• Target profit and stop-loss thresholds outline the active risk management boundaries applied during execution.

Profit and Loss Calculations for Low and High Risk Versions

1. Low-Risk Short Jade Lizard

The previous diagram sets up an example for the low-risk version of the short jade lizard.

Key Parameters

• Target Profit (target_percentage): 50% of the net credit
• Stop-Loss (stoploss_percentage): 30% of the net credit
• Instrument: FINNIFTY Index
• Expiration Type: Nearest Monthly Expiry
• Strike Selection:
• Leg One: 2 strikes away from ATM (OTM Put Sell) - 20150
• Leg Two: 2 strikes away from ATM (OTM Call Sell) - 20350
• Leg Three: 4 strikes away from ATM (Further OTM Call Buy) - 20450

(Short Jade Lizard structure: short put + call spread)

• Re-entry Levels:
  • Re-Entry Trigger: Re-entry is initiated after the previous positions have been fully exited, provided no active position is currently open.

Calculations

(Assume a simple 1:1 relationship between the FINIFTY Index and the spread for illustration.)

• Total Premium Collected: ₹120 (Put) + ₹80 (Call) = ₹200
• Total Premium Paid: ₹40 (Long Call)
• Net Premium Received: ₹120 + ₹80 − ₹40 = ₹160
• Target Profit (0.5 × Net Credit):
  160 × 0.50 = ₹80
  Exit when profit reaches +₹80
• Stop-Loss (0.3 × Net Credit):

160 × 0.30 = ₹48
Exit when loss reaches –₹48

• Maximum Profit Calculation:

Maximum Profit = Net Premium Received = ₹160

This occurs when FINNIFTY remains above the put strike (20150) and below the call spread (20350) at expiration, allowing all options to expire worthless.

• Maximum Loss Calculation:
  Maximum Loss = Put Strike – Net Credit
  The risk is on the downside (short put side) and occurs when the underlying falls to 0 at expiry.
• Breakeven Points:
• Lower Breakeven: Put Strike − Net Credit = 20150 − 160 = 19990
• Upper Breakeven: None (eliminated due to call spread structure)

P&L Outcomes:

2. High-Risk Short Jade Lizard
The diagram below illustrates the profit and loss structure for the high-risk variation of the short jade lizard strategy:

Figure 3: Profit and Loss Diagram - High Risk Version

The following example illustrates the high-risk Short Jade Lizard constructed on a liquid US large-cap stock, TSLA. The setup is designed to generate higher premium income in exchange for increased downside exposure due to the higher volatility of the underlying.

Key Parameters

• Target Profit (target_percentage): 60% of the net credit
• Stop-Loss (stoploss_percentage): 40% of the net credit
• Instrument: TSLA (Tesla Inc.)
• Expiration Type: Nearest Weekly Expiry
• Strike Selection:
• Leg One: 3 strikes away from ATM (OTM Put Sell) - $240
• Leg Two: 3 strikes away from ATM (OTM Call Sell) - $270
• Leg Three: 4 strikes away from ATM (Further OTM Call Buy) - $275
  (Short Jade Lizard structure: short put + call spread)
• Re-entry Levels:
  • Re-Entry Trigger: Re-entry is initiated after the previous positions have been fully exited, provided no active position is currently open.

Calculations

(Assume a simple 1:1 relationship between the TSLA stock underlying and the spread for illustration.)

• Total Premium Collected: $9.00 (Put) + $4.00 (Call) = $13.00
• Total Premium Paid: $1.50 (Long Call)
• Net Premium Received: $13.00 − $1.50 = $11.50
• Target Profit (0.6 × Net Credit):

11.50 × 0.60 = $6.90

Exit when profit reaches +$6.90

• Stop-Loss (0.4 × Net Credit):

11.50 × 0.40 = $4.60

Exit when loss reaches –$4.60

• Maximum Profit Calculation:

Maximum Profit = Net Premium Received = $11.50

This occurs when TSLA remains above the put strike ($240) and below the short call strike ($270) at expiration, allowing all options to expire worthless.

• Maximum Loss Calculation:
  Maximum Loss = Put Strike – Net Credit
  The risk is on the downside (short put side) and occurs when the underlying falls to 0 at expiry.

• Breakeven Points:

  • Lower Breakeven: Put Strike − Net Credit = 240 − 11.50 = $228.50
  • Upper Breakeven: None (eliminated due to call spread structure)

The low-risk version of the Short Jade Lizard is designed with a more conservative structure, using controlled premium collection and tighter downside exposure to suit relatively stable market environments.

The high-risk version, on the other hand, uses more aggressive strike placement to increase premium potential and overall return opportunities. While this can improve profitability in calm or mildly bullish conditions, it also exposes the strategy to larger fluctuations and greater downside risk during sharp market declines.

To better understand how the Short Jade Lizard compares with other premium-selling approaches, the comparison below highlights the differences in payoff structure and risk profile between the Short Jade Lizard and the Short Strangle.

Comparing Short Jade Lizard and Short Strangle

The Short Jade Lizard and the Short Strangle are premium-selling options strategies designed to benefit from stable or range-bound market conditions. Both strategies aim to generate income through time decay, but they differ significantly in how they manage upside risk.

The Short Strangle profits when the underlying remains within a defined range, but it carries unlimited risk on both the upside and downside due to the uncovered short options.

In contrast, the Short Jade Lizard modifies the structure by adding a long call hedge, which removes or significantly reduces upside risk while still allowing the strategy to benefit from premium decay in stable market conditions.

Figure 4: Short Jade Lizard vs. Short Strangle Mind Tree

Which One Is Right for You?

If you expect the market to remain relatively stable with a slight bullish bias and prefer a premium-selling strategy with capped upside risk, the Short Jade Lizard may be more suitable. This strategy combines a short put with a hedged call structure, allowing traders to benefit from time decay while reducing or eliminating upside risk. It performs best when the underlying stays within a defined range without sharp directional movement.

If you are comfortable taking on higher risk in exchange for greater premium collection and expect the market to remain range-bound with low volatility, the Short Strangle may be more appropriate. Since both the call and put are sold uncovered, the strategy can generate higher premium income, but it also carries substantial risk if the underlying moves sharply in either direction.

The Short Jade Lizard offers a more risk-controlled alternative to the Short Strangle by capping upside exposure through the long call hedge. Choose this strategy if you want to participate in premium decay opportunities while maintaining more structured risk on the upside.

To read more about the Short Strangle strategy, refer to our detailed blog here:

Customize the Strategy with Your Own Parameters!

Traders can fine-tune strike selection, expiry choice, stop-loss levels, and profit targets based on risk tolerance.

💡 Want to see the complete strategy? Check out the full implementation here.

👉 For testing on the Phoenix platform of AlgoBulls, head over to our site now!

👉 A Jupyter notebook for this strategy is coming soon. Meanwhile, check out All Available Notebooks for Testing Custom Strategies!

Final Thoughts

The Short Jade Lizard works best as a structured premium-selling strategy rather than a passive hold-until-expiry position. It is designed to benefit from time decay and stable market conditions while maintaining controlled upside risk through its built-in call hedge.

This setup performs most effectively when combined with disciplined risk management and clearly defined exit conditions. Profit targets, stop-loss thresholds and controlled re-entry rules help the strategy remain aligned with the intended range-bound or mildly bullish market outlook while limiting exposure during adverse market moves.

Rather than relying solely on expiry outcomes, the focus is on systematic and responsive trade management that adapts to changing market conditions and protects against sudden increases in volatility or directional momentum.

Key Risk-Mitigation Techniques
✔ Incorporated in the Strategy (Recap)

Target Profit & Hard Stop-Loss:
The strategy exits automatically once predefined profit or loss thresholds are reached, helping systematically lock in gains from premium decay while limiting downside exposure during adverse market moves.
Strategy-Level P&L Exit:
The complete structure may also be exited based on overall strategy-level profit or loss conditions, supporting disciplined and systematic risk management.
✔ Additional Enhancements

Position Refinement:

Strike placement, call spread width and lot sizing can be dynamically adjusted based on market volatility and directional outlook. In higher-volatility environments, wider strike spacing may help accommodate larger price swings while maintaining controlled upside exposure. Strike selection may also be refined using volatility or trend-based filters to better align the structure with prevailing market conditions.

Volatility-Based Entry Filtering:

Additional volatility filters may be incorporated to avoid initiating positions during highly unstable market conditions. Restricting entries during periods of excessive volatility expansion can help reduce exposure to sharp directional moves and improve the consistency of premium decay opportunities.