Building and Backtesting Options Strategies with QX.FinLib

What is Backtesting and Why is it Necessary?

Before putting capital at risk, traders must validate their ideas. Backtesting is the process of applying a trading strategy to historical data to see how it would have performed in the past. It is a simulation of real-world trading that accounts for price movements, costs, and execution rules.

In options trading, backtesting is not just a "nice-to-have", it is essential for several reasons:

• Risk Quantification: Unlike stocks, options have non-linear risks. Backtesting helps you understand your "Maximum Drawdown" and how your strategy behaves during volatility spikes.
• Theta Decay Validation:You can verify if the time decay (Theta) you expect to collect actually offsets the potential price movement (Delta) against your position.
• Avoiding Curve Fitting: By testing across different market cycles (bull, bear, and sideways), you ensure your strategy is robust and not just lucky during a specific month.
• Confidence Building: Execution is psychologically easier when you have data proving that a strategy has a positive "Expected Value" over hundreds of trades.

Introduction

Options trading offers unique opportunities for generating alpha through volatility, time decay, and directional exposure. However, backtesting options strategies presents significant challenges:

• Data Complexity: Each options contract (strike, expiry, type) is a unique instrument.
• Non-Linear P&L: Options have asymmetric payoff profiles.
• Time Decay (Theta): Options lose value as expiration approaches.
• Volatility Sensitivity (Vega): Changes in implied volatility affect option prices.

The QX.FinLib framework solves these challenges by providing a powerful abstraction layer that allows strategy developers to focus on alpha generation rather than data management complexities.

In this article, we will build a practical Straddle Strategy that:

1. Enters an ATM (At-the-Money) straddle position at a configurable time (e.g., 09:30 AM).
2. Optionally triggers entry based on the underlying's SuperTrend behavior.
3. Exits on a percentage-based stop-loss or at end-of-day (15:20 PM).

Part 1: Understanding the Data Normalization Layer

Before writing strategies, it is crucial to understand how QX.FinLib manages the underlying data. Robust backtesting relies on a "Single Source of Truth"—a normalized database where disparate exchange feeds are cleaned and structured into a uniform format.

Required Historical Data Structure

Options backtesting requires high-resolution data typically stored in a relational database like MySQL. QX.FinLib expects a specific schema to perform its abstraction magic. Each record represents a 1-minute snapshot of a specific contract.

Note on Data Integrity:To ensure fast lookups and data uniqueness, the database must use a Composite Primary Key consisting of .

The QX.FinLib Symbology Standard

To automate strike selection and expiry handling, the library enforces a strict naming convention. This allows the framework to "parse" an instrument name to understand its Greeks and moneyness without constant database metadata queries.

1. Options Symbology

The pattern follows:

• Example: NIFTY2801202524000CE
• NIFTY: Underlying Symbol
• 28012025: Expiry Date (January 28, 2025)
• 24000: Strike Price
• CE: Option Type (European Call)

2. Continuous Futures Symbology

For strategies involving futures hedging or trend-following on underlying momentum, QX.FinLib uses a Roman numeral suffix to handle rollovers:

• NIFTY-I: Current month (Near) expiry contract.
• NIFTY-II: Next month (Mid) expiry contract.

3. Spot Index Symbology

For cash-settled indices used as the primary reference for ATM (At-the-Money) calculations:

• NIFTY 50: Standard identifier for the NIFTY Index spot price.

Part 2: Defining Strategy Requirements and Code Structure

Now that we understand the data layer, let’s define the logic for a 2-Leg Options Strategy. In QX.FinLib, a "Leg" is the foundational building block of any multi-leg strategy (like a Straddle, Strangle, or Iron Condor).

Defining Strategy Legs

LegDefination leg1Defination = new LegDefination() 
{ 
    OrderSide = OrderSide.Sell, 
    OptionType = OptionType.CE, 
    OptionMoneyLess = OptionMoneyLess.ATM, 
    StopLossDetail = StopLossDetail.GetStopLossPercentageBased(30), 
    ProfitTargetDetail = ProfitTargetDetail.GetProfitTargetPercentageBased(50) 
}; 

[StrategyAttribute("{2340A2B6-3FF8-491C-B216-CF660A420ABC}", "MultiLegX1", "MultiLegX1", "QXT")] 
public class MainStrategy : StrategyBase 
{ 
    // Strategy Parameters accessible via UI 
    [Parameter("Leg1", Description = "Leg1 Options", DefaultValue = "")] 
    private string _leg1 = ""; 
    [Parameter("Leg2", Description = "Leg2 Options", DefaultValue = "")] 
    private string _leg2 = ""; 
    [Parameter("TradeStartTime", Description = "The trade start time", DefaultValue = 092000)] 
    private int TradeStartTime = 092000; 
    [Parameter("TradeEndTime", Description = "The trade end time", DefaultValue = 152000)] 
    private int TradeEndTime = 152000; 
    // Internal state variables 
    LegDefination _leg1Defination = null; 
    LegDefination _leg2Defination = null; 
    private OptionsInstrumentInfoAccessor _optionsInstrumentInfoAccessor = null; 
    private bool _entryDone = false; 
    public MainStrategy() { } 
    protected override void Initialize() { } 
    protected override void OnStateChanged() 
    { 
        if (StrategyState == StrategyState.ActiveMode) 
        { 
            // Initialize the Options Accessor provided by the framework 
            _optionsInstrumentInfoAccessor = this.OptionCommandAccessor.GetOptionsInstrumentInfoAccessor(); 
            // Load leg definitions from JSON parameters 
            _leg1Defination = JsonConvert.DeserializeObject(_leg1); 
            _leg2Defination = JsonConvert.DeserializeObject(_leg2); 
        } 
    } 
    public override string GetInfoText() 
    { 
        return string.Empty; 
    }  
}  

public override void ProcessStrategy() 
{ 
    IBarData barData = TimeDataSeries[CurrentIndex]; 
    int currentTime = TimeNum();  
    // 1. Entry Logic 
    if(!_entryDone && currentTime == TradeStartTime) 
    { 
        OptionsInstrument callOptions; 
        OptionsInstrument putOptions; 
        // Dynamic ATM lookup 
        this.OptionCommandAccessor.GetATMOptionPair(barData.Close, barData.DateTimeDT, 0, out callOptions, out putOptions); 
        this.OptionCommandAccessor.EnterShortAtMarket(callOptions, 1, "Short Straddle Entry"); 
        this.OptionCommandAccessor.EnterShortAtMarket(putOptions, 1, "Short Straddle Entry"); 
_leg1Option = callOptions; 
_leg2Option = putOptions 
        _entryDone = true; 
    } 
    // 2. Risk Management (Stop Loss / Profit Target) 
    double slHitPrice = 0; 
    if (this.OptionCommandAccessor.IsStopLossHit(_leg1Option, _leg1Defination.StopLossDetail, out slHitPrice)) 
    { 
        this.OptionCommandAccessor.GoFlatAtMarket(_leg1Option, $"SL Hit at {slHitPrice}"); 
    } 
    // 3. EOD Square-off 
    if (currentTime >= TradeEndTime && _entryDone) 
    { 
        this.OptionCommandAccessor.GoFlatAtMarket(_leg1Option, "EOD Exit"); 
        _entryDone = false; 
    } 
}