Top 5 Beginner Projects to Get Into Quantitative Finance
Quantitative finance can be difficult to approach as a beginner. You might understand some Python, probability, or statistics, but still have no idea what you are supposed to build.
The good news is that your first project does not need to predict the stock market or compete with a hedge fund. A useful beginner project should help you work with real financial data, turn a mathematical idea into code, and test whether your results actually make sense.
The five projects below cover different parts of quantitative finance, from basic market analysis to portfolio construction, derivatives pricing, and statistical arbitrage. They are arranged roughly in order of difficulty, so you can work through them as a sequence or choose the area that interests you most.
Table of Contents
- 1. Financial Market and Risk Dashboard
- 2. Moving Average Crossover Backtest
- 3. Markowitz Portfolio Optimiser
- 4. Black–Scholes and Monte Carlo Option Pricer
- 5. Cointegration-Based Pairs Trading
- Choosing Your First Project
1. Build a Financial Market and Risk Dashboard
A financial dashboard is a good place to start because it forces you to become comfortable with market data before you try to build a trading strategy.
Choose a small collection of stocks or ETFs and download their historical prices using Python. From there, calculate daily returns, cumulative returns, annualised volatility, maximum drawdown, and the Sharpe ratio. You can also compare the assets using a correlation matrix and measure their performance against a benchmark such as the S&P 500.
At first, this can be done entirely inside a Jupyter notebook. Once the calculations work, you could use Streamlit or Plotly to turn the notebook into an interactive application where the user can enter a ticker and select a date range.
- • Which asset produced the highest return?
- • Which one experienced the worst drawdown?
- • Did the asset with the highest return also have the best risk-adjusted performance?
- • How did correlations change during periods of market stress?
- • Add rolling volatility and rolling Sharpe-ratio charts.
- • Compare stocks from different industries.
- • Calculate Value at Risk and Conditional Value at Risk.
- • Allow the user to upload their own portfolio.
- • Generate a downloadable performance report.
2. Backtest a Moving Average Crossover Strategy
Once you know how to handle price data, the next step is to build a basic backtest.
A moving average crossover is one of the simplest strategies you can implement. You calculate a short-term moving average and a long-term moving average for the same asset. When the short moving average moves above the long moving average, the strategy enters a position. When it moves below, the strategy exits.
For example, you could use a 50-day moving average and a 200-day moving average. The exact numbers are not particularly important. The point of the project is not to discover a perfect combination of parameters; it is to understand the structure of a backtest.
You will need to translate the strategy into exact rules, generate positions, calculate daily strategy returns, and compare the result with simply buying and holding the asset. Your final output should include an equity curve, total return, annualised volatility, Sharpe ratio, and maximum drawdown.
If a signal is calculated using today's closing price, you cannot also pretend that you entered the trade at that same closing price. Shifting your positions by one period is a small detail, but ignoring it introduces look-ahead bias and makes the backtest unreliable.
- • Add transaction fees and slippage.
- • Test different moving-average lengths.
- • Compare results across stocks, indices, and commodities.
- • Separate your data into in-sample and out-of-sample periods.
- • Test whether the strategy works after parameters have been chosen.
Do not judge the strategy only by its return. A strategy that gains 20% while experiencing a 50% drawdown is very different from one that gains 15% with a 10% drawdown.
3. Create a Markowitz Portfolio Optimiser
A portfolio optimiser is a natural next project for anyone interested in the mathematical side of quantitative finance.
Start by selecting a group of stocks or ETFs. Using their historical returns, estimate the expected return of each asset and the covariance matrix between them. You can then generate different portfolio weight combinations and calculate the expected return and volatility of each portfolio.
Plotting these portfolios produces the familiar efficient frontier from Modern Portfolio Theory. From there, identify the minimum-volatility portfolio and the portfolio with the highest estimated Sharpe ratio.
This is a good project for learning how an optimisation problem becomes a working program. It also shows why portfolio construction is not simply a matter of selecting the assets with the highest historical returns. Correlations matter. Combining two volatile assets can still reduce overall portfolio risk when their returns do not move together closely.
The result can be extremely sensitive to the expected returns you feed into the optimiser. Small changes in the input data may produce very different portfolio weights. Rather than hiding this problem, include it in your analysis.
- • Compare the optimised portfolio with equal weighting.
- • Add a no-short-selling constraint.
- • Limit the maximum allocation to any one asset.
- • Rebalance the portfolio monthly or quarterly.
- • Test the chosen weights on a later, unseen period.
- • Use shrinkage or another method to improve the covariance estimate.
A strong submission should explain the mathematics, show the weights clearly, and discuss the limitations of using historical averages as estimates of future returns.
4. Build a Black–Scholes and Monte Carlo Option Pricer
This project is a good introduction to derivatives and computational finance.
Begin with a European call or put option. Implement the Black–Scholes formula in Python using the current asset price, strike price, time to expiry, risk-free rate, and volatility. The formula gives you an analytical option value under the assumptions of the model.
Next, calculate the same price using Monte Carlo simulation.
Simulate thousands of possible terminal prices for the underlying asset using geometric Brownian motion. Calculate the option payoff under each simulated outcome, take the average, and discount it back to the present. The Monte Carlo estimate should move closer to the Black–Scholes value as the number of simulations increases.
Do not stop after printing two numbers. Plot some of the simulated price paths. Run the calculation with different numbers of simulations and record the error. You can also repeat the experiment several times to see how much the Monte Carlo estimate varies.
- • Price both calls and puts.
- • Check that put-call parity holds.
- • Calculate Delta, Gamma, Vega, Theta, and Rho.
- • Add a binomial-tree pricing method.
- • Produce a heatmap showing how the option price changes with volatility and the underlying price.
- • Add confidence intervals to the Monte Carlo estimate.
- • Build a small Streamlit pricing application.
This project also gives you plenty to discuss in a README. You can explain the model assumptions, show where Monte Carlo error comes from, and compare the advantages of analytical and numerical pricing methods.
5. Build a Cointegration-Based Pairs-Trading Strategy
Pairs trading is the most advanced project on this list, but it is also the closest to a small quantitative research project.
The basic idea is to find two assets whose prices share a stable long-term relationship. When that relationship temporarily moves away from its usual level, the strategy buys one asset and sells the other, expecting the spread between them to return towards its historical mean.
Start with stocks from the same industry rather than testing completely unrelated companies. You might examine two banks, two oil companies, or two large technology firms.
Two price series can be highly correlated without having a stable long-term spread. A better project should introduce stationarity and cointegration.
You can use linear regression to estimate the hedge ratio between the two assets, construct the spread, and apply an Augmented Dickey–Fuller test. If the spread appears stationary, calculate its rolling z-score. The strategy can enter a trade when the z-score moves beyond a chosen threshold and exit when it returns closer to zero.
Backtest the resulting long-short positions and include transaction costs. More importantly, choose the pair and trading rules using one period of data, then evaluate them on an out-of-sample period. Otherwise, it is very easy to search through enough stocks and parameters until you find an impressive historical result by chance.
- • Search for cointegrated pairs within the same sector.
- • Estimate the hedge ratio using a rolling window.
- • Calculate the half-life of mean reversion.
- • Compare correlation-based and cointegration-based pair selection.
- • Add stop-loss and maximum-holding-period rules.
- • Build a portfolio containing several pairs.
- • Test whether the relationship remains stable over time.
The most interesting result may be that a pair which worked well historically stops behaving in the same way later. That is not a failed project. Finding and explaining the failure is part of quantitative research.
Choosing Your First Quantitative Finance Project
Whichever project you choose, make the work your own. Change the assets, test a different period, add another metric, and explain the decisions you made. Your GitHub repository should contain readable code, a clear README, the assumptions behind the model, and an honest discussion of what did not work.
A simple project becomes much more convincing when you can explain every line of the code and every limitation of the result. That is a far better starting point for quantitative finance than a complicated model you do not fully understand.
Ready to build?
Pick one project, finish a rough version, then extend it. That is how most people at QuantSoc start turning theory into something they can show.
Additional Materials
-
Financial Market Risk Assessment Using Python — dashboard walkthrough for returns and risk metrics
-
Moving Average Crossover Trading System Backtest in Python — a simple signal-and-backtest tutorial
-
Markowitz Bullet in Python: Efficient Frontier — visualising the efficient frontier
-
Monte Carlo Simulation for Option Pricing with Python — simulation-based option pricing
-
Backtest a Pairs Trading Strategy in Python — pairs trading from spread construction to backtest
-
Quantitative finance Python projects on GitHub — browse open-source examples for inspiration