Most options content online is either hand-wavy “buy this call and get rich” hype, or a dense finance textbook full of integrals. This course is neither. It is written for programmers — people who are comfortable with code, data and systems — and it uses that comfort as the teaching tool. We will treat an option like what it really is to us: a small, well-defined object with inputs, outputs and a pricing function you can literally write in Python. By the end you should understand options properly, from the absolute basics up to a few genuinely advanced ideas, and you should be able to automate the boring parts the way we automate everything else.
A serious note up front — please read it. This is educational material, not financial advice and not a tip service. Options are leveraged instruments and you can lose money very fast — SEBI’s own studies show the large majority of retail F&O traders in India lose money. Selling options can lose far more than you put in. Nothing here is a recommendation to trade. Learn first, paper-trade for a long time, risk only what you can afford to lose, and treat the first goal as not blowing up, not getting rich. All numbers are illustrative examples.
Why a programmer has an edge
A manual trader eyeballs an option chain and trades on gut feeling. You can do something quite different. You can pull the entire chain every second, compute implied volatility and Greeks for 200 strikes, apply rules without emotion, size positions by a formula, and never once forget a stop-loss. The maths of options is not hard for us — Black-Scholes is about ten lines of Python — and the whole thing is just data flowing through logic. The edge is real. So is the risk, which is exactly why we will spend a full lesson on not blowing up.
We start from zero (what even is a call?), get the payoff shapes into your muscle memory, then build up the Greeks and pricing with real Black-Scholes numbers (computed, not hand-waved — e.g. an at-the-money Nifty 24000 weekly call works out to ~176 points, losing ~14 points a day to theta). From there we cover volatility, the standard strategies from covered calls to iron condors, and the risk management that actually keeps an account alive. We finish on the part that is ours to own: the data and broker-API tooling stack, and a simple options algo built end to end.
What this course covers
| # | Lesson | What you will learn |
|---|---|---|
| 1 | Why Options (for Coders) | The techie edge; what options are, at a high level; the mindset |
| 2 | The Absolute Basics | Call, put, strike, premium, expiry, lot size; buyer vs seller |
| 3 | Moneyness & Payoffs | ITM/ATM/OTM, intrinsic vs time value, the four payoff shapes |
| 4 | The Greeks | Delta, gamma, theta, vega, rho — with real numbers and code |
| 5 | Pricing & Implied Vol | Black-Scholes in Python; what implied volatility really is |
| 6 | Volatility | HV vs IV, IV rank/percentile, smile & skew, India VIX |
| 7 | Directional Strategies | Covered call, protective put, cash-secured put |
| 8 | Spreads | Bull call / bear put, debit vs credit, defined risk |
| 9 | Advanced Strategies | Straddle, strangle, iron condor, butterfly, calendar |
| 10 | Risk & Position Sizing | Max loss, margin (SPAN), assignment, expiry day, costs |
| 11 | Data & Tooling Stack | Option chain, broker APIs, backtesting, paper trading |
| 12 | Build a Simple Algo | Data → signal → risk → order → monitor, end to end |
It is written in plain Indian English with a working engineer in mind, grounded in real Black-Scholes computations, and every lesson ends with the pitfalls and a quick recap. The goal is simple: after reading this, you should understand options basics (and a fair bit of the advanced stuff) genuinely, and be able to build small, safe tools around them.
Start with Lesson 1: Why Options (for Coders).
For related material, see the Low-Latency Trading Systems course, the algo trading vocabulary, and position sizing with the Kelly criterion.