Derivatives trading: theory to algo execution

Explain the roles of exchanges, clearing houses, and market participants in Indian derivatives markets.

Interpret contract specifications for Nifty, Bank Nifty options and stock futures on the NSE.

Describe the margining system (SPAN, exposure margin) and its impact on capital requirements.

Apply the cost-of-carry model to price forwards and futures and identify arbitrage opportunities.

Apply put-call parity for European options to identify arbitrage opportunities and construct synthetic positions.

Explain the intuition behind risk-neutral pricing and why it works for derivatives valuation.

Construct a simple Monte Carlo simulation in Python to estimate the expected payoff of an option.

Construct a one-step binomial tree to price a European option using a replicating portfolio.

Extend the binomial model to multi-step trees and price American options, accounting for early exercise.

Outline the conceptual steps for deriving the Black-Scholes-Merton formula, from the asset price model to risk-neutral expectation.

Execute the mathematical derivation of the Black-Scholes-Merton formula for a European call option.

Price European calls and puts using the Black-Scholes-Merton formula and interpret each input parameter.

Calculate implied volatility from observed market prices using iterative numerical methods in Python.

Price a European option using Monte Carlo simulation in Python and compare the result to the Black-Scholes price.

Explain the assumptions and limitations of the Black-Scholes-Merton model.

Distinguish between historical, implied, and realized volatility and explain their respective uses in trading.

Explain the common shapes of the volatility smile and skew and their underlying economic causes.

Construct and interpret a volatility surface from market option prices across strikes and expirations.

Describe the term structure of volatility and its implications for trading across different expiration cycles.

Explain the concept of the volatility risk premium by comparing historical and implied volatility data.

Explain the intuition behind GARCH models for volatility forecasting.

Fit a GARCH(1,1) model to historical return data in Python to generate a volatility forecast.

Conceptually compare local volatility and stochastic volatility models and their implications for pricing.

Derive Delta from the Black-Scholes formula and interpret its meaning as a hedge ratio and probability proxy.

Derive Gamma from the Black-Scholes formula and interpret its role in measuring delta stability and position convexity.

Derive Vega and Theta from the Black-Scholes formula and explain their impact on an option's value.

Analyze the practical interplay and trade-offs between all major Greeks across different market regimes.

Calculate and interpret the aggregate Greek exposures for a multi-leg options portfolio.

Implement a dynamic delta hedging strategy for a short option position and analyze its P&L drivers.

Implement the mechanics of a gamma scalping strategy by re-hedging to maintain delta neutrality.

Analyze the P&L of a gamma scalping strategy, attributing performance to the spread between realized and implied volatility.

Construct covered calls and protective puts, draw their payoff diagrams, and identify optimal market conditions.

Design vertical spreads (bull call, bear put) to express a directional view with defined risk.

Construct straddles and strangles to trade non-directional views on volatility.

Build iron condors and iron butterflies for range-bound, income-generating strategies.

Design calendar and diagonal spreads to trade volatility term structure and time decay differentials.

Build ratio and backspreads to create asymmetric payoff profiles.

Develop a decision framework for selecting an appropriate options strategy based on market outlook and implied volatility.

Analyze the P&L of a multi-leg strategy under different scenarios using Python simulation.

Analyze historical implied volatility patterns around earnings announcements to identify IV expansion and crush phenomena.

Structure an options strategy (e.g., a short straddle or iron butterfly) to capitalize on post-event IV crush.

Design a trade to capitalize on expected volatility changes during a major macroeconomic event (e.g., the Union Budget).

Develop a realized volatility forecast and construct a delta-neutral trade to exploit the implied-realized volatility spread.

Explain how volatility skew changes create trading opportunities.

Design a specific skew trading strategy, such as a risk reversal, to express a view on tail risk.

Execute futures basis trading strategies and analyze the convergence of futures to spot at expiry.

Implement a pairs trading strategy using two correlated stock futures to create a market-neutral position.

Translate a discretionary options strategy into systematic rules covering signal logic, entry, exit, and risk management.

Implement a systematic covered call strategy in Python with defined entry triggers and exit rules.

Implement a systematic iron condor strategy in Python that is managed based on price boundaries or delta thresholds.

Define systematic rules for a volatility trading strategy based on implied volatility percentile signals.

Implement the systematic volatility trading strategy in Python, translating the rules into executable code.

Structure the framework for a gamma scalping algorithm, defining the initial position and hedging parameters.

Implement the core dynamic hedging logic that triggers delta-neutralizing trades based on predefined thresholds.

Code P&L attribution for the gamma scalping strategy, separating scalp gains from theta decay costs.

Design the high-level architecture of an event-driven backtester, defining its core components (Data, Strategy, Portfolio, Execution).

Implement a data handler component capable of providing historical options data tick-by-tick or bar-by-bar.

Implement a portfolio component that tracks positions, cash, and market values upon receiving fill events.

Integrate the components into a core backtesting loop that processes market data events sequentially.

Model transaction costs and slippage in the execution handler to ensure realistic P&L estimation.

Refactor a previously implemented strategy (e.g., systematic iron condor) into the modular backtesting framework.

Evaluate backtest performance using key metrics: Sharpe ratio, max drawdown, Calmar ratio, and trade statistics.

Apply position sizing frameworks, including fixed fractional and the Kelly criterion, to a backtested strategy.

Explain the architecture of an automated trading system, from signal generation to order execution.

Authenticate and connect to the Zerodha Kite Connect API to fetch real-time quotes and user data.

Programmatically place, modify, and cancel single-leg and multi-leg orders using the API.

Manage a live portfolio by fetching current positions and open orders.

Implement a websocket client to stream real-time market data for multiple instruments.

Develop a strategy execution loop that listens to live data and triggers trades based on predefined logic.

Integrate pre-trade risk checks, such as maximum order quantity and position limits, into the execution logic.

Build a robust error handling and logging mechanism for the live trading application.

Implement real-time risk controls including portfolio-level loss limits and kill switches.

Set up a monitoring dashboard and alerting system for live strategy execution.

Perform stress testing on a multi-leg options portfolio by shocking key risk variables (spot, volatility) and analyzing P&L.

Define target portfolio Greek exposures (e.g., delta-neutral, vega-positive) and establish rules for re-hedging.

Outline a cloud deployment architecture for a trading bot using scheduled execution (e.g., cron jobs on a VPS).

Containerize a trading application using Docker for portability and consistent deployment.

Build a volatility regime detection system using a simple metric like a moving average of implied volatility.

Design a meta-strategy that adapts strategy selection or capital allocation based on the detected volatility regime.

Formulate a novel trading hypothesis based on a perceived market inefficiency or pattern.

Gather and process the necessary historical data to research and validate the hypothesis.

Develop a complete set of systematic rules for a new trading strategy based on the validated hypothesis.

Implement the strategy within the event-driven backtesting framework and rigorously evaluate its historical performance.

Write a comprehensive strategy report detailing the hypothesis, backtest results, and risk analysis.

Implement the full execution logic for the strategy using the Zerodha Kite Connect API.

Build and test a minimal deployment pipeline for the strategy, including logging and basic risk controls.

Present the final strategy, including its logic, performance, and a demonstration of the live execution module.