Python Projects for Aspiring Quants: Five Studies You Can Run Today

Five small, self-contained quant research projects built on real market data: a pre-earnings IV screen, a dilution drift study, a dividend capture screen, a momentum rank tilt, and a volatility slate audit.

Every aspiring quant hits the same wall. You have finished the Python tutorials, you can wrangle a DataFrame, and now every piece of advice says the same thing: "build projects." What nobody hands you is a project that is actually shaped like quant research, with a real hypothesis, real market data, and a result you can defend.

The usual suspects fail that test. Another moving-average crossover on Yahoo Finance data teaches you matplotlib, not research. A Kaggle price-prediction notebook teaches you sklearn, not markets. What you want is the shape of work an actual research desk does: a bounded question about a specific market mechanism, answered with data that existed at the time.

Here are five projects with that shape. Each one is small enough to finish in a sitting, each is built on a live dataset you can pull through the Alphanume API, and each pairs with an interactive lesson where the code already runs in your browser. Together they cover volatility, events, income, momentum, and signal auditing: a respectable cross-section of what systematic research looks like.

Project 1: a pre-earnings IV screen

The question: which names heading into earnings combine a track record of overpricing their moves with currently elevated implied volatility?

This project joins two datasets on ticker. From earnings move history you take each name's record: how often the options-implied move overshot the realized move, over how many events. From IV rank you take the state: where current implied vol sits inside the name's own trailing 52-week range. The output is one small table, one row per name, sorted by the size of the historical bias.

The skill it builds is separating tendency from state. A chronic overpricer whose IV sits at its yearly floor is a very different setup from the same name with IV stretched, even though the track record reads identically. It also forces a sample-size habit: a name with a handful of events is a story, not evidence, and your screen should drop it no matter how pretty the other columns look. The full build, including the attack on your own result, is the Building the Pre-Earnings Screen lesson.

Project 2: a dilution drift study

The question: what does the population of dilutive share registrations actually look like, and how long does the registration-to-effectiveness clock run?

The dilution feed carries every S-1 registration as known on its filing date: a human-read dilutive flag, shares offered, market cap at filing, and the effectiveness lifecycle. Your project computes two things. First, offering intensity: shares offered per million dollars of market cap, a crude but instantly effective way to separate trivial registrations from recapitalization-sized ones. Second, the timing distribution of days from filing to effectiveness, which is the window any systematic short exit gets built around.

The first thing the data teaches you is that a meaningful share of registrations are not dilutive at all, so shorting the feed indiscriminately would put you in all of them. That is event-driven research in miniature: the filter is the strategy. The guided version is the dilution event study lesson, and if you want to extend it into a standing scanner, see how to build a dilution screener.

Project 3: a dividend capture screen

The question: among names going ex-dividend in the next two weeks, which ones habitually drop less than the dividend and recover fast?

This is the rare beginner project that points forward instead of backward. The dividend capture dataset carries both sides: a forward ex-dividend calendar (declared dividends, ex-dates, pay dates) and historical ex-day behavior (drop ratios, recovery speed). Your screen pulls the upcoming calendar, pulls recent ex-day history cross-sectionally, and keeps the names where the drop ratio sits below 1.0 and the price recovered within a few sessions, ranked by what the dividend actually pays.

The skill here is joining a schedule to a behavioral history, which is the shape of most practical screens. Whether the underlying trade earns its keep is a real empirical debate, which we take up in does dividend capture actually work. The screen itself, built step by step, is the Recovery Odds and the Calendar lesson.

Project 4: a momentum rank tilt

The question: inside a live ten-name momentum basket, do the top-ranked names carry more of the continuation than the marginal ones?

The Quant Galore Momentum Index publishes a rules-based basket: ten deeply liquid names, re-ranked monthly, three fields per row (date, ticker, rank). The sparseness is the point. Your project groups rows by rebalance date, measures turnover between consecutive rebalances (every slot that changes hands is a round trip through the spread, so turnover is the strategy's cost engine), and tests whether weighting toward the top rank slots beats holding all ten equally.

This teaches a subtle and transferable idea: a ranking can carry information beyond membership. "Winners keep winning" is the headline claim of momentum; whether rank one differs from rank ten is a sharper question about the same data. The momentum basket lesson runs the study, and our momentum backtest walkthrough covers the broader methodology.

Project 5: auditing the movers slate

The question: a model publishes a daily slate of names expected to move big tomorrow. Does it deliver, and what exactly does it claim?

The next-day movers feed flags a handful of names each afternoon, and every row is point-in-time: the prediction is published first, the realized move fills in after the session closes. On the newest date, the outcome fields are null because the session has not happened yet. So your code starts by splitting pending rows from resolved rows, then computes the share of resolved names that moved more than 5 and 10 percent, and the median absolute move.

This is the best auditing exercise on the list, because the feed claims movement, not direction. A slate can be a genuine success with most names down on the day, as long as they moved. Learning to grade a signal on exactly what it claims, no more, is a skill most aspiring quants never practice, and it is the entire subject of the movers slate lesson.

How to work each project

Whichever project you pick, run it through the same four-step loop:

• Hypothesis: write the claim down before touching data, so the data cannot talk you into a different claim later.
• Data: pull the feed and inspect real rows before computing anything. Print a full record. Follow a filing URL. Know your fields.
• Measurement: one small table or a handful of summary numbers. Resist the urge to build a dashboard.
• Attack: hunt for the reason your own result is wrong. Sample size, regime concentration, a single tail event doing all the work.

The attack step is what separates a portfolio project that impresses from one that embarrasses. An interviewer will not be impressed by a Sharpe ratio; they will probe how you tried to break it. If you can name the weaknesses of your own study before being asked, you are doing research.

Run them in the browser

All five projects come from Alphanume Learn's course, Systematic Trading with Market Data, where each one is an interactive lesson: the Python runs in your browser against live API data, no setup, no videos, no toy datasets. A lesson states the claim, hands you the data, and grades what your code prints.

The first module is free and needs no account, and it builds the mechanism-first thinking the projects rest on. The full course, roughly 18 hours, is included with an Alphanume Pro membership along with the data platform; see pricing, or start from the syllabus and pick the project that pulls you in. Theory is cheap. Run the code.