Learn quantitative finance with Python from scratch

Quantitative finance has a reputation for being gatekept behind expensive certificates and heavy math. Some of the math is real. But the fastest way in is not a reading list, it is building the core models yourself in Python until they are no longer mysterious.

Here is the path that works, and what you are really learning at each step.

Start with returns and risk

Everything begins with returns. Simple returns, log returns, and why quants usually prefer log returns (they add up across time). Then risk: variance, standard deviation as volatility, and covariance between assets. If you can compute and reason about these from a price series, the rest has a foundation.

You do not need anything beyond NumPy here. Building it yourself is the point: when you have written the volatility calculation, "annualized vol" is no longer a word, it is a thing you computed.

Time value of money and bonds

Discounting is the second pillar: a rupee today is worth more than a rupee next year. Present value, future value, and then bonds, which are just a series of discounted cash flows. Pricing a bond and computing its yield teaches you the machinery that the rest of fixed income is built on.

Portfolios

Once you have returns and covariance, you can build portfolios: expected return, portfolio variance, and the idea that diversification reduces risk without necessarily reducing return. This is where the math starts to pay off, because you can see why combining assets is not the same as averaging them.

Stochastic models and Monte Carlo

Prices are modeled as random walks. Simulating thousands of possible future paths and looking at the distribution of outcomes is the Monte Carlo method, and it is one of the most useful tools in the whole field. Building a simple price simulator yourself demystifies a huge amount of what follows.

Options and the Greeks

Options pricing is where many people give up, because they meet Black-Scholes as a formula to memorize. It lands very differently when you build up to it: price an option by simulation first, see the same answer come out of the closed form, and then compute the Greeks (delta, gamma, vega, theta) as the sensitivities they actually are. Built this way, the Greeks are intuitive, not intimidating.

Signals and backtesting

Finally, the part everyone wants to jump to: turning data into a trading signal and testing it against history. The discipline here is honest backtesting, accounting for the fact that a strategy that looks great in hindsight often falls apart out of sample. Building a backtester yourself is the best way to understand why.

Build it, do not import it

The reason "from scratch" matters in quant finance is that the field is full of black boxes. If you only ever call a library function for option pricing, you cannot reason about when it breaks. If you have built it, you can.

The Quantitative Finance track walks this exact path, returns and risk, time value and bonds, portfolios, stochastic models and Monte Carlo, options and the Greeks, signals, and backtesting, with everything built from scratch in NumPy and graded in your browser as you go. The first project is free.

Start with returns. The rest builds on it.