Our Learning Paths
Rigorous, high-density courses built for quick scanning and faster decisions. Filter by strategy and find your edge.
Quantitative Finance
73 courses
Understanding the Mathematical Toolkit for Quant Finance: What You Actually Need
A finance-first orientation to the mathematics behind quantitative investing, written for engineers, coders, and systematic traders who want to know which tools matter before committing months to textbooks. Instead of teaching every subject in depth, this course shows where probability, statistics, linear algebra, calculus, time series, optimisation, and numerical methods actually appear in real quant work: sizing a Nifty 50 position, building a covariance matrix from NSE returns, backtesting a momentum rule, pricing a Bank Nifty option, and reading a risk report. Each lesson pairs the concept with a worked Indian example and a clear verdict on how deep you need to go. You finish with a personal study plan and a checklist of the maths you can defer until a specific strategy demands it.
- Which branches of mathematics quant roles actually use daily, and which are mostly interview theatre
- How to think in probabilities and expected value when sizing a position on the NSE
- Why the covariance matrix, not individual stock volatility, decides the risk of a portfolio
Advanced Machine Learning Techniques for Trading: Ensembles and Deep Learning
A rigorous, code-first path into applying ensemble methods and deep learning to systematic trading, for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from correct labeling of market data through random forests, gradient boosting, and stacked ensembles, into recurrent networks and convolutional architectures for sequential price data, with an honest look at where deep learning helps and where it overfits. Built on real NSE and BSE data (Nifty 200, Nifty Bank, sector baskets), with Python throughout.
Advanced Options Strategies: Volatility Arbitrage and Skew Trading
A quant-grade deep dive into volatility trading: how the implied volatility surface is built from the NSE options chain, why skew and term structure exist, and how prop desks and systematic traders extract edge from them through dispersion, risk reversals, calendar spreads, and vanna-volga adjustments.
- How to construct and read the implied volatility surface from live NSE options chain data
- Why volatility skew and smile exist and how to quantify them using risk reversals and butterflies
- How to trade volatility term structure shifts around events like Budget, RBI policy, and earnings
Advanced Regime Switching Models for Strategy Allocation
A rigorous, code-first path into regime detection and regime-switching strategy allocation for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from rule-based regime flags through Hidden Markov Models, Markov-switching regression, regime-conditional strategy design, capital allocation, rigorous backtesting, and risk management through regime transitions. Built on real Nifty, Bank Nifty, and NSE data, with Python throughout.
Advanced Risk Management: Value at Risk and Stress Testing
A rigorous, formula-first treatment of Value at Risk and stress testing built for quant researcher aspirants, prop trading applicants, and systematic traders who already understand volatility and returns. Covers the three core VaR methodologies (historical simulation, parametric, and Monte Carlo), why VaR breaks down at the tails and how Expected Shortfall fixes it, how to backtest a VaR model properly, and how to build a stress testing framework using real Indian market crises like the 2008 GFC, the 2013 taper tantrum, and the 2020 COVID crash, applied to Nifty, Bank Nifty, and individual NSE stocks.
Advanced Statistical Arbitrage: Multi Factor Approaches
A rigorous, code-first path into statistical arbitrage and multi-factor investing for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from cointegration and pairs trading through basket mean-reversion, factor construction, signal combination, portfolio risk, honest backtesting, execution microstructure, and the SEBI algo-trading and tax framework that governs running this live in India. Built on real NSE and BSE data (Nifty 500 pairs, sector baskets, Kite Connect execution), with Python throughout.
Case Study: Analyzing a Momentum Strategy's Performance Across Market Cycles
A backtest that shows 18 percent CAGR over twenty years tells you almost nothing until you know where those returns came from and when they disappeared. This intermediate case study takes a completed cross-sectional momentum strategy on the Nifty 500 universe, the same 12-1 monthly rebalanced design built in our beginner backtesting course, and puts it through the analysis a prop desk or quant fund would run before allocating capital. You will define Indian market regimes from 2005 to 2025 using rules rather than hindsight, slice the track record by bull, bear, sideways and recovery phases, dissect the momentum crashes of 2009 and 2020, measure drawdown depth against duration, run rolling Sharpe and beta, attribute returns to sectors, size and style factors, and price the STT, brokerage and short-term capital gains tax that vary with turnover across cycles. The course ends with the performance memo a hiring manager expects, and a verdict on what should change before the strategy runs with real money.
- How to define bull, bear, sideways and recovery regimes for Indian equities with transparent rules that cannot be tuned in hindsight
- How to compute conditional returns, hit rates and turnover for a momentum portfolio inside each regime, and why the averages hide the story
- Why momentum crashes when markets rebound sharply, using the 2009 and 2020 Nifty recoveries as worked examples
Case Study: Analyzing the 2020 Covid Crash Through a Volatility Lens
A beginner-friendly quant case study that re-reads the March 2020 Covid crash using volatility as the measuring instrument instead of price. You will learn what realized and implied volatility actually measure, how NSE computes India VIX, and then apply those tools to the actual 2020 timeline: the calm January, the 38% collapse in Nifty, VIX at 86, two circuit-breaker halts, and the V-shaped recovery. The final chapter shows how to reproduce every chart in Python and turn the lessons into a simple volatility-aware position-sizing rule.
- What volatility measures, how it is calculated from daily returns, and why it is the quant's preferred lens for a crash
- How NSE builds India VIX from the Nifty options chain and what a reading of 12 versus 86 actually implies
- The day-by-day volatility story of January to June 2020 on NSE, including the 13 March and 23 March circuit-breaker halts
Case Study: Archegos Capital's Collapse Through a Risk Management Lens
In March 2021 a single family office lost roughly USD 20 billion of its own capital in two trading days and handed its prime brokers more than USD 10 billion in losses, without ever owning most of the shares it was betting on. This case study rebuilds Archegos Capital's book, its total return swap financing, and the margin-call cascade that unwound it, then dissects every risk control that should have stopped it and did not. Built for aspiring quant researchers, prop desk applicants and systematic traders scaling up leverage, with each lesson mapped to the Indian framework: SEBI position limits, NSE margining, broker pledging rules and the concentration traps that exist on Indian exchanges too.
- Reconstruct how a USD 10 billion family office built USD 50 billion of hidden exposure using total return swaps across eight prime brokers
- Trace the March 2021 margin-call cascade day by day and explain why the fastest bank to sell lost nothing while the slowest lost USD 5.5 billion
- Diagnose the specific risk-control failures at Credit Suisse: static margining, ignored limit breaches, potential exposure blind spots and governance gaps
Case Study: Building and Scaling a Volatility Arbitrage Desk
A case study that follows a two-person Mumbai prop desk from a first delta-hedged Nifty straddle to a fifty crore volatility book. You build the pricing and Greeks toolkit, run the core short gamma book and the relative value overlays (skew, term structure, dispersion), design the risk limits and margin discipline that keep a short volatility desk alive on gap days, move from Excel to a production stack on broker APIs, and work through SEBI's F&O and algo framework, taxation, and entity structure. Every chapter closes with a case drawn from real NSE events, and every number is worked in INR on Nifty and Bank Nifty options.
- Measure the volatility risk premium on Nifty and Bank Nifty using India VIX and realized volatility estimators
- Price and risk manage an options book with a Black-76 engine and a full Greeks ladder (delta, gamma, vega, theta, vanna, volga)
- Run a delta-hedged short gamma book and attribute its P&L to theta, gamma, vega and hedging costs
Case Study: Comparing Buy and Hold vs a Simple Systematic Strategy
A hands-on case study for coders, engineers and quant-curious investors who want to know whether a simple rule can actually beat doing nothing. You will take two clearly defined approaches, buying and holding the Nifty 50 through an index fund, and a 200-day moving average rule that moves between the Nifty 50 and a liquid fund, and put them through the same test on the same Indian data. Along the way you will learn why the Total Return Index matters, how to build both equity curves in Python, how to read CAGR, drawdown, Sharpe and time under water without fooling yourself, and how brokerage, STT, exit loads, capital gains tax and whipsaws change the verdict. The course ends with an honest scorecard and a framework you can reuse to judge any strategy against buy and hold.
- What buy and hold actually commits you to, and why most investors who claim to follow it do not
- What separates a systematic strategy from a hunch: a written rule, a signal, a schedule and no discretion
- How to set up a fair comparison with the same data, the same period, the same starting capital and no cherry-picking
Case Study: Comparing Systematic Strategy Performance Pre and Post Covid
March 2020 split the Indian market into two worlds. Volatility, correlation, liquidity and the retail investor base all changed within weeks, and every systematic strategy that had been tuned on the calm years before it was suddenly running on unfamiliar ground. This case study walks through how momentum, mean reversion, trend following and low volatility strategies behaved across the pre Covid, crash, recovery and post Covid windows on NSE, how to measure that behaviour honestly after costs, and how to diagnose why the numbers moved. Built for aspiring quant analysts, prop desk applicants and discretionary traders who are systematising their process and need to show they can evaluate a strategy across regimes rather than on one lucky backtest.
- Split a market history into defensible regime windows and justify the boundaries with data rather than hindsight
- Compute and interpret CAGR, Sharpe, Sortino, maximum drawdown, rolling returns and time under water for a systematic strategy
- Explain why momentum, mean reversion, trend following and low volatility behaved so differently across the Covid crash and recovery on NSE
Case Study: How Alternative Data Predicted Retail Earnings Surprises
An advanced case study built around Meridian Quant, a fictional Mumbai systematic fund, and its analyst Priya Nair, who is asked one question: can data that arrives before a quarter ends tell us whether DMart, Trent, Titan or V-Mart will beat or miss consensus? Each chapter is one stage of the project: mapping the retail P&L to what alternative data can actually observe, assembling an Indian data stack from GST and UPI aggregates, Google Trends, app-download panels, scraped store locators and price trackers, engineering point-in-time features, building and backtesting a revenue nowcast against Bloomberg and Refinitiv consensus, walking through three real earnings quarters where the model called a beat, called a miss, and got it wrong, and finally turning the forecast into a sized, risk-controlled event trade that survives crowding, signal decay and SEBI's insider-trading line. Built for aspiring quant researchers, prop-desk applicants and systematic traders who want to see a complete alternative-data pipeline in an Indian context, with the failures left in.
- Map an Indian retailer's P&L to the alternative datasets that can observe each line item before results are announced
- Source and clean Indian alternative data: GST and e-way bill aggregates, UPI volumes, Google Trends, app-download panels, scraped store counts and price trackers
- Engineer point-in-time features aligned to Indian fiscal quarters without look-ahead bias
Case Study: How LTCM's Statistical Arbitrage Strategy Failed
In 1998 a hedge fund run by two Nobel laureates and Wall Street's best bond arbitrageurs lost roughly USD 4.6 billion in under five months and had to be rescued by a Federal Reserve-brokered consortium of 14 banks. Long-Term Capital Management's edge was relative-value and convergence trading, the direct ancestor of today's statistical arbitrage: buy the cheap twin, sell the expensive one, wait for the spread to close. This case study rebuilds the trades, the leverage and the risk models, walks through the Russian default and the August-September 1998 unwind, and dissects why a strategy that was right on average still blew up. Built for aspiring quant analysts, prop desk applicants and traders systematizing a pairs or spread strategy, with every lesson mapped to NSE pairs trades, arbitrage funds, SEBI margining and Indian liquidity crises.
- Explain how LTCM's convergence trades worked, from on-the-run versus off-the-run Treasuries to the Royal Dutch/Shell pair, and how they relate to modern statistical arbitrage
- Reconstruct how roughly USD 4.7 billion of equity supported a balance sheet above USD 100 billion and over USD 1 trillion of derivatives notional
- Trace the Russian default of August 1998 and the flight to liquidity that pushed every LTCM spread wider at the same time
Case Study: How Renaissance Technologies' Philosophy Applies to Retail Quant
A case study breaking down Renaissance Technologies and the Medallion Fund: what actually made the firm different, which of its principles are genuinely learnable by a retail trader, and where the comparison breaks down. Written for engineers, coders, and systematic traders who want the substance behind the legend, not the mythology.
- What Renaissance Technologies and the Medallion Fund actually did, separated from the popular mythology around them
- Which of Renaissance's principles (uncorrelated small edges, data discipline, systematic risk control) are genuinely usable by a retail trader
- Why capital, infrastructure and data access mean you cannot replicate Medallion from a retail brokerage account
Case Study: Reconstructing a Simple Machine Learning Model for Stock Direction Prediction
A hands-on case study for quant analyst aspirants, prop trading applicants and traders who want to systematise their process. We take a typical claim you will see on social media, a simple machine learning model that 'predicts next-day Nifty direction with high accuracy', and reconstruct it step by step in Python on real NSE data. Along the way you will frame direction prediction as a classification problem, build labels and features correctly, catch the look-ahead leakage that inflates most published results, train logistic regression and random forest models with walk-forward validation, and judge them with the right metrics instead of raw accuracy. The course ends by turning predicted probabilities into a trading rule, subtracting real Indian costs on Nifty futures, testing the edge across regimes like 2020 and 2022, and delivering an honest verdict on what a simple ML model can and cannot do.
- Why stock direction models look so impressive in screenshots and what questions to ask before believing any accuracy claim
- How to frame next-day or next-week direction as a supervised classification problem with clean, well-defined labels
- How to build a Nifty 50 daily dataset in Python and engineer features such as lagged returns, RSI, moving average gaps and India VIX
Case Study: The 2018 Volmageddon Event, A Volatility Strategy Post Mortem
On 5 February 2018 the VIX more than doubled in a single session and XIV, an exchange-traded note that had returned hundreds of percent by selling volatility, lost over 90 percent of its value after the closing bell. It was not a black swan. It was the predictable result of a strategy with negative convexity, a product that had to buy exactly what was spiking, and a crowd that had mistaken a long calm stretch for low risk. This intermediate case study rebuilds the event the way a risk desk would: the VIX futures term structure that made the trade look like free money, the daily rebalancing maths that turned a bad day into a terminal one, the acceleration clause that ended XIV, and the risk metrics that hid the tail. Then it turns the lens on India, where short straddles and strangles on Nifty and Bank Nifty options are the same trade in local clothing, and on the India VIX shocks of March 2020 and 4 June 2024. You finish with a post-mortem memo and a deployment checklist for any short-volatility strategy.
- Why selling volatility produced smooth, high returns from 2012 to 2017 and why that smoothness was itself the warning
- How the VIX, VIX futures and contango worked together to create the roll yield that short-vol products harvested
- How daily-rebalanced inverse volatility ETNs were forced to buy VIX futures into a spike, and how to compute that rebalancing need yourself
Case Study: Understanding Flash Crashes Through Market Microstructure
A case-study driven walk through market microstructure: how order books, market makers and liquidity actually work, what happened minute by minute during the May 2010 Flash Crash and India's own fat-finger and circuit-breaker moments, and how NSE/BSE safeguards and SEBI's algo trading rules try to prevent a repeat. Built for engineers, coders and systematic traders who want the mechanics, not just the headlines.
- How order books, bid-ask spreads and market makers actually work
- What triggered the May 2010 Flash Crash, minute by minute
- How liquidity evaporation creates a feedback loop that crashes prices
Case Study: Using Monte Carlo Simulation to Estimate Portfolio Value at Risk
An end-to-end case study for quant analyst aspirants, prop trading applicants, and systematizing traders. You follow one ₹1 crore portfolio of Nifty 50 stocks and a gold ETF from raw NSE price data to a finished risk memo: estimating the covariance matrix, correlating random shocks with Cholesky decomposition, choosing between normal and fat-tailed distributions, simulating 10,000 scenarios in Python, extracting VaR and Expected Shortfall, then backtesting, stress testing, and decomposing the result the way a real risk desk would.
- Build a Monte Carlo VaR model for a real multi-asset Indian portfolio from scratch
- Estimate volatilities and a covariance matrix from NSE price history
- Use Cholesky decomposition to generate correlated return scenarios
Introduction to Machine Learning for Trading: What Actually Works
A clear-eyed, myth-busting path into using machine learning for trading, built for quant analyst aspirants, prop trading applicants, and traders looking to systematize their process. Covers where ML actually adds value versus where it is just curve-fitting in disguise, correct problem framing (prediction vs signal vs execution), the data leakage and look-ahead traps that quietly wreck most beginner models, honest model selection between linear, tree-based, and deep learning approaches, and how a validated signal turns into a strategy once transaction costs and slippage are accounted for. Built on real NSE and BSE data, with Python throughout.
- Why most 'ML for trading' claims online are curve-fitting dressed up as skill, and how to tell the difference
- How to frame a trading problem correctly before touching a single model: prediction vs signal vs execution
- How to spot and eliminate data leakage and look-ahead bias in your features and labels
Introduction to Monte Carlo Simulation in Quantitative Finance
A hands-on, formula-first introduction to Monte Carlo simulation for quant analyst aspirants, prop trading applicants, and systematizing traders. Builds up from randomness and probability fundamentals to simulating stock price paths with Geometric Brownian Motion, pricing options via simulation, and estimating Value at Risk. Grounded entirely in Nifty 50 and Indian market data.
Introduction to Options Pricing Models: Black-Scholes Explained
A rigorous but accessible walkthrough of how options are actually priced, built for aspiring quant analysts, prop trading applicants, and traders who want to move past chart-reading into the math underneath. Covers geometric Brownian motion, risk-neutral valuation, the Black-Scholes formula step by step, and the Greeks that drive real hedging decisions. Uses Nifty and Bank Nifty option chains, India VIX, and Zerodha/NSE data throughout so every formula lands on a real, checkable Indian market number.
Introduction to Portfolio Optimization: Markowitz and Beyond
A rigorous, formula-first path into modern portfolio theory for quant analyst aspirants, prop trading applicants, and systematizing traders. Covers portfolio return and variance, covariance and correlation, the Markowitz efficient frontier, the Capital Market Line and its link to CAPM, and the practical extensions (Black-Litterman, risk parity, factor-based construction) that fix mean-variance optimization's real-world weaknesses. Built entirely on Nifty 50, Nifty Bank, and Nifty IT data.
Introduction to Quantitative Finance: What Quants Actually Do
A practical, myth-busting guide to what quantitative finance actually involves, where quants work in India and globally, what the job looks like day to day, the core skills that matter, and how to actually break in.
- Explore the quant landscape and where quants actually work
- See a day in the life and the quant toolkit
- Learn practical paths for getting into quantitative finance
Introduction to Risk Metrics: Sharpe Ratio, Sortino Ratio, Drawdown
A clear, formula-first walkthrough of the three risk metrics every serious investor and systematic trader needs: the Sharpe ratio, the Sortino ratio, and maximum drawdown. Learn what each one actually measures, how to calculate it on real Indian market data, where each one breaks down, and how to read them together instead of in isolation.
- Learn why risk-adjusted returns matter more than raw returns
- Calculate and interpret the Sharpe and Sortino ratios
- Understand drawdown and recovery to judge portfolio risk
Introduction to SQL for Storing and Querying Market Data
A first course in SQL built entirely around Indian market data, for engineering graduates, working coders and traders who want to store and query price history properly instead of wrestling with spreadsheets. Sets up a free local database with SQLite and DB Browser, then teaches SELECT, WHERE, sorting, aggregation and GROUP BY by working directly with NSE and BSE bhavcopy data. Moves on to real schema design, primary keys, and joins across stocks, prices and sector tables, finishing with subqueries and CTEs for the kind of multi-step questions a quant or systematic trader actually asks of their data.
Introduction to Statistical Arbitrage
A rigorous, from-first-principles path into statistical arbitrage for quant analyst aspirants, prop trading applicants, and traders looking to systematize their trading. Covers market-neutral thinking, correlation and spread construction, the z-score as a trading signal, formal cointegration testing (stationarity, the Augmented Dickey-Fuller test, Engle-Granger), building and running a real pairs trade, dynamic hedge ratios with the Kalman filter, the risk and cost realities that make backtests lie, and a first look at factor-based stat arb with orthogonalization. Built entirely on real NSE and BSE data, with Python throughout.
- How statistical arbitrage isolates alpha from a relationship between two assets instead of a directional market call
- How to build a spread and turn it into a z-score trading signal
- How to formally test whether a pair is cointegrated using the Augmented Dickey-Fuller and Engle-Granger tests
Introduction to Statistics for Trading and Investing
A foundation course in statistics for trading and investing, built for engineering graduates, coders, data scientists and systematic traders. Covers descriptive statistics, probability, distributions, correlation and regression, and hypothesis testing, all grounded in NSE and BSE market data, with worked calculations, real Indian stock examples, and hands-on practice exercises in every lesson.
- Calculate and interpret mean, variance, standard deviation, skewness and kurtosis on real stock return data
- Apply probability rules and Bayes' theorem to trading decisions
- Understand why fat tails and log-normal distributions matter more than the normal distribution in real markets
Introduction to Systematic Trading vs Discretionary Trading
A clear, jargon-free comparison of the two ways to trade markets: by written rules that are tested and executed the same way every time, or by human judgement applied trade by trade. Built for engineering graduates and coders curious about quant work, and for active traders who want to know whether their process should be systematized. Covers what each style actually is, how a systematic rule is written and backtested, what human discretion does well and badly, how to compare the two honestly on returns, risk, costs and scalability in Indian markets, and how to pick the path that fits your temperament, time and capital. Uses NSE and BSE examples throughout, with real Indian tools and cost structures.
- What separates a systematic trader from a discretionary one, and why 'algorithmic' and 'systematic' are not the same thing
- How a trading idea becomes a written rule with a universe, signal, entry, exit and position size, and how that rule is backtested
- What backtests can and cannot tell you, and the ways both styles fool themselves: overfitting on one side, hindsight bias on the other
Introduction to Time Series Data in Financial Markets
A ground-up introduction to time series data for engineering graduates, coders, and traders who want to systematize their process. Starts with what makes market data a time series, how an OHLCV bar is built, and where Indian market data actually comes from (NSE bhavcopy, broker APIs, free sources). Moves to the one transformation every quant does first, prices to returns, including log returns, adjusted prices, and Indian corporate actions. Then teaches how to describe a series honestly: rolling windows, volatility, return distributions, stationarity, autocorrelation, seasonality, and the cleaning work that real NSE data demands. Every concept is applied to Nifty 50 and NSE stock data with short Python examples.
- Explain what makes financial data a time series and why ordering and sampling frequency change what you can conclude from it
- Read an OHLCV bar, pick the right frequency for a question, and source Indian market data from NSE, BSE, and broker APIs
- Convert prices to simple and log returns, handle dividends, splits, and bonus issues, and rebuild a price path from returns
Masterclass Case Study: A CIO's Post Mortem on a Failed Quant Strategy
A full-length case study for senior quants, systematic fund manager aspirants and prop desk leads. You sit in the CIO's chair at Tapti Quant Capital, a hypothetical SEBI Category III AIF whose residual momentum and quality long-short book in Indian mid and small caps went live in mid 2024 on the back of a Sharpe 2.1 backtest, then lost 31% as the momentum and smallcap trade unwound between October 2024 and March 2025. Across ten chapters you run a blameless post-mortem: reopen the research that got approved, rebuild the backtest honestly with deflated Sharpe ratios and point-in-time NSE data, dissect the risk model, crowding, hedging and liquidity assumptions, reconstruct the drawdown week by week, audit execution and model governance, and examine the people and incentive failures behind the numbers. The case is tested against LTCM, the 2007 quant quake, the 2009 momentum crash and Indian market shocks, and the course closes with the CIO's written remediation plan and a pre-mortem and strategy health playbook you can run on your own systematic book.
- Run a structured, blameless post-mortem on a systematic strategy and separate bad luck from bad process
- Detect overfitting with multiple-testing adjustments, the deflated Sharpe ratio and honest holdout design
- Spot survivorship, look-ahead and regime biases in Indian equity backtests built on NSE and BSE data
Masterclass Case Study: How a Founder Built an Indian Quant Fund From Zero AUM
This masterclass follows Nikhil Rao, a composite founder built from the real decisions Indian quant managers face, as he leaves a Mumbai prop desk and builds a systematic fund from zero assets. Every stage is worked through with Indian specifics: running a personal prop book on NSE through broker APIs, choosing between a PMS licence, a Category III AIF and a GIFT City structure, budgeting for a trustee, custodian, fund administrator and SEBI fees, turning a two-year prop track record into something an investor can audit, raising the first crore from people who trust him, surviving the first real drawdown with outside money, and scaling past the capacity of his own strategies. All fund figures, AUM milestones and returns in this course are illustrative and used only to make the arithmetic concrete. Built for senior quants, aspiring systematic fund managers and prop desk leads who want to know what the journey costs before they start it.
- Decide whether your strategy should stay a prop book, become a PMS, launch as a Category III AIF or go offshore via GIFT City, and what each choice costs in rupees and months
- Build a track record that survives investor due diligence, with audited prop statements, realistic Indian transaction costs and a clear line between backtest and live
- Assemble the minimum viable infrastructure for a live systematic fund on NSE, from broker APIs and colocation to reconciliation and kill switches
Masterclass Case Study: How a Prop Desk Built a Multi Strategy Book Over a Decade
A decade-long case study of a Mumbai proprietary trading desk that grew from one Nifty futures trend strategy and three crore of partner capital in 2015 into a diversified book of trend, statistical arbitrage, volatility premium and event strategies running over two hundred crore by 2025. You follow every major decision in sequence: why the first strategy was not enough, how each new engine was researched and sized, how the strategies were combined into one risk budget, how the book survived demonetisation, the 2018 IL&FS shock, the March 2020 crash and the June 2024 election gap, and how the infrastructure, team, entity and tax structure had to change at every stage. Every number is worked in INR on NSE instruments with the actual SEBI rules that applied at the time.
- Diagnose when a single strategy desk has hit its capacity, drawdown or correlation ceiling and a second engine is needed
- Research, validate and size a new strategy so it earns its place in an existing book instead of diluting it
- Build and run four distinct engines on NSE: index trend, cash and futures statistical arbitrage, short volatility, and calendar and event trades
Masterclass: Building a Quant Fund From Scratch, Structure and Strategy
A founder-level blueprint for turning a set of profitable signals into an institutional quant fund in India. Covers the fund as a business (fees, costs and the AUM breakeven), the choice between a SEBI Category III AIF, a PMS, a proprietary desk and a GIFT City vehicle, tax and algo-trading regulation, strategy architecture and capacity on NSE, the research pipeline and alpha governance, fund-level risk, the data and execution stack, team and service providers, and raising capital from Indian family offices and institutional seeders. Built for senior quants, aspiring systematic fund managers and prop-desk leads who can already generate alpha and now need to build the firm around it.
- Model the P&L of a quant fund and find the AUM at which it stops burning founder capital
- Choose between a Category III AIF, a PMS, a prop desk and a GIFT City feeder using SEBI rules, tax and investor access
- Design a multi-strategy alpha book sized to what NSE liquidity can actually absorb
Masterclass: Building and Leading a Quant Research Team
A leadership masterclass for senior quants, systematic fund manager aspirants and prop desk leads who are about to build or take over a quant research team. Strategy design is assumed; this course is about the organisation around it. You work through the mandate and economics of a research team inside an Indian prop desk, SEBI Category III AIF or PMS, the roles and team topologies that work, how to hire and pay quants from the IIT, ISI and industry talent pool, the data and research platform a team needs before its first signal, a research process built on pre-registration, holdouts and a multiple-testing budget, how to lead PhDs and engineers without killing intellectual honesty, the model risk, SEBI algo and data licensing obligations a head of research owns, and what breaks when the team scales from three to thirty. The course runs on a hypothetical fund, Mahanadi Systematic, from its first hire to a multi-strategy desk, and closes with a 90-day plan and a scorecard for a new head of quant research.
- Define the mandate, cost base and capacity economics of a quant research team inside an Indian prop desk, Category III AIF or PMS
- Choose a team topology and role mix that fits your capital, strategy horizon and asset classes
- Source, interview and pay quant researchers and data engineers in the Indian talent market without overpaying for pedigree
Masterclass: How Top Prop Trading Firms Hire and Train Quants
An inside view of how proprietary trading firms in India and globally source, screen, interview, onboard and evaluate quantitative talent. Built for senior quants who want to understand the machine they are inside, aspiring systematic fund managers who need to build one, and prop desk leads who own a hiring pipeline. Covers the economics of a trading seat, the campus and lateral funnels that feed Indian HFT and options market-making desks, the probability, market-making and coding rounds and how they are actually graded, the bootcamp and graduated-risk model used to train a fresh quant, and the evaluation gates that decide who gets capital. Grounded in NSE and BSE market structure, SEBI regulation and real Indian desk examples.
Masterclass: Managing a Multi Strategy Quant Portfolio
A masterclass in running a book of many quantitative strategies as one portfolio. Built for senior quants who own a sleeve inside a larger book, aspiring systematic fund managers who must design the book from scratch, and prop desk leads who allocate capital across traders. Treats every strategy as a return stream with its own data sheet, then teaches how to allocate capital across streams under noisy Sharpe estimates, aggregate gross, net and factor exposure across pods, set drawdown budgets and kill switches, use NSE margin and netting rules for capital efficiency, and run the full lifecycle from incubation to retirement. Follows Mahanadi Systematic, a hypothetical Category III AIF running five sleeves on NSE cash, futures and options, from its first allocation to a full year of live decisions. Grounded in SEBI regulation, NSE Clearing margin practice and the real history of multi-strategy blow-ups.
- Describe every strategy as a return stream with a standard data sheet covering Sharpe, drawdown, capacity, turnover, cost drag and regime behaviour
- Explain how pod, central-book and hybrid multi-strategy firms are organised and which model fits an Indian AIF, PMS or prop desk
- Allocate capital across sleeves using equal risk, risk parity, fractional Kelly and shrinkage-based mean-variance, and know when each one breaks
Masterclass: Raising Capital for a Systematic Trading Fund
A masterclass for senior quants, prop desk leads and aspiring systematic fund managers in India who have a strategy and now need outside capital. It covers the full raise: choosing between a SEBI PMS, a Category III AIF and a GIFT City IFSC structure; the minimum tickets, sponsor commitment and tax treatment that shape each; fee economics and breakeven AUM; why allocators discount backtests and how to build a verifiable live track record; the pitch deck and the hard questions on overfitting, capacity and key person risk; the due diligence questionnaire and operational due diligence that family offices, wealth platforms and global allocators run; seed and anchor deals, first-loss capital, founders' share classes and side letters; distribution through wealth managers and placement agents; and how to run the pipeline, report to investors through drawdowns and manage capacity once the money arrives. Every lesson uses Indian regulation, Indian allocators and realistic rupee numbers, and the capstone has you write your own fund's capital raising plan.
- Choose the right vehicle for a systematic strategy in India: PMS, Category III AIF, GIFT City IFSC fund or managed accounts
- Model fee structures, hurdle rates, high-water marks and the breakeven AUM your fund needs to survive
- Build a track record that allocators actually trust, and present performance the way institutional investors read it
Masterclass: The Philosophy of Systematic Investing, Lessons From Industry Leaders
A masterclass on the ideas, not the code, behind the world's most successful systematic investors, and how those ideas translate to Indian markets. Built for senior quant professionals, aspiring systematic fund managers and prop desk leads who already know how to build a backtest and now need to decide what kind of firm, process and philosophy they are building. Traces the intellectual lineage from Markowitz, Fama and Thorp through Simons, Shaw, Asness, Dalio, Dennis and Harding, extracts the operating principles each of them actually lived by, and tests each principle against NSE data, SEBI rules and the Indian quant landscape of HFT props, quant mutual funds and momentum PMS. Ends with you writing the investment charter for your own systematic strategy.
Practice Drills: Applying Derivatives to Calculate Greeks and Duration
A drill-focused course for learners who already understand options and bonds and now want to compute their risk sensitivities cleanly and quickly. Every drill uses real Indian market inputs: NSE option chains for the Greeks, G-Secs for duration and convexity. The closing chapter rebuilds the same calculations in Python for anyone who wants to automate them.
- Read Delta and Gamma off a live NSE option chain and size a hedge from them
- Quantify Theta decay and Vega sensitivity for a given options position
- Use Rho to judge how rate moves reprice an options position
Practice Drills: Building a Basic Portfolio Optimization Model
A practice-drill course for quant aspirants, prop desk applicants and traders who want to systematise how they size positions. You know the Markowitz theory. Here you build the model yourself, with no black-box library doing the thinking for you. You start from five Nifty 50 stocks, build the return and covariance inputs, solve a two-stock minimum variance problem by formula, then solve the full five-stock minimum variance and max Sharpe problems in Google Sheets Solver. You rebuild the same model in Python with NumPy and scipy.optimize, trace and plot the efficient frontier, add weight caps, stress-test how fragile the weights are, and finish by converting optimal weights into a whole-share order list for a ₹5 lakh budget on Zerodha.
- Write any portfolio optimization problem as three pieces: inputs, an objective and constraints
- Build annualised return and covariance inputs for five NSE stocks from daily prices
- Solve two-stock minimum variance weights by formula and check them against a spreadsheet
Practice Drills: Building a Cointegration Test for a Pairs Trade
A hands-on drill course for quant analyst aspirants, prop trading applicants, and traders systematizing their approach. You will take two NSE stocks from raw price data to a defensible pass or fail verdict on cointegration: unit root tests on each leg, an OLS hedge ratio, the Engle-Granger residual test with the right critical values, half-life of mean reversion, and rolling-window stability checks. Every step is worked by hand first, then automated in Python.
- How to pull, clean, and align price data for two NSE stocks so the test is not corrupted by splits, bonuses, or missing days
- How to run and read an Augmented Dickey-Fuller test on each leg, by hand and with statsmodels
- How to estimate a hedge ratio with OLS and test the residual spread for stationarity using the correct critical values
Practice Drills: Building a Covariance Matrix and Running PCA on a Stock Portfolio
A practice-drill course for engineers, coders, and systematic traders who want to build real quant intuition. You will take a small portfolio of Indian stocks from raw daily returns to a full covariance matrix, then run principal component analysis on it to uncover the hidden risk factors driving the portfolio, all worked by hand first and then automated in Python.
- Why portfolio risk cannot be measured by averaging individual stock volatilities
- How to compute a covariance matrix from real NSE stock return data, by hand and in Python
- What eigenvectors and eigenvalues of a covariance matrix actually represent
Practice Drills: Building a Simple Classification Model for Price Direction
A hands-on drill course for aspiring quant analysts, prop trading applicants, and discretionary traders who want to systematise. You build a next-day direction classifier for the Nifty 50 from scratch in Python: labelling the data, engineering features without leaking the future, training logistic regression and a decision tree with chronological splits, and scoring the output with confusion matrices, precision, recall, and calibration. The final chapter turns predictions into positions, subtracts real Indian trading costs, and runs the full pipeline end to end on Bank Nifty.
- Turn a raw Nifty 50 price series into a clean up-or-down label and measure the base rate you must beat
- Build lagged return, RSI, moving average and volatility features without look-ahead leakage
- Split time series data chronologically and retrain a model walk-forward
Practice Drills: Building a Simple Correlation Matrix Across Stocks
A focused practice-drill course that takes you from raw NSE price data to a finished correlation matrix you can actually read and use. You will calculate correlation by hand for one pair of stocks, then build the full matrix in a spreadsheet and in Python, and learn what the numbers do and don't tell you about diversification.
- What a correlation coefficient actually measures between two stocks
- Why correlation must be calculated on returns, not raw prices
- How to pull clean historical price data for NSE stocks
Practice Drills: Calculating Sharpe Ratio and Drawdown by Hand and in Python
A focused set of practice drills for two of the most-used risk metrics in systematic trading: Sharpe ratio and maximum drawdown. Each metric is worked out by hand first, from raw daily returns, so the formula stops being a black box. Then the same calculation is reproduced in Python using numpy and pandas, so you can check your hand-worked answer against code and start building the habit of verifying a metric both ways.
- What Sharpe ratio and maximum drawdown actually measure, and why raw returns alone are misleading
- How to calculate Sharpe ratio by hand from a series of daily returns, including annualizing it correctly
- How to reproduce the same Sharpe ratio calculation in Python using numpy and pandas
Practice Drills: Identifying Overfitting in a Sample Backtest
A practice-drill course for anyone building or evaluating trading strategies who wants to catch overfitting before it costs real money. You will look at sample backtests, learn the warning signs of curve-fitting and data snooping, and work through drills that test whether a strategy's edge is real or an artifact of the data it was built on.
- Recognize the signs that a backtest result is too good to be true
- Tell the difference between curve-fitting, data snooping, and survivorship bias
- Read the gap between in-sample and out-of-sample performance
Understanding Alternative Data in Quantitative Strategies
A rigorous, theory-and-practice path into alternative data for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Covers the taxonomy of alt data (web, satellite, transaction, text, supply chain), sourcing and compliance in the Indian context, feature engineering, signal research, rigorous backtesting, portfolio integration, and real Indian case studies from satellite tracking to UPI data. Built around NSE, BSE, and Indian vendor examples throughout.
Understanding Calculus for Finance: Derivatives, Integrals, and Continuous Compounding
A ground-up, finance-first introduction to the calculus that quant work actually uses. Starts with the idea of a rate of change using Nifty 50 price paths, builds derivatives as sensitivities (duration, delta, marginal cost), then integrals as accumulation (total return, expected payoff, area under a distribution), and finishes with the exponential function and continuous compounding that underpin discounting, log returns, and Black-Scholes. Every concept is anchored in NSE and BSE data, INR examples, and screener.in style numbers rather than abstract textbook problems.
Understanding Capacity Constraints and Strategy Scaling
A framework-driven look at why every trading strategy has a ceiling on how much capital it can absorb, and how quant researchers, prop desks, and systematic traders scale AUM without destroying their own edge. Covers market impact, liquidity, alpha decay, crowding, capacity estimation, scaling playbooks, and execution at scale, grounded throughout in NSE liquidity, Nifty and Bank Nifty examples, and real capacity math.
Understanding Correlation and Its Role in Strategy Building
A ground-up, numbers-first course on correlation for anyone who wants to build trading or investing strategies systematically. You will learn what the correlation coefficient actually measures, how to compute it correctly on NSE price data in Google Sheets and Python, why it moves around so much across market regimes, and how it drives the three things every strategy depends on: diversification, hedging, and relative-value ideas like pairs trading. Anchored in Indian examples throughout, including Nifty 50, Bank Nifty, IT stocks versus USD/INR, gold, crude, and the 2020 COVID crash, with a hard look at the traps that catch most beginners: spurious correlations, unstable windows, and mistaking correlation for causation or beta.
- Read a correlation coefficient the way a quant does, and explain what it does and does not tell you
- Compute correlation correctly from NSE data using returns rather than prices, in Sheets and Python
- Tell correlation apart from beta, R-squared, and causation without getting confused again
Understanding Factor Investing From a Quant Lens
A rigorous, formula-first introduction to factor investing for quant analyst aspirants, prop trading applicants, and systematizing traders. Covers the theory behind why factors earn a premium, the core factor zoo (value, momentum, size, quality, low-volatility), and the practical mechanics of scoring, backtesting, and combining factors into a portfolio. Grounded in NSE and BSE data, Nifty factor indices, and Indian smart-beta ETFs throughout.
Understanding Implied Volatility and the Volatility Surface
A focused, practitioner-style walkthrough of implied volatility and how it organizes itself into a surface across strikes and expiries. Built for quant analyst aspirants, prop trading applicants, and systematizing traders who already understand Black-Scholes and want to go one level deeper into how real options desks read volatility. Covers IV vs historical/realized vol, the smile and skew, term structure, and how to assemble and interpret a full volatility surface, using Nifty, Bank Nifty, and India VIX data throughout.
Understanding Latency, Colocation, and Infrastructure in HFT
A ground-up look at the infrastructure layer of high frequency trading: what latency actually costs, why firms pay for colocation at NSE and BSE, how SEBI regulates fair access, and the network and hardware choices that separate microseconds from milliseconds.
- How tick-to-trade latency is measured and where the time actually goes
- Why colocation at NSE and BSE exists and how SEBI regulates fair access to it
- How fiber, microwave, and FPGA hardware choices trade off cost against speed
Understanding Linear Algebra for Finance: Matrices, Eigenvalues, and Covariance
A from-scratch, finance-first tour of linear algebra for engineers, coders, and systematic traders who want to understand what actually happens inside a portfolio optimiser or a risk model. You will represent portfolios as vectors, build a covariance matrix from real Nifty 50 constituent returns, see why portfolio variance is w transpose sigma w, and meet eigenvalues through principal component analysis of Indian equities and the G-Sec yield curve. The final chapter applies it all: beta via the normal equations, the minimum variance portfolio via the inverse covariance matrix, and the estimation errors that break naive models on real NSE data. Every concept is anchored in Indian market examples with worked numbers you can reproduce in Python or Google Sheets.
- Represent a portfolio of NSE stocks as a weight vector and price moves as a returns matrix
- Multiply, transpose, and invert matrices by hand and in Python, and know which operation answers which finance question
- Build a covariance and correlation matrix from daily returns of Nifty 50 constituents
Understanding Market Data: Tick, OHLC, and Order Book Basics
Every quant model, backtest and trading bot is built on market data, yet most people never learn what that data actually is. This course takes you from a single order hitting NSE's matching engine to the tick it produces, the OHLC candle it gets folded into, and the order book it moved through. You will learn to read Zerodha's market depth window, understand why adjusted and unadjusted prices differ, spot the data quality traps that quietly break backtests, and pull your first clean dataset into Python. Built for engineers, data scientists and systematic traders who want to stop treating price data as a black box.
- Trace a single order through NSE's matching engine and understand what a tick, a trade and a quote each record
- Build OHLC candles from raw ticks and see how timeframe and aggregation choices change what a chart shows
- Correct historical prices for splits, bonuses and dividends and know when to use adjusted versus unadjusted data
Understanding Market Making and Liquidity Provision Strategies
A rigorous, India-grounded path into how market makers actually operate: the economics of the bid-ask spread, inventory risk, adverse selection, order book microstructure, and the regulatory framework SEBI and NSE/BSE impose on liquidity providers. Built for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book, using real Nifty, Bank Nifty, and NSE order book examples throughout.
Understanding Mean Reversion Strategies
A comprehensive, from-first-principles course on mean reversion for quant analyst aspirants, prop trading applicants, and traders looking to systematize their approach. Covers the statistical logic of reversion (z-score, autocorrelation, half-life, the Ornstein-Uhlenbeck process), single-asset strategies built on Bollinger Bands, RSI, and moving averages, volatility reversion using India VIX, valuation and sector-level reversion, an introduction to pairs-based reversion, and a full Python backtesting workflow. Closes with the failure modes that turn a reversion trade into a falling knife. Built entirely on real NSE and BSE data, with Python throughout.
- Why prices, volatility, and valuations tend to pull back toward a statistical 'normal', and why some things never revert
- How to measure how stretched a price is using z-score, autocorrelation, and half-life of reversion
- How to build and trade single-asset reversion strategies with Bollinger Bands, RSI, and moving averages
Understanding Momentum and Trend Following Strategies
A rigorous, from-first-principles path into momentum and trend following for quant analyst aspirants, prop trading applicants, and traders looking to systematize their approach. Covers what momentum actually is as a market anomaly, how to measure trend with moving averages and crossover systems, momentum indicators like ROC and RSI, and how to build a cross-sectional momentum ranking system in the spirit of Jegadeesh-Titman. Built entirely on real NSE and Nifty data, with Indian brokers, costs, and market structure throughout.
- What momentum is as a market anomaly, and why it persists despite being well known
- The difference between trend following and momentum, and where each idea comes from
- How to build and read moving average crossover systems like the golden cross and death cross
Understanding Multi Asset Systematic Strategies
A rigorous path into building systematic strategies that span equities, fixed income, commodities, and currencies, for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from the asset universe and cross-asset correlation through trend-following, carry, value, risk parity, multi-strategy allocation, rigorous backtesting, and the operational realities of running a multi-asset book. Built on real NSE, MCX, and G-Sec data throughout.
Understanding Numerical Methods in Quantitative Finance: Binomial Trees and Finite Difference Methods
A formula-first, computation-heavy course for quant analyst aspirants, prop trading applicants, and systematizing traders on the two workhorse numerical methods for option pricing: binomial trees and finite difference schemes. Builds from why closed-form Black-Scholes breaks down, through single and multi-step trees, American option early exercise, and on to explicit, implicit, and Crank-Nicolson finite difference methods. Grounded throughout in Nifty 50, Bank Nifty, and NSE stock examples.
Understanding Optimization Theory: Convex Optimization and Lagrange Multipliers for Portfolio Construction
A rigorous, formula-first path into the optimization theory that underlies modern portfolio construction, for quant analyst aspirants, prop trading applicants, and systematizing traders. Builds from the basics of objective functions and constraints, through convex sets and convex functions, gradients and Hessians, Lagrange multipliers for equality-constrained problems, KKT conditions for real-world inequality constraints like no-short-selling, and Lagrangian duality. Every derivation is grounded in Nifty 50 stock data.
Understanding Order Book Dynamics and Microstructure Alpha
A rigorous, code-first path into limit order book mechanics and microstructure alpha for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from order book anatomy and price formation through trade classification, price impact, and short-horizon alpha signals like order book imbalance and VPIN, all built on real NSE and BSE tick and depth data, with Python throughout.
Understanding Pairs Trading: Concepts and Cointegration
A focused, from-first-principles course on pairs trading for quant analyst aspirants, prop trading applicants, and traders looking to systematize their approach. Covers market-neutral thinking, spread construction, the z-score as a trading signal, and the formal statistical test that separates a real pairs trade from a coincidence: cointegration, via stationarity, the Augmented Dickey-Fuller test, and the Engle-Granger two-step method. Ends with screening, sizing, and managing a real pair from entry to exit. Built entirely on real NSE and BSE data, with Python throughout.
- How pairs trading isolates alpha from a relationship between two assets instead of a directional market call
- How to build a spread between two stocks and turn it into a z-score trading signal
- Why correlation is not cointegration, and why that distinction decides whether a pair actually mean-reverts
Understanding Position Sizing and the Kelly Criterion
A first-principles guide to position sizing for traders and investors who already have an edge but don't know how much to bet on it. Derive the Kelly Criterion from scratch, learn why full Kelly is too aggressive for real markets, and apply fractional Kelly and portfolio-level sizing to Indian equities, Nifty and Bank Nifty options, and futures.
Understanding Probability Concepts Used in Trading Strategies
A ground-up course on the probability ideas that every systematic trading strategy quietly depends on. Built for engineering graduates, coders and self-taught traders who can write a loop but have never had probability explained in market terms. Covers expected value and edge, distributions and fat tails, conditional probability and base rates, sample size and the law of large numbers, and how these feed into position sizing, drawdown estimates and the honest evaluation of a backtest. Every idea is worked with Indian market examples: Nifty 50 daily returns, Bank Nifty options, Zerodha brokerage arithmetic and SEBI's own data on retail F&O outcomes.
Understanding Regime Detection in Markets
A concept-first introduction to market regimes for quant analyst aspirants, prop trading applicants, and traders who want to systematize their process. Builds the intuition behind trending vs mean-reverting markets and calm vs stressed volatility, shows how to read regime signals like India VIX, market breadth, and correlation without any modelling, and explains the statistical ideas behind regime detection (Markov-switching, Hidden Markov Models) in plain language before any code is introduced. Grounded in real Indian market history including 2008, 2020, and 2022. A natural on-ramp to the code-first Advanced Regime Switching Models course.
- Explain what a market regime is and why the same strategy behaves differently across regimes
- Distinguish trending from mean-reverting markets and calm from stressed volatility regimes
- Read India VIX, moving averages, market breadth, and correlation as practical regime signals
Understanding Reinforcement Learning Applications in Trading
A rigorous, code-first path into reinforcement learning for trading, for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from framing trading as a Markov Decision Process through core RL theory, building a working trading environment in Python, and (in later chapters) training, validating, and stress-testing RL-based strategies on real NSE data.
Understanding Risk Parity and Advanced Portfolio Construction
A rigorous, formula-first path into risk parity and modern portfolio construction for quant researcher aspirants, prop trading applicants, and traders scaling a systematic book. Goes from the failures of mean-variance optimization through equal risk contribution, volatility targeting and leverage, correlation regimes, Hierarchical Risk Parity, factor risk parity, and honest backtesting, ending with a live Python build using Nifty, G-Sec, and gold data. Built entirely on Indian asset classes.
Understanding Stochastic Calculus: Brownian Motion, Ito's Lemma, and the Path to Black-Scholes
A rigorous, first-principles build-up of the stochastic calculus that underpins modern quant finance, for quant analyst aspirants, prop trading applicants, and systematizing traders who want the actual math, not just the formula. Starts from random walks, builds the Wiener process and its defining properties, develops Ito's lemma from scratch, and uses it to derive the Black-Scholes PDE and formula step by step. Grounded in Nifty and Indian market examples throughout.
Understanding Transaction Costs and Slippage in Backtests
A practical, cost-first look at why backtested returns rarely survive contact with live markets. Covers the full Indian cost stack (brokerage, STT, GST, stamp duty, exchange charges), bid-ask spread and market impact, how to model slippage realistically, why high-turnover strategies suffer more than low-turnover ones, break-even edge analysis, and how to build a cost-aware backtest that won't lie to you. Built for quant analyst aspirants, prop trading applicants, and traders systematizing their own strategies, grounded throughout in NSE and Zerodha-level cost realities.
- Why paper returns and executable returns diverge, and how large that gap typically is
- How to price the full Indian cost stack: brokerage, STT, GST, stamp duty, and exchange charges
- How bid-ask spread and market impact create slippage even before you account for broker fees
Using Excel Solver for Basic Optimization Problems
A hands-on introduction to Excel's Solver add-in for readers who want to move beyond manual trial and error. You will set up an objective, decision variables and constraints for a real portfolio allocation problem, run Solver end to end, and learn to read its sensitivity report so you can trust the answer it gives you.
- What optimization means and when Solver is the right tool for the job
- How to enable Solver and structure a spreadsheet around an objective, decision variables and constraints
- How to build and solve a portfolio allocation problem in Excel from scratch
Using Google Colab for Free Cloud Based Quant Research
A hands on introduction to Google Colab as a free, cloud based research environment for quant work. You will set up your first notebook, pull real NSE and BSE market data, and build a repeatable analysis workflow, all without installing anything on your own machine.
- Why cloud notebooks are a better starting point than a local Python setup for market data work
- How to set up and navigate a Colab notebook, including runtimes and Google Drive integration
- How to pull, clean, and store NSE and BSE price data using yfinance and nsepy
Algorithmic Trading
17 courses
Case Study: Building and Testing a Volatility Breakout Strategy on Nifty Options
A hands-on case study that follows a single idea, volatility compression followed by expansion on the Nifty 50, all the way from a written hypothesis to a costed backtest and a paper-trading plan. You will source NSE bhavcopy and India VIX data, build the squeeze and breakout signals in Python, express the view with Nifty options (straddles, directional buys, debit spreads), account for STT, brokerage and slippage, and then stress the results with walk-forward tests and regime splits across the 2020 crash, the 2021 rally and the 2024 election week. Built for aspiring quant analysts, prop trading applicants and discretionary traders who want to systematise.
- Write a falsifiable trading hypothesis before touching data or code
- Source and clean Nifty spot, India VIX and options chain data from NSE bhavcopies
- Build ATR and Bollinger Band Width squeeze signals and a VIX regime filter in Python
Automating Strategies Using Zerodha Kite Connect API
You already know how to log in to Kite Connect, pull data and place an order. This course is about everything that comes after: building a strategy that runs on its own, reliably, inside SEBI's retail algo framework. You will build live candles from ticks, structure strategy logic as a state machine, size positions from live margins, handle partial fills and rejections, code your own kill switch, and deploy the bot on a Mumbai cloud server with a static IP, using a Nifty futures opening range breakout as the running example.
- How to architect an automated strategy as separate data, signal, risk, execution and monitoring layers
- What SEBI's retail algo framework, static IP rules and order-per-second limits mean for your code
- How to build live candles from Kite Ticker ticks and survive disconnects without corrupting your data
Building a Backtesting Engine Using Python and Backtrader
A hands-on build course for traders and aspiring quants who have outgrown spreadsheet and pandas one-liner backtests. You will assemble a complete event-driven backtesting engine on Backtrader: Indian data feeds from CSV and pandas, strategies with proper order handling, commission schemes that reproduce a real Zerodha contract note (brokerage, STT, exchange charges, SEBI fees, GST and stamp duty), slippage and volume rules, position sizers, and NSE futures with lot sizes and margin. You then measure results with built-in and custom analyzers, benchmark against the Nifty 50 TRI, and pressure-test every edge with parameter optimisation, walk-forward splits and Monte Carlo resampling. The course ends with a full momentum rotation backtest on Nifty 50 stocks and a clear map of what changes when a backtest moves toward paper and live trading under SEBI's retail algo framework. Built for quant analyst aspirants, prop desk applicants and systematising traders who can already write basic Python.
- Explain when an event-driven engine beats a vectorised pandas backtest, and why Backtrader is built the way it is
- Load, clean and resample NSE daily and intraday data, including corporate actions, holidays and multiple stocks at once
- Write strategies with correct order handling, custom indicators and no look-ahead bias
Case Study: A Retail Trader's Journey From Discretionary to Systematic Trading
A foundation-level case study built around Arjun Mehta, a Bengaluru software engineer who starts trading Nifty stocks and Bank Nifty on Zerodha on instinct, loses money, and rebuilds himself as a systematic trader over eighteen months. Each chapter is one stage of his journey: auditing his discretionary trades with Zerodha Console, turning instincts into precise written rules, backtesting on NSE data with realistic Indian costs, sizing positions and surviving a real drawdown, and finally going live with Kite Connect while keeping the discipline that stops him slipping back. Built for engineers, coders and traders who want to see exactly how the transition happens in an Indian account, with the mistakes left in.
- Audit your own discretionary trades using Zerodha Console, Tradebook and P&L exports to find where money actually leaks
- Convert instincts into a complete, testable rule set covering universe, entry, exit, sizing and review
- Run a first Python backtest on NSE data with Indian brokerage, STT, slippage and taxes built in
Case Study: Backtesting a Basic Momentum Strategy on Indian Stocks
A hands-on, end-to-end case study for coders and quant-curious engineers who have never run a backtest before. You will take one clearly specified idea, buying the NSE stocks that have risen the most over the past year and rebalancing monthly, and turn it into a working Python backtest step by step. Along the way you will source and clean Indian price data, handle splits and bonuses, avoid survivorship and look-ahead bias, build the ranking and rebalancing engine, and then subtract the brokerage, STT, impact cost and capital gains tax that separate a pretty equity curve from a real one. The course ends with a verdict on whether basic momentum has actually worked in India, and a checklist for what to test before risking a rupee.
- What cross-sectional momentum is, why it has persisted in Indian and global markets, and what the Nifty200 Momentum 30 index tells you about it
- How to write a complete, testable strategy specification before touching any data, so you cannot move the goalposts later
- How to source NSE price data in Python, adjust it for splits, bonuses and dividends, and build a clean monthly price panel
Case Study: Backtesting a Pairs Trade on Indian Banking Stocks
A hands-on, end-to-end case study for aspiring quant analysts, prop desk applicants and traders who want to systematise a market-neutral idea. You will take the classic pairs trade, going long one bank and short another when their price relationship stretches too far, and turn it into a working Python backtest on Nifty Bank constituents. Along the way you will learn why correlation is the wrong test and cointegration is the right one, how to estimate a hedge ratio and the half-life of the spread, how to build a z-score signal engine in pandas, and how the two-leg cost stack in India, including STT, SLB borrowing fees and stock futures rollovers, changes the answer. The course ends with a verdict on whether the chosen pair actually paid, and a checklist of what to test before risking a rupee.
- What a pairs trade is, why it is market-neutral in theory and not quite in practice, and why Indian banking stocks are a natural hunting ground
- The difference between correlation and cointegration, and how to run the Engle-Granger and ADF tests on NSE price data in Python
- How to estimate a hedge ratio, build the spread, and measure its half-life so you know how long a trade should take to converge
Case Study: How a Simple Moving Average Crossover Strategy Performs on Nifty
A hands-on case study for coders and quant-curious engineers who want to run their first real backtest. You will take the most famous trend-following rule in the world, buy Nifty 50 when its 50-day moving average crosses above its 200-day average and sell when it crosses back below, and test it honestly on two decades of Indian index data in Python. Along the way you will download and clean Nifty 50 history, compute moving averages and crossover signals in pandas, build positions without look-ahead bias, simulate an equity curve, and then subtract the brokerage, STT, slippage and capital gains tax that separate a textbook chart from a real trading account. The course ends with a verdict on whether the golden cross has actually worked on Nifty, why it behaves the way it does in Indian bull and sideways markets, and a checklist of what to test before risking a rupee.
- What a simple moving average is, what a golden cross and death cross mean, and why trend followers have used them for a century
- How to write the exact rules of a crossover strategy before touching any data, so you cannot move the goalposts later
- How to download Nifty 50 daily history in Python and clean it into a backtest-ready pandas DataFrame
Introduction to TradingView Pine Script for Strategy Building
A ground-up, code-first introduction to Pine Script for traders and engineers who want to build their own indicators and strategies on TradingView instead of relying on someone else's. You will set up TradingView for NSE and BSE charts, learn Pine Script's syntax, series and built-in variables, and use them to build real indicators like moving averages, RSI and Bollinger Bands from scratch. You will then move from indicator() to strategy(), write entry and exit logic, size positions, and read a Strategy Tester report the way a sceptical coder would, spotting the difference between a good backtest and a lucky one. No prior Pine Script experience is assumed, but comfort with basic programming logic (variables, if-else, loops) will help you move faster.
- How to set up TradingView for NSE and BSE charts and navigate the Pine Script editor
- Pine Script's core language: variables, series, built-in OHLCV variables, operators, conditionals and loops
- How to write built-in and user-defined functions in Pine Script
Introduction to Zerodha's Kite Connect API
A hands-on foundation course for using Zerodha's Kite Connect API to access market data and place orders programmatically. You will set up API access, understand the authentication flow, pull the instruments dump, fetch historical and live tick data, and place your first order, all with real NSE and BSE examples in Python.
- How to create a Kite Connect developer app and generate API credentials
- The Kite Connect login and authentication flow, including daily access token refresh
- How to fetch and decode the instruments dump to map trading symbols to instrument tokens
Masterclass: Understanding Regulatory Considerations for Algorithmic Trading in India
A regulator's-eye map of algorithmic trading in India for senior quants, aspiring systematic fund managers and prop desk leads. Covers the legal stack (SEBI Act, SCRA, Stock Broker Regulations, PFUTP, exchange bye-laws), exchange-level algo approvals and pre-trade risk checks, order-to-trade ratio and order-per-second discipline, kill switches, the co-location and market data framework and the NSE co-location matter, SEBI's February 2025 retail algo framework (broker as principal, API rules, white-box and black-box algos, algo registration), market abuse doctrine for algorithmic conduct, and how to structure and run a systematic business in India: prop membership, PMS, AIF Category III, GIFT IFSC, cybersecurity and system audit obligations, tax treatment and a working compliance programme.
- Map every rule that touches an algorithmic order on NSE or BSE to the statute, regulation, circular or bye-law it comes from
- Design pre-trade risk checks, OTR and OPS controls and kill-switch procedures that satisfy exchange requirements
- Explain the co-location and market data framework and the lessons of the NSE co-location matter
Practice Drills: Backtesting a Moving Average Crossover Strategy
A hands-on practice drill for building and honestly evaluating a moving average crossover backtest in Python, using real NSE price data. You will code the strategy, compute performance metrics, and learn where backtests quietly lie to you.
- How a moving average crossover strategy generates buy and sell signals
- How to source and clean NSE price data for a backtest
- How to code a crossover backtest in Python from scratch
Practice Drills: Backtesting a Strategy While Accounting for Transaction Costs
A drill course for traders who already understand why costs break backtests and now need to prove it on their own strategies. You will price real Zerodha round trips line by line, code the Indian cost stack and a slippage model in Python, run the same NSE strategy gross and net of costs, find the break-even cost at which its edge disappears, and finish with a full cost-aware backtest and the kind of report a prop desk or quant interviewer expects to see.
- Price a delivery, intraday, futures and options round trip on Zerodha line by line, including STT, exchange charges, GST, SEBI fees and stamp duty
- Turn the Indian cost stack into a reusable Python function that plugs into any backtest
- Estimate slippage from bid-ask spreads and traded volume instead of guessing a flat number
Practice Drills: Writing a Basic Buy Sell Signal Generator in Python
A practice-drill course for coders and quant-curious learners who want to get their hands dirty writing the Python logic behind a basic buy/sell signal generator. You will pull real NSE stock data, code moving average and RSI based signals from scratch, combine them, and sanity-check the output against history. This is a coding skill drill, not a validated trading system.
- Pull historical OHLC data for NSE stocks into Python with pandas
- Code a moving average crossover signal from scratch
- Code an RSI-based overbought/oversold signal from scratch
Understanding Algorithmic Trading: Concepts and Terminology
A foundation-level walkthrough of algorithmic trading for the Indian markets, covering the core concepts, terminology, and building blocks that separate systematic trading from discretionary trading. Built for engineering graduates, coders, and traders curious about the quant side of NSE and BSE markets.
- Learn what algorithmic trading is and its core terms
- Explore types of algo strategies and backtesting basics
- See India's market infrastructure and algo career pathways
Understanding Backtesting: Concepts and Common Pitfalls
A concept-first course on backtesting for coders, engineers and systematic traders who want to know what a backtest can and cannot tell them before they write one. You will learn the anatomy of a proper backtest, how Indian price data misleads you through splits, bonuses and delisted stocks, and the five biases that turn random noise into a beautiful equity curve. You will then price the real frictions of trading on NSE and BSE, brokerage, STT, slippage, impact cost, circuit limits and capital gains tax, and learn to read CAGR, drawdown and Sharpe ratio the way a sceptical reviewer would. No code is required; every idea is illustrated with Indian stocks, Nifty data and worked numbers you can reproduce in a spreadsheet.
- What a backtest actually measures, and the difference between a historical simulation and a forecast
- The five components every backtest needs: universe, signal, rules, execution assumptions and evaluation metrics
- Why raw NSE prices lie without split, bonus and dividend adjustment, and how to spot an unadjusted series
Understanding Overfitting and Curve Fitting in Strategy Design
A foundation course on the single most common way systematic traders lose money: building a strategy that fits the past perfectly and the future not at all. You will learn what overfitting and curve fitting actually are in statistical terms, the specific design habits that let them creep in (parameter sweeps, data snooping, look-ahead and survivorship bias), how to detect an overfit strategy before you risk capital using out-of-sample tests, walk-forward analysis, and parameter sensitivity checks, and how to design strategies with an economic rationale that hold up on NSE and BSE data. Every example uses Indian market data, Indian brokers, and INR.
- Explain overfitting and curve fitting in plain statistical terms and recognise them in a backtest
- Identify the design habits that introduce overfitting: parameter sweeps, data snooping, look-ahead and survivorship bias
- Split data into in-sample and out-of-sample sets and run a walk-forward test correctly
Using Amibroker for Basic Strategy Backtesting
Learn to use Amibroker, one of the most widely used backtesting platforms among Indian systematic traders, to turn a trading idea into a rule-based strategy and test it against historical NSE data. You will set up Amibroker with Indian market data, learn the basics of AFL (Amibroker Formula Language), build a simple moving average crossover strategy, and run your first backtest with stop-loss and position sizing rules in place. By the end, you will be able to read a backtest report and spot the most common mistakes that make backtests lie.
- Install Amibroker and connect it to Indian (NSE) market data
- Read and write basic AFL (Amibroker Formula Language) code
- Translate a trading idea into buy and sell signal conditions
Python for Finance
12 courses
Building a Monte Carlo Option Pricing Model in Python
A build-along course for quant analyst aspirants, prop trading applicants, and systematizing traders who want a real Monte Carlo pricing engine, not a toy script. You will write a vectorised GBM engine in NumPy, validate it against Black-Scholes and the live NSE Nifty chain, cut its error with antithetic, control variate, and Sobol techniques, compute Greeks by simulation, price path-dependent payoffs like the barriers inside Nifty-linked MLDs, move beyond GBM with jump-diffusion and Heston, handle early exercise with Longstaff-Schwartz, and ship the whole thing as a tested, fast Python package.
Building a Pairs Trading Strategy Using Python and Statsmodels
A build course for quant analyst aspirants, prop desk applicants and traders who already know what a pairs trade is and now want to code one properly. You will use statsmodels as your statistics engine: sm.OLS and RollingOLS for hedge ratios, adfuller and kpss for stationarity, coint for Engle-Granger, coint_johansen for multi-stock baskets, an AR(1) regression for half-life, a state space model for a time-varying hedge ratio, and VECM for the adjustment dynamics of both legs. Each tool is taught by reading its actual output, not just calling it. You then scan sector universes from the Nifty 200 for candidates without falling into the multiple testing trap, code a z-score signal engine with no look-ahead bias, backtest it in pandas with the full Indian cost stack, walk it forward, and package the whole thing as a reusable, tested Python module.
- Set up a clean pairs trading project and pull, adjust and align NSE price data for two or more stocks
- Estimate a hedge ratio with sm.OLS and read every line of the regression summary, including the ones that mislead you on price data
- Track hedge ratio drift with RollingOLS and model it directly with a Kalman filter built on statsmodels state space
Building a Portfolio Optimizer Using Python's PyPortfolioOpt
A hands-on build course for quant aspirants, prop desk applicants and traders who want to systematise how they size a portfolio. You already know what an efficient frontier is. This course makes you build one that survives contact with real Indian data. You will pull a clean price panel for Nifty 50 stocks, estimate expected returns three ways, build covariance matrices that are not drowned in noise, and run max Sharpe, minimum volatility and target return optimisations in PyPortfolioOpt with the Indian risk-free rate. You then add the constraints a real portfolio needs (weight caps, NSE sector limits, regularisation, transaction cost penalties), move beyond mean-variance with Hierarchical Risk Parity, Black-Litterman and CVaR, and finally convert weights into whole shares for a real INR budget, backtest the result against the Nifty 50 TRI and account for rebalancing turnover and Indian capital gains tax. The course ends with an end-to-end monthly optimizer pipeline you can rerun yourself.
- Set up a reproducible PyPortfolioOpt project and build a clean, adjusted price panel for NSE stocks
- Estimate expected returns with historical, exponentially weighted and CAPM methods, and know why each one misleads
- Build sample, shrunk, exponential and semicovariance risk models, and check them before trusting them
Building an Options Pricing Calculator Using Python
A hands-on build course for traders and aspiring quants who want to understand where the numbers on an NSE option chain come from. You will write a complete options pricing library in Python: the Black-Scholes formula term by term, all five Greeks in closed form and by finite differences, an implied volatility solver, a binomial tree and a Monte Carlo engine. Every model is tested against real Nifty 50 and Bank Nifty contracts, with Indian conventions handled correctly: the 91-day T-bill as the risk-free rate, lot sizes, weekly and monthly expiry timing, and India VIX as a cross-check on your implied volatility. You finish by packaging the code as a tested module with a Streamlit front end and a strategy payoff tool. Built for systematising traders, prop-desk applicants and quant analyst aspirants who can already read an option chain and want to rebuild it from first principles.
- Set up a clean Python environment for options work with NumPy, SciPy, pandas and pytest
- Prepare the Black-Scholes inputs the Indian way: spot vs futures, T-bill risk-free rate, dividend yield and exact time to expiry
- Code the Black-Scholes pricer and verify it with put-call parity and live Nifty 50 chain prices
Introduction to Jupyter Notebooks for Trading Research
A focused course on working well inside Jupyter, for readers who already know basic Python and pandas from Introduction to Python for Finance. Covers choosing between JupyterLab, classic Notebook and VS Code notebooks, magic commands and widgets that speed up exploration, and the habits that keep a research notebook honest: avoiding hidden state, structuring notebooks so they survive a restart-and-run-all, version controlling them with Git, and exporting them into reports colleagues can actually trust. Closes with look-ahead bias and data snooping, the two mistakes that quietly ruin notebook-based research.
- Choose and configure the right Jupyter environment for serious research work
- Use magic commands, widgets and extensions to move faster inside a notebook
- Structure notebooks so they survive a restart-and-run-all
Introduction to Pandas and NumPy for Market Data
A hands-on introduction to NumPy and Pandas built around real Indian market data. You will learn to work with arrays and DataFrames, clean and index price data, pull live data from NSE and BSE, and run the same groupby and aggregation techniques used in professional quant workflows, all using screener.in exports and yfinance pulls instead of toy datasets.
- Why NumPy arrays outperform plain Python lists for price and returns data
- How to build, index, and filter Pandas Series and DataFrames
- How to work with dates and resample daily price data to weekly or monthly
Introduction to Python for Finance: Why It's the Quant's Language
A first course in Python built entirely around Indian market data, for engineering graduates, working coders and traders who want to systematise what they do. Explains why Python beat Excel, R and C++ as the working language of quant desks, sets up a proper workstation with Jupyter and free NSE data, then teaches core Python, NumPy and pandas by computing returns, moving averages, volatility and drawdowns on Nifty 50 stocks. Ends with a simple, honest backtest that includes STT and slippage, a look at Zerodha Kite Connect and SEBI's algo rules, and a realistic map of quant careers in India.
Practice Drills: Cleaning and Structuring Raw Market Data in Pandas
Nine hands-on drills for cleaning, structuring and merging real NSE and BSE market data in Pandas. Built for anyone who already knows basic Python and wants practice on the messy CSVs, corporate action adjustments and multi-symbol datasets they will actually run into, not toy data.
- Parse and clean raw NSE/BSE bhavcopy files and broker data exports in Pandas
- Adjust historical prices for splits, bonuses and dividends
- Reshape and merge multi-symbol datasets into an analysis-ready format
Practice Drills: Writing Your First Python Script to Pull Stock Data
A practice-drill course for engineers and quant-curious learners who want hands-on reps writing Python that talks to real market data. You will set up your environment, pull live NSE stock prices, clean and structure the data, save it properly, and then push your script further with progressively harder drills covering multiple stocks, date ranges, and a simple watchlist tracker.
- Set up a working Python environment for pulling market data
- Write a script that fetches live NSE stock price data
- Clean and structure raw API data into usable tables with pandas
Setting Up Python for Financial Data Analysis
Get your Python environment, core libraries and first real NSE/BSE data pipeline working, so you're ready to analyse Indian markets in code instead of spreadsheets.
- Install and configure Python, VS Code and Jupyter for financial analysis work
- Manage virtual environments and packages so your projects stay reproducible
- Use NumPy and pandas to work with price and returns data
Using NumPy for Matrix Operations in Finance
A hands-on introduction to NumPy built specifically for finance work: representing price series and portfolios as arrays, and using matrix operations to compute portfolio returns, covariance, and risk. For engineers and data-inclined traders who already know some Python and want to stop looping over prices in plain lists. Every example uses real Indian market data conventions: NSE/BSE tickers, Nifty constituents, and data shaped the way you'd pull it from screener.in or a broker API.
Using yfinance and NSEpy to Pull Indian Market Data
A hands-on guide to pulling real Indian market data with Python. Covers yfinance for NSE and BSE tickers (historical OHLCV, adjusted close, corporate actions) and NSEpy for NSE-specific data that yfinance doesn't cover, including F&O and delivery percentage. Built for engineering graduates, coders, and systematizing traders who want a working data pipeline, not just theory, with every example run against real Nifty 50 and F&O tickers.