DEV Community: Amit Kumar Jha

Portfolio Optimization in Python: From Markowitz to Machine Learning

Amit Kumar Jha — Fri, 24 Jul 2026 05:37:43 +0000

Portfolio Optimization in Python: From Markowitz to Machine Learning

Every quant faces the same question: how do you allocate capital across assets to maximize returns while minimizing risk? This is portfolio optimization — and it's the backbone of modern quantitative finance.

In this post, we'll build portfolio optimization from scratch in Python, starting with Markowitz's classical mean-variance framework and progressing to machine learning approaches used on actual trading desks.

The Markowitz Framework

Harry Markowitz's 1952 paper revolutionized finance by formalizing diversification. The core idea: don't just pick individual stocks — optimize the entire portfolio.

The Math Behind It

Given a portfolio of $n$ assets with:

Expected return vector: $\mu$
Covariance matrix: $\Sigma$
Weight vector: $w$

The portfolio return and risk are:

R_{p} = w^{T} μ

σ_{p 2} = w^{T} Σ w

The optimization problem becomes:

w min w^{T} Σ w subject to w^{T} μ = μ_{t a r g e t}, w^{T} 1 = 1

Python Implementation

import numpy as np
import pandas as pd
from scipy.optimize import minimize

def portfolio_stats(weights, mean_returns, cov_matrix):
    """Calculate portfolio return and volatility."""
    portfolio_return = np.sum(mean_returns * weights)
    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    return portfolio_return, portfolio_volatility

def minimize_volatility(target_return, mean_returns, cov_matrix, n_assets):
    """Find minimum volatility portfolio for a target return."""
    args = (mean_returns, cov_matrix)

    constraints = (
        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
        {'type': 'eq', 'fun': lambda x: portfolio_stats(x, mean_returns, cov_matrix)[0] - target_return}
    )

    bounds = tuple((0, 1) for _ in range(n_assets))
    result = minimize(
        fun=lambda x: portfolio_stats(x, mean_returns, cov_matrix)[1],
        x0=np.array([1/n_assets] * n_assets),
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )
    return result

# Generate sample data
np.random.seed(42)
n_assets = 5
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']

# Simulate returns
mean_returns = np.array([0.12, 0.10, 0.15, 0.11, 0.20])
cov_matrix = np.array([
    [0.04, 0.006, 0.008, 0.005, 0.01],
    [0.006, 0.03, 0.007, 0.004, 0.008],
    [0.008, 0.007, 0.06, 0.009, 0.015],
    [0.005, 0.004, 0.009, 0.035, 0.007],
    [0.01, 0.008, 0.015, 0.007, 0.10]
])

# Find efficient frontier
target_returns = np.linspace(0.08, 0.20, 50)
frontier_volatilities = []

for target in target_returns:
    result = minimize_volatility(target, mean_returns, cov_matrix, n_assets)
    frontier_volatilities.append(result.fun)

print("Efficient frontier computed!")
print(f"Minimum volatility: {min(frontier_volatilities):.4f}")

The Efficient Frontier

The efficient frontier is the set of portfolios offering the highest expected return for each level of risk. Any portfolio below the frontier is suboptimal — you could get more return for the same risk.

Portfolio	Return	Volatility	Sharpe Ratio
Min Variance	10.2%	14.8%	0.42
Max Sharpe	14.5%	18.2%	0.63
Equal Weight	13.6%	19.1%	0.50

Beyond Markowitz: Black-Litterman

Classical Markowitz has a problem: it's extremely sensitive to input estimates. Small changes in expected returns lead to wildly different allocations. The Black-Litterman model fixes this by combining market equilibrium with investor views.

The Key Insight

Instead of estimating returns directly, Black-Litterman starts with implied equilibrium returns derived from market capitalization weights:

Π = δ Σ w_{mk t}

where $\delta$ is the risk aversion coefficient and $w_{mkt}$ is the market portfolio.

Python Implementation

def black_litterman(cov_matrix, market_weights, risk_aversion, views, view_confidences):
    """
    Black-Litterman model implementation.

    Parameters:
    - cov_matrix: covariance matrix
    - market_weights: market cap weights
    - risk_aversion: risk aversion coefficient
    - views: matrix of investor views (k x n)
    - view_confidences: confidence in each view (k x k)
    """
    n = len(market_weights)

    # Implied equilibrium returns
    pi = risk_aversion * cov_matrix @ market_views

    # View uncertainty (Omega)
    tau = 0.05
    sigma_views = view_confidences

    # Black-Litterman expected returns
    P = views
    Q = np.array([0.10, 0.15])  # View returns

    M1 = np.linalg.inv(tau * cov_matrix)
    M2 = P.T @ np.linalg.inv(sigma_views) @ P
    bl_returns = np.linalg.inv(M1 + M2) @ (M1 @ pi + P.T @ np.linalg.inv(sigma_views) @ Q)

    return bl_returns

Machine Learning Approaches

Modern quant desks use ML for portfolio optimization in several ways:

1. Reinforcement Learning for Dynamic Allocation

import torch
import torch.nn as nn

class PortfolioAllocator(nn.Module):
    def __init__(self, n_assets, lookback=60):
        super().__init__()
        self.lstm = nn.LSTM(n_assets, 64, batch_first=True)
        self.fc = nn.Linear(64, n_assets)
        self.softmax = nn.Softmax(dim=-1)

    def forward(self, returns_history):
        # returns_history: (batch, lookback, n_assets)
        lstm_out, _ = self.lstm(returns_history)
        weights = self.fc(lstm_out[:, -1, :])
        return self.softmax(weights)

2. Variational Autoencoders for Scenario Generation

Instead of assuming normal returns, VAEs learn the actual distribution of market scenarios, capturing fat tails and regime changes.

3. Graph Neural Networks for Sector Allocation

GNNs model relationships between assets, capturing contagion effects and sector rotations that traditional correlation matrices miss.

Practical Considerations

Transaction Costs

Real portfolios face trading costs. The optimization must account for:

def portfolio_with_transaction_costs(weights, new_weights, transaction_cost=0.001):
    """Add transaction cost penalty."""
    turnover = np.sum(np.abs(new_weights - weights))
    cost = turnover * transaction_cost
    return cost

Rebalancing Frequency

Frequency	Pros	Cons
Daily	Captures signals	High transaction costs
Weekly	Balance	Moderate costs
Monthly	Low costs	May miss opportunities

Risk Constraints

# Maximum position size
constraints.append({'type': 'ineq', 'fun': lambda x: 0.20 - x})

# Maximum sector exposure
sector_exposure = np.sum(weights[sector_indices])
constraints.append({'type': 'ineq', 'fun': lambda x: 0.40 - sector_exposure})

Real-World Application

Here's a complete pipeline you can use:

import yfinance as yf
from sklearn.covariance import LedoitWolf

# Fetch data
data = yf.download(['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA'], 
                    start='2020-01-01', end='2024-01-01')
returns = data['Adj Close'].pct_change().dropna()

# Shrinkage estimator for covariance
lw = LedoitWolf().fit(returns)
cov_matrix = lw.covariance_
mean_returns = returns.mean() * 252  # Annualized

# Optimize
result = minimize_volatility(0.12, mean_returns, cov_matrix, 5)
print(f"Optimal weights: {dict(zip(tickers, result.x.round(3)))}")

Key Takeaways

Markowitz is the foundation — understand mean-variance optimization before moving to advanced methods
Black-Litterman fixes sensitivity — use market equilibrium as a prior
ML adds value — but only when you have enough data and proper validation
Transaction costs matter — theoretical optimal ≠ practical optimal
Risk constraints are essential — never optimize without limits

Want to Learn More?

If you're preparing for quant interviews or want to deepen your portfolio theory knowledge, check out our Quantitative Finance for Absolute Beginners course — it covers portfolio optimization, risk management, and derivatives pricing with hands-on Python projects.

Built with Python, NumPy, SciPy, and PyTorch. Full code available on GitHub.

Monte Carlo Simulation in Finance: From Random Walks to Option Pricing

Amit Kumar Jha — Wed, 22 Jul 2026 04:40:28 +0000

Why Monte Carlo?

Monte Carlo simulation is the Swiss Army knife of quantitative finance. When analytical solutions don't exist, we simulate: generate thousands of possible future price paths, price the derivative on each path, then average and discount.

The method is named after the Monaco casino — a nod to randomness. But there's nothing gambling about it when done correctly.

Simulating Asset Prices with GBM

The geometric Brownian motion (GBM) model is the starting point:

S_{t + Δ t} = S_{t} exp ((μ - \frac{σ ^{2}}{2}) Δ t + σ Δ t Z)

Where:

$S_{t}$ is the current stock price
$μ$ is the drift (expected return)
$σ$ is the volatility
$Z \sim N (0, 1)$ is a standard normal random variable

This comes from discretizing the GBM stochastic differential equation:

d S = μ S d t + σ S d W_{t}

Python: Building a Monte Carlo Pricer

import numpy as np

def monte_carlo_call(S0, K, T, r, sigma, n_sims=100000, n_steps=252):
    """Price a European call option via Monte Carlo."""
    dt = T / n_steps
    Z = np.random.standard_normal((n_sims, n_steps))

    drift = (r - 0.5 * sigma**2) * dt
    diffusion = sigma * np.sqrt(dt) * Z

    terminal_prices = S0 * np.exp(np.sum(drift + diffusion, axis=1))
    payoffs = np.maximum(terminal_prices - K, 0)

    call_price = np.exp(-r * T) * np.mean(payoffs)
    std_error = np.exp(-r * T) * np.std(payoffs) / np.sqrt(n_sims)

    return call_price, std_error

# Example: 1-year ATM call
price, se = monte_carlo_call(S0=100, K=100, T=1.0, r=0.05, sigma=0.20)
print(f"Price: {price:.4f}, 95% CI: [{price-1.96*se:.4f}, {price+1.96*se:.4f}]")

Variance Reduction

Raw Monte Carlo converges at

O (1/ N)

— to halve the error, you need 4x simulations. Variance reduction helps:

Antithetic Variates

For every path

Z

, also simulate

- Z

. This halves variance at zero extra cost:

Z_anti = -Z  # Flip the sign
Z_all = np.vstack([Z, Z_anti])

Control Variates

Use Black-Scholes (which has a closed form) as a control to reduce variance of your Monte Carlo estimate.

Multi-Asset Simulations

For basket options or portfolio derivatives, use Cholesky decomposition to generate correlated paths:

L = np.linalg.cholesky(corr_matrix)
Z = np.random.standard_normal((n_sims, n_steps, n_assets))
corr_Z = Z @ L.T  # Correlated random draws

Interview Essentials

Q: Why not just use Black-Scholes?
Black-Scholes only works for vanilla European options. Most real derivatives — path-dependent, American, basket — don't have analytic solutions. Monte Carlo handles all of them.

Q: How do you price American options with Monte Carlo?
Use the Longstaff-Schwartz least-squares method. At each exercise date, regress future payoffs on current state variables to estimate continuation value.

Q: What are the convergence properties?
Standard error decreases as

1/ N

. To get one more decimal digit, you need 100x more simulations. This is why variance reduction matters.

Summary

Technique	Best For	Complexity
Raw MC	Vanilla European	Low
Antithetic Variates	Any path	Low
Control Variates	Known analytic benchmark	Medium
Importance Sampling	Deep OTM options	High
Quasi-MC (Sobol)	Low-dimensional	Medium

Monte Carlo is not the fastest, but it's the most flexible. When in doubt, simulate.

Ready to go deeper? Check out Desk2Quant for hands-on practice with derivatives pricing, portfolio optimization, and quant interview prep.

Options Greeks Explained: Delta, Gamma, Theta, Vega — With Python Code

Amit Kumar Jha — Wed, 22 Jul 2026 03:44:23 +0000

Options Greeks Explained: Delta, Gamma, Theta, Vega — With Python Code

Options trading is a cornerstone of quantitative finance. Before pricing exotic derivatives or building a volatility surface, you need to master the Greeks — sensitivity measures that tell you how an option's price changes with respect to underlying parameters.

This post breaks down the four primary Greeks with intuition, formulas, and production-ready Python code.

What Are the Greeks?

The Greeks are partial derivatives of the option pricing model. They measure risk — how your P&L shifts when market conditions change.

Greek	Measures	Intuition
Delta	Sensitivity to spot price	How much option price moves per $1 in underlying
Gamma	Sensitivity of Delta	How fast Delta itself changes
Theta	Time decay	How much value you lose per day
Vega	Volatility sensitivity	How much option price changes per 1% vol move

Black-Scholes Greeks: The Formulas

For a European call option under Black-Scholes:

d_{1} = \frac{ln ( S / K ) + ( r + σ ^{2} /2 ) T}{σ T}, d_{2} = d_{1} - σ T

The Greeks are:

Δ = N (d_{1})

Γ = \frac{N ^{'} ( d _{1} )}{S σ T}

Θ = - \frac{S N ^{'} ( d _{1} ) σ}{2 T} - rK e^{- r T} N (d_{2})

V = S N^{'} (d_{1}) T

Where N(.) is the standard normal CDF and N'(.) is the PDF.

Python Implementation

import numpy as np
from scipy.stats import norm


def black_scholes_greeks(S, K, T, r, sigma, option_type="call"):
    """
    Calculate Black-Scholes Greeks for European options.

    Parameters:
        S: Current stock price
        K: Strike price
        T: Time to expiry (years)
        r: Risk-free rate
        sigma: Volatility
        option_type: "call" or "put"

    Returns:
        dict with delta, gamma, theta, vega
    """
    d1 = (np.log(S / K) + (r + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)

    nd1 = norm.cdf(d1)
    npdf_d1 = norm.pdf(d1)
    nd2 = norm.cdf(d2)

    # Delta
    delta = nd1 if option_type == "call" else nd1 - 1

    # Gamma (same for calls and puts)
    gamma = npdf_d1 / (S * sigma * np.sqrt(T))

    # Theta
    if option_type == "call":
        theta = (-S * npdf_d1 * sigma / (2 * np.sqrt(T))
                 - r * K * np.exp(-r * T) * nd2)
    else:
        theta = (-S * npdf_d1 * sigma / (2 * np.sqrt(T))
                 + r * K * np.exp(-r * T) * norm.cdf(-d2))

    # Vega (same for calls and puts, per 1% vol move)
    vega = S * npdf_d1 * np.sqrt(T) / 100

    return {
        "delta": round(delta, 4),
        "gamma": round(gamma, 4),
        "theta": round(theta, 4),
        "vega": round(vega, 4)
    }


# Example: ATM call on a $100 stock
result = black_scholes_greeks(
    S=100, K=100, T=0.25, r=0.05, sigma=0.20, option_type="call"
)
print(result)
# {'delta': 0.5596, 'gamma': 0.0355, 'theta': -6.414, 'vega': 0.1782}

Practical Interpretation

Delta

ATM options: Delta ~ 0.50 (call) or -0.50 (put)
Deep ITM: Delta approaches 1.0 (call) or -1.0 (put)
Deep OTM: Delta approaches 0.0 (both)
Delta hedging: Hold -Delta shares to neutralize directional risk

Gamma

Highest for ATM options near expiry
Gamma risk spikes as expiry approaches
Long options = long gamma; short options = short gamma

Theta

Always negative for long option holders (time decay)
Accelerates in the last 30 days before expiry
Theta is the "cost" of holding an option position

Vega

Highest for ATM options with long tenor
Vega exposure = exposure to implied volatility changes
Critical during earnings season or macro events

Greeks Sensitivity Table

# How Greeks change with moneyness
strikes = [90, 95, 100, 105, 110]
print(f"{'Strike':<8} {'Delta':<8} {'Gamma':<8} {'Theta':<8} {'Vega':<8}")
print("-" * 40)
for K in strikes:
    g = black_scholes_greeks(100, K, 0.25, 0.05, 0.20)
    print(f"{K:<8} {g['delta']:<8} {g['gamma']:<8} {g['theta']:<8} {g['vega']:<8}")

Output:

Strike   Delta    Gamma    Theta    Vega
----------------------------------------
90       0.8429   0.0096   -4.58    0.0481
95       0.7184   0.0214   -5.66    0.1069
100      0.5596   0.0355   -6.41    0.1782
105      0.3961   0.0449   -6.73    0.2243
110      0.2553   0.0443   -6.54    0.2213

Notice how Gamma peaks ATM (strike 100-105) while Delta transitions from 0 to 1.

Greeks in Portfolio Risk Management

In practice, portfolio-level Greeks aggregate across all positions:

portfolio_delta = sum(pos.quantity * pos.delta for pos in positions)
portfolio_gamma = sum(pos.quantity * pos.gamma for pos in positions)
portfolio_theta = sum(pos.quantity * pos.theta for pos in positions)
portfolio_vega = sum(pos.quantity * pos.vega for pos in positions)

A delta-neutral portfolio has portfolio_delta = 0. But with non-zero gamma, your delta changes as the market moves — this is dynamic hedging.

Common Interview Questions

What happens to Gamma as expiry approaches for an ATM option? — Gamma increases, creating "pin risk"
How do you delta-hedge a short call? — Buy Delta shares of the underlying
Why is Vega important during earnings? — Implied volatility spikes before earnings and crushes after
What's the relationship between Theta and Gamma? — For delta-hedged options, Theta decay ~ Gamma * S^2 * sigma^2 / 2 (the theta-gamma tradeoff)

Level Up Your Quant Skills

Want to go deeper into options pricing, Greeks, and quant interview prep? Check out the Desk2Quant Quant Interview Problem Book — 100+ problems with detailed solutions covering derivatives pricing, stochastic calculus, and probability.

Published by Desk2Quant — helping you break into quantitative finance.

Black-Scholes Explained Simply — With Python Code

Amit Kumar Jha — Mon, 20 Jul 2026 01:58:13 +0000

Black-Scholes Explained Simply — With Python Code

The Black-Scholes model is the foundation of modern option pricing. Published in 1973 by Fischer Black, Myron Scholes, and Robert Merton, it revolutionized finance by providing the first closed-form formula for European option prices. Every quant interview starts here.

This guide breaks down the model from first principles, implements it in Python, covers the Greeks, and explains where and why it fails.

The Black-Scholes Formula

Under the risk-neutral measure, a European call option price is:

C_{BS} = S_{0} N (d_{1}) - K e^{- r T} N (d_{2})

where:

d_{1} = \frac{ln ( S _{0} / K ) + ( r + σ ^{2} /2 ) T}{σ T}, d_{2} = d_{1} - σ T

S₀ — current stock price
K — strike price
r — risk-free rate
σ — volatility (annualized)
T — time to expiration (years)
N(·) — cumulative standard normal distribution

For a European put, use put-call parity:

P = C - S_{0} + K e^{- r T}

The Five Assumptions

Assumption	Reality	Impact
Constant volatility	Vol varies by strike/time (smile)	Model underprices OTM options
Log-normal returns	Returns have fat tails	Underestimates crash risk
No dividends	Most stocks pay dividends	Overprices calls on dividend stocks
No transaction costs	Spreads exist	Real hedging costs more
Continuous trading	Markets close, gaps happen	Overnight risk unmodeled

Understanding these assumptions is critical for interviews. When a trader says "the model is wrong," they mean one of these is violated.

Python Implementation

import numpy as np
from scipy.stats import norm

def bs_call(S, K, r, T, sigma):
    """Black-Scholes European call price."""
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return S * norm.cdf(d1) - K * np.exp(-r*T) * norm.cdf(d2)

def bs_put(S, K, r, T, sigma):
    """Black-Scholes European put price."""
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return K * np.exp(-r*T) * norm.cdf(-d2) - S * norm.cdf(-d1)

# Price an ATM call
S0, K, r, sigma, T = 100, 100, 0.05, 0.20, 1.0
call_price = bs_call(S0, K, r, T, sigma)
put_price = bs_put(S0, K, r, T, sigma)

print(f"Call Price: ${call_price:.4f}")
print(f"Put Price:  ${put_price:.4f}")

Output:

Call Price: $10.4506
Put Price:  $5.5735

The Greeks: Risk Sensitivities

The Greeks tell traders how the option price changes when inputs move. This is what you actually use on the desk.

Delta

Δ_{c a ll} = N (d_{1}), Δ_{p u t} = N (d_{1}) - 1

Delta is the sensitivity to the underlying price. A delta of 0.63 means the option price moves $0.63 for every $1 move in the stock.

Gamma

Γ = \frac{N ^{'} ( d _{1} )}{S _{0} σ T}

Gamma is the rate of change of delta. High gamma = the option's delta changes rapidly = more convexity = more valuable.

Vega

ν = S_{0} T N^{'} (d_{1})

Vega is the sensitivity to volatility. This is the most important Greek for vol traders.

Theta

Θ_{c a ll} = - \frac{S _{0} N ^{'} ( d _{1} ) σ}{2 T} - rK e^{- r T} N (d_{2})

Theta is time decay. Options lose value as expiration approaches.

Rho

ρ_{c a ll} = K T e^{- r T} N (d_{2})

Rho is the sensitivity to interest rates.

Python: Greeks Calculator

def bs_greeks(S, K, r, T, sigma):
    """Compute all Greeks for a European call."""
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    delta = norm.cdf(d1)
    gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
    vega = S * norm.pdf(d1) * np.sqrt(T) / 100
    theta = (-(S * norm.pdf(d1) * sigma) / (2*np.sqrt(T)) 
             - r * K * np.exp(-r*T) * norm.cdf(d2)) / 365
    rho = K * T * np.exp(-r*T) * norm.cdf(d2) / 100

    return {'delta': delta, 'gamma': gamma, 'vega': vega, 
            'theta': theta, 'rho': rho}

greeks = bs_greeks(100, 100, 0.05, 1.0, 0.20)
for name, val in greeks.items():
    print(f"{name:>6s}: {val:.4f}")

Output:

 delta: 0.6368
 gamma: 0.0188
  vega: 0.3752
 theta: -0.0176
   rho: 0.5323

Implied Volatility

Given a market price, we can back out the volatility that makes Black-Scholes match that price. This is implied volatility.

from scipy.optimize import brentq

def implied_vol(price, S, K, r, T):
    try:
        return brentq(
            lambda sigma: bs_call(S, K, r, T, sigma) - price, 
            0.01, 3.0
        )
    except:
        return np.nan

market_price = 10.50
iv = implied_vol(market_price, 100, 100, 0.05, 1.0)
print(f"Implied Volatility: {iv*100:.2f}%")

Output:

Implied Volatility: 20.15%

If you plot implied volatility across different strikes, you get the volatility smile. This is the single biggest evidence that Black-Scholes is wrong.

Where Black-Scholes Fails

1. The Volatility Smile

If Black-Scholes were correct, implied volatility would be constant across all strikes. It isn't. OTM puts trade at higher implied vol — the skew. This is why quants use Heston, local vol, or jump-diffusion models.

2. Fat Tails

Real returns have kurtosis > 3. The 1987 crash, 2008 crisis, and 2020 COVID crash were all "impossible" under log-normal assumptions.

3. Path Dependence

Black-Scholes prices European options only. Asian, barrier, and lookback options require Monte Carlo or PDE methods.

Interview-Ready Summary

Concept	Formula/Key Point	Interview Question
BS Call	S·N(d₁) − Ke⁻ʳᵀ·N(d₂)	"Derive BS from risk-neutral pricing"
Delta	N(d₁)	"What's the delta of an ATM call?"
Gamma	N'(d₁)/(S·σ·√T)	"Why is gamma highest ATM?"
Vega	S·√T·N'(d₁)	"Why does vega increase with T?"
Put-Call Parity	P = C − S + Ke⁻ʳᵀ	"Does put-call parity hold for Americans?"
Implied Vol	σ such that C_BS(σ) = C_market	"What does the vol smile tell us?"
Key Limitation	Constant vol assumption	"Why use Heston instead of BS?"

How to Become a Quant in 2026: The Complete Career Guide

Amit Kumar Jha — Mon, 20 Jul 2026 01:46:55 +0000

How to Become a Quant in 2026: The Complete Career Guide

The quantitative finance landscape has shifted dramatically in the past two years. AI models now write pricing code, LLMs summarize research papers in seconds, and yet the demand for human quants has never been higher. Why? Because the job has evolved - and the people who understand why models fail, not just how to run them, are the ones banks and funds are fighting to hire.

This guide is not a generic "study math and learn Python" listicle. It's a 2026-specific roadmap based on what hiring managers at Goldman Sachs, Citadel, Two Sigma, and Jane Street are actually looking for right now.

What Does a Quant Actually Do in 2026?

The term "quant" covers a spectrum of roles. In 2026, the landscape has crystallized into four distinct tracks:

Role	What You Do	Where	2026 Trend
Front Office Quant	Pricing exotic derivatives, vol surfaces, real-time risk	Banks (GS, JPM, Barclays)	More Python, less Excel. AAD now standard.
Quant Researcher	Alpha research, signal generation, stat arb	Hedge Funds (Citadel, Two Sigma, DE Shaw)	ML-heavy. Alternative data table stakes.
Quant Developer	Low-latency systems, pricing libraries, risk infra	Banks + Prop Shops (Optiver, IMC, HRT)	C++ still king for HFT. Rust gaining traction.
Risk/Model Validation	Model validation, VaR/ES, stress testing	Banks, Regulators (Fed, PRA, ECB)	FRTB implementation driving hiring.

Key insight for 2026: The lines between these roles are blurring. A front office quant now needs to write production Python, a quant researcher needs to understand market microstructure, and a quant developer needs stochastic calculus intuition. Generalists with depth are winning over narrow specialists.

The 2026 Skill Stack

1. Mathematics (Non-Negotiable)

You don't need a PhD in pure math, but you need working fluency in:

Probability & Statistics - Conditional expectation, Bayesian inference, copulas, extreme value theory. This is 60% of what you use daily.
Stochastic Calculus - Ito's Lemma, Girsanov's theorem, martingale pricing. You need to understand it, not just memorize formulas. Can you explain why we change measure from $\mathbb{P}$ to $\mathbb{Q}$ in one sentence?
Linear Algebra - PCA for risk decomposition, eigenvalues for covariance estimation, matrix calculus for ML models.
Numerical Methods - Monte Carlo (variance reduction), PDE solvers (Crank-Nicolson), optimization (differential evolution).

2026 shift: Pure math knowledge is now a prerequisite, not a differentiator. What separates candidates is the ability to connect math to market reality - knowing when models break and why.

2. Programming (The New Filter)

In 2026, programming is the #1 filter in quant interviews:

Language	Where It's Used	Interview Weight
Python	Research, prototyping, ML, data analysis	50% of coding interviews
C++	HFT, pricing libraries, risk engines	30% (higher for dev roles)
SQL	Data extraction, trade queries, risk reports	15% (often overlooked)
R / Rust	R: legacy risk. Rust: next-gen HFT.	5% (nice to have)

2026 shift: Python is now expected at every level. Five years ago, a quant could get away with "I know Excel VBA." Today, if you can't write a Monte Carlo pricer from scratch in Python, you're not getting past the first round.

3. Financial Knowledge (The Differentiator)

Math and code get you the interview. Financial knowledge gets you the offer:

Derivatives Pricing - Black-Scholes, Greeks, vol surfaces, local vs stochastic vol, exotic payoffs
Risk Management - VaR, Expected Shortfall, CVA/DVA/FVA, SA-CCR, FRTB
Market Microstructure - Order books, bid-ask spreads, market impact, adverse selection
XVA - Credit/Debt/Funding Valuation Adjustment. XVA desks are one of the largest quant employers.

Education Paths

Path 1: Traditional Degree (Still the Gold Standard)

Top feeder programs in 2026:

Mathematical Finance / Financial Engineering - Carnegie Mellon MSCF, Princeton MFin, Baruch MFE, Columbia MFE, NYU Tandon
Statistics / Applied Math - Stanford, MIT, Cambridge, Oxford
Physics / Engineering PhD - Still the most common background for senior quants
Computer Science - Increasingly valued for quant dev and ML researcher roles

2026 reality: A degree alone is no longer enough. Hiring managers want to see projects, not just coursework.

Path 2: Self-Study Curriculum

Phase	Focus	Resources	Timeline
1. Foundations	Probability, Linear Algebra, Python	MIT OCW 18.05, 18.06	2-3 months
2. Stochastic Calculus	Ito's Lemma, SDEs, risk-neutral pricing	Shreve (vols I & II)	2-3 months
3. Derivatives	Black-Scholes, Greeks, vol surfaces, exotics	Hull (Options, Futures)	2-3 months
4. Projects	Build pricing engines, backtests, risk tools	Personal projects	2-3 months
5. Interview Prep	Brain teasers, probability puzzles, coding	Practice problems	1-2 months

Total timeline: 9-14 months of focused study.

Path 3: Career Transition (Most Common)

Software Engineer ? Quant Developer - Add stochastic calculus and derivatives knowledge
Data Scientist ? Quant Researcher - Add financial domain knowledge and market intuition
Actuary ? Risk Quant - Add Python and regulatory knowledge (FRTB, SA-CCR)
Academic Researcher ? Quant - Learn financial products and market conventions

The Interview Process

Round 1: Online Assessment

LeetCode-style coding (medium difficulty)
Probability puzzles (conditional expectation, Bayes)
Mental math (quick arithmetic, percentages)

Round 2: Technical Phone Screen

Walk through a project on your resume
1-2 probability/brain teaser questions
Basic derivatives pricing

Round 3: Superday (4-6 Hours)

Math/Probability - "You roll two dice. Given the sum is 8, what's the probability one die shows 3?"
Stochastic Calculus - "Explain Ito's Lemma. Why is it different from ordinary calculus?"
Coding - "Implement a Monte Carlo pricer for an Asian call option."
Finance - "What's a variance swap? Why would a trader buy one?"
Behavioral - "Tell me about a time you debugged a model under pressure."

2026 shift: More firms are using AI-powered interview platforms for initial screening. Practice with voice-based mock interviews.

Salary Landscape (2026)

Role / Location	Base (USD)	Total Comp
Junior Quant (0-2 yrs) - NYC/London	$120K-$180K	$180K-$350K
Mid-Level (3-5 yrs)	$180K-$250K	$350K-$600K
Senior / VP (5-10 yrs)	$250K-$400K	$600K-$1.5M
Quant Researcher - Top Hedge Fund	$200K-$350K	$500K-$2M+
Quant Dev - Prop Shop (HFT)	$200K-$300K	$400K-$1M+
Quant - India (Mumbai/Gurgaon)	?15L-?40L	?25L-?80L+

The AI Question: Will LLMs Replace Quants?

No. But the job is changing.

What AI can do in 2026:

Generate boilerplate pricing code
Summarize research papers
Write unit tests and debug simple errors

What AI cannot do:

Understand why a model fails in a new market regime
Make judgment calls on model risk
Navigate trading desk politics
Design novel hedging strategies
Take responsibility when a $50M PnL gap appears

The quants who thrive in 2026 are the ones who use AI as a force multiplier - 10x their productivity with Copilot, use LLMs to prototype faster, and focus their human judgment on the hard problems.

Your 90-Day Action Plan

Day 1-7: Assess your gap. Take a mock quant interview.
Day 8-30: Build foundations. Study probability, linear algebra, Python. Write a Monte Carlo pricer.
Day 31-60: Learn derivatives pricing. Build a project.
Day 61-90: Interview prep. Solve 200+ puzzles. Do 5+ mock interviews.

This post originally appeared on Desk2Quant. For quant interview prep resources, visit desk2quant.vercel.app.

DEV Community: Amit Kumar Jha

Portfolio Optimization in Python: From Markowitz to Machine Learning

Portfolio Optimization in Python: From Markowitz to Machine Learning

The Markowitz Framework

The Math Behind It

Python Implementation

The Efficient Frontier

Beyond Markowitz: Black-Litterman

The Key Insight

Python Implementation

Machine Learning Approaches

1. Reinforcement Learning for Dynamic Allocation

2. Variational Autoencoders for Scenario Generation

3. Graph Neural Networks for Sector Allocation

Practical Considerations

Transaction Costs

Rebalancing Frequency

Risk Constraints

Real-World Application

Key Takeaways

Want to Learn More?

Monte Carlo Simulation in Finance: From Random Walks to Option Pricing

Why Monte Carlo?

Simulating Asset Prices with GBM

Python: Building a Monte Carlo Pricer

Variance Reduction

Antithetic Variates

Control Variates

Multi-Asset Simulations

Interview Essentials

Summary

Options Greeks Explained: Delta, Gamma, Theta, Vega — With Python Code

Options Greeks Explained: Delta, Gamma, Theta, Vega — With Python Code

What Are the Greeks?

Black-Scholes Greeks: The Formulas

Python Implementation

Practical Interpretation

Delta

Gamma

Theta

Vega

Greeks Sensitivity Table

Greeks in Portfolio Risk Management

Common Interview Questions

Level Up Your Quant Skills

Black-Scholes Explained Simply — With Python Code

Black-Scholes Explained Simply — With Python Code

The Black-Scholes Formula

The Five Assumptions

Python Implementation

The Greeks: Risk Sensitivities

Delta

Gamma

Vega

Theta

Rho

Python: Greeks Calculator

Implied Volatility

Where Black-Scholes Fails

1. The Volatility Smile

2. Fat Tails

3. Path Dependence

Interview-Ready Summary

Further Reading

How to Become a Quant in 2026: The Complete Career Guide

How to Become a Quant in 2026: The Complete Career Guide

What Does a Quant Actually Do in 2026?

The 2026 Skill Stack

1. Mathematics (Non-Negotiable)

2. Programming (The New Filter)

3. Financial Knowledge (The Differentiator)

Education Paths

Path 1: Traditional Degree (Still the Gold Standard)

Path 2: Self-Study Curriculum

Path 3: Career Transition (Most Common)

The Interview Process

Round 1: Online Assessment

Round 2: Technical Phone Screen

Round 3: Superday (4-6 Hours)

Salary Landscape (2026)