You have to know that it didn’t get that way overnight. And more often than not, it didn’t get that way quietly.

On every step of the way down, companies like this are forced by regulators to publicly share every detail on exactly how business is going and what they’ve got planned.

All you have to do is look for it.

So, that’s exactly what we did.

A Primer on Advanced Event-Driven Trading

For a quantitative trader, you have to know that the “quantitative” part can only go so far.

At the end of the day, markets are driven by information, above all else.

Even for purely quantitative strategies like stat arb, that information component can cloud up returns as it’s really, really hard to hedge against a company that just announced it’s going bankrupt and went down 75% overnight.

By going the event-driven route, you’re still working with data and markets, the only difference is that the event happening is the signal.

Now, none of this might be news to you.

You’re likely already familiar with the most typical market events:

• Earnings

• Biotech announcements (e.g., FDA drug approvals/rejections)

• Fed meetings (e.g., rate cut/hike decisions)

However, this is essentially the tip of the iceberg:

The real edge comes from turning things that happen in the market and making them an event.

To see an example of this, let’s take a look at a understudied, but common market-happening:

Dilution

At a high level, dilution is pretty simple.

A company needs more cash and won’t or can’t take out a loan from the bond market. So, it simply issues new shares and sells them on the open market.

With those proceeds, it can do whatever it pleases; raise exec salary, increase R&D funding, pay off other debts, whatever.

Now, naturally, this isn’t risk-free cash.

If you’re an investor in one of these companies and get told that your 5% stake is now going to be a 3% stake, you’re going to be less-incentivized to hold it, let alone buy more shares.

And you’re not alone; the same dilution happened to the other 3,000 investors and they have the same view too.

When all of those participants have the same view, on the same stock, at the same time, the net result gets pretty predictable:

At this point, you might think to yourself:

Well, you can.

This is the core of the next tranche of event-driven trading:

You take a specific market happening, collect every time it happened, then see what happened after.

If it’s predictable in the way that economically makes sense (i.e., you expect diluted stocks to go down), you dive deeper and see if it can be a real return stream.

So, let’s do exactly that.

The Event IS the Trade

Okay, so we know that certain events lead to certain outcomes, so before building out the strategy, let’s map out which events we want to focus on:

• Dilution

  • Company issues new shares, existing holders get diluted, selling pressure follows.

• De-SPACs

  • A blank check company closes its merger and becomes a real company. The thing is, most of these companies went the SPAC route because they couldn’t IPO the traditional way. So, you’re already starting with an adversely selected pool. From there, it’s a mess of redemptions, float confusion, and brutal valuation discovery. The cohort underperformance is well-documented.

• Defaults

  • Company misses a debt payment, gets delisted, or enters bankruptcy proceedings. By the time this happens, the stock is usually already in freefall, but the event itself tends to accelerate the final leg down.

Once we have them all ordered by date and time, we then want to see what happens if we outright short them for a month.

So, going back to the strategy; we’re going to add a full day delay between when the event was logged and the time of trading.

If we got word of the event on Jan 1 at 10 am, we place a trade on Jan 2 at 4 pm.

This comes with drawbacks of its own, but it at least gives us a more realistic baseline that would match practical trade execution.

So, with our strategy and universe defined, let’s run a few mock simulations:

Read more

A few weeks ago, we publicly introduced Alphanume: the quantitative research data platform we’ve been building underneath Quant Galore for the past year.

If you missed the full backstory, it’s all here:

TL;DR: we kept building internal datasets to support our own trading; dilution events from SEC filings, point-in-time market caps, risk regime classifications, optionable universe snapshots.

Eventually we realized that most of this stuff simply doesn’t exist elsewhere in a clean, research-ready form.

So, we packaged it up and opened it to other researchers.

Since launch, we’ve continued to expand the library.

Every dataset now has a full practical guide walking through the mechanics, use cases, and how traders are actually building with it, starting with the De-SPAC Events guide and rolling out across the full catalog.

We've also shipped new endpoints and refined others. Here's a taste of what's in the library and what you can actually do with it:

→ Dilution Events: know the moment a company dilutes their shares, before the shares hit the market. This is a core dataset behind our short-selling basket strategy.

→ S&P 500 Risk Regime: a daily binary signal (risk-on / risk-off) going back to 2011. Use it to scale exposure, filter entries, or just stay out of the market when conditions are hostile.

→ Next-Day Movers: a daily, model-ranked list of the stocks most likely to make an outsized move the next session. Use it to buy (or not buy) straddles, screen for directional plays, or just know where the action is going to be.

→ S&P 500 0-DTE Strike Band: a daily expected range for SPX, derived from implied probability distributions. Sell spreads outside the band and collect premium where tail risk is overpriced, every day.

→ De-SPAC Events: De-SPACs, as a cohort, are one of the most well-documented sources of post-listing underperformance. Short the basket accordingly.

These sit alongside datasets for historical market cap, the Quant Galore Momentum Index, and optionable universe snapshots, all accessible via API, all stored point-in-time, and all designed to plug directly into real trading workflows.

The full dataset library and docs are here if you want to look around:

[Explore Alphanume →]

Now, the reason for this email.

We opened a small Founding Researcher program alongside the launch: 20 seats, $499 one-time, with lifetime access to every current and future dataset on the platform.

Those filled up quickly.

After the round closed, we kept hearing from readers who saw the announcement late and still wanted in. Many of them came with sharp questions, dataset ideas, and use-cases we hadn’t considered yet, which is exactly the kind of feedback that makes the platform better.

So, we decided to briefly reopen the program one last time to let a few more researchers in on the same terms.

That window closes today.

Once it’s done, we’ll move to a more traditional pricing structure as the dataset library continues to grow.

If you’ve been on the fence, this is the last note we’ll send about it. We’d rather under-sell than create inbox fatigue, but we also didn’t want this to close without giving everyone a fair heads up.

[Become a Founding Researcher →]

As always, the Quant Galore newsletter isn’t going anywhere. The research posts, strategy walkthroughs, and experiments will keep coming regardless.

Alphanume just gives us better tools to do it with, and now you can use the same ones.

Good luck, and happy trading. 🫡🫡

For the past couple of years, most of the work happening behind Quant Galore hasn’t been visible.

You see the posts, the strategy walkthroughs, and the experiments.

What you don’t see, however, is the infrastructure that sits underneath all of it:

• The datasets.

• The pipelines.

• The event feeds.

• The little internal tools that make research easier.

If you run systematic strategies for long enough, you eventually reach the same conclusion:

Most of the real work in quantitative trading has surprisingly little to do with trading.

It’s data.

Collecting it, cleaning it, structuring it, and most importantly, being able to access the datasets for tomorrow.

At some point we realized that a lot of the datasets we were building and trading off of internally might actually be useful to other researchers and traders as well.

So over the past year or so, we’ve been quietly assembling something a bit more formal:

Alphanume.

A quantitative research data platform designed specifically for systematic trading.

Today we’re publicly opening it up for the first time.

What’s The Point?

Naturally, there are already numerous reputable data providers. For instance, when it comes to price data, Massive (formerly Polygon.io) has been our top and sole provider for years and we have no plan on changing that.

However, there are very few datasets available that sit on that second layer.

The second layer of what you do after you get the price data.

You start asking questions like:

• Which assets are most likely to move tomorrow?

• Which equities actually had weekly options available at the time?

• Which stocks just entered a structural regime change?

• What types of routine corporate events predictably result in share price drops?

These are the kinds of questions that drive systematic trading research, but answering them usually means building datasets from scratch.

Which means writing pipelines, maintaining them, and constantly updating them so your research stays point-in-time correct and models don’t go haywire.

Over the years we built hundreds of these second-layer datasets internally.

Some of them became core parts of our daily research workflow and some of them ended up becoming the foundation for actual trading strategies:

• A Quant’s Guide to Cross-Section Maxxing [Code Included]

  • Rank stuff, long the top, short the bottom, go home.

• A Junior Quant’s Guide to Corporate Actions

  • There’s serious money to be made in SEC filings; the catch is, you actually have to read them.

• A Junior Quant’s Guide to Time-Series Momentum

  • You’re not predicting the future. You’re betting yesterday keeps happening.

Those are just some of the ones we’re starting with.

Now, rather than trying to describe the platform abstractly, it’s probably easier to show you a few of the datasets themselves.

Let’s start with one of the simplest, and one we’ve actually been posting the outputs of publicly for a while:

Next-Day Movers Feed

One of the first questions we kept coming back to internally was a simple one.

If you’re trying to become cross-sectional kingpins, you inevitably start asking:

Out of thousands of equities, which ones are actually likely to do something interesting tomorrow?

Not just drift a little, but produce the kinds of moves that make systematic strategies worth running.

At first glance, you might think the answer is simple:

“Just sort stocks by implied volatility.”

But markets are rarely that cooperative, as options already price expectations.

The highest implied volatility names are often the most obvious ones: earnings events, biotech catalysts, or stocks that are already extremely chaotic.

What we really wanted to know was something slightly different:

Which equities are most likely to produce a large realized move tomorrow?

So we built a model specifically designed to search for those candidates.

The result became what we internally call the Next-Day Movers feed.

Each trading day, the system identifies the five equities most likely to experience a large realized move the following day.

More formally, the model ranks the cross-section of liquid equities by their probability of producing large next-day realized volatility.

The actual dataset is delivered as structured data through the API, but if you visualize the daily output in a simple way, it looks something like this:

But underneath that simplicity is a fairly deep research problem.

Predicting realized volatility is one of the most interesting questions in quantitative finance.

Markets already price expected volatility into options, yet realized moves still regularly exceed expectations.

And when they do, the payoff can be dramatic.

For example:

• a stock moves 20% overnight

• short-dated options explode

• back-term volatility surface steepens

• liquidity shifts

These are the moments systematic traders live for.

Once you have a real-time and historical log of which candidates were most likely to have an underpriced large move, you can take things in many interesting directions:

• What happens if you simply long shares of the top five predicted movers each day?

• What happens if you buy short-dated OTM debit spreads on these names ahead of the predicted move?

• What happens if you sell volatility instead; do these stocks actually move enough to justify the options pricing?

• What if you trade the names relative to their sector group rather than outright?

• Do short-dated straddles or strangles on these names outperform the rest of the options universe?

• What happens if you combine the signal with momentum or mean-reversion features?

There are dozens of ways you could approach it.

But the point isn’t a single strategy, it’s that once you have a daily cross-section of extreme volatility candidates, delivered both historically and in real-time, an entire research surface opens up.

What Else Is In The Lab?

Over time we ended up building dozens of datasets like this: some focused on volatility, some on corporate events, and others on the structural plumbing of markets themselves.

A few of the ones already available through Alphanume include:

Historical Optionable Universe

A full point-in-time record of which equities actually had listed options on a given date.

This may sound simple and boring, but it’s the bedrock of almost every serious strategy we run.

Even better, the dataset tracks which tickers had weekly options available, allowing you to construct realistic short-dated options universes going back nearly a decade: it’s how we were able to validate our long-running momentum strategy.

Dilution & Corporate Offering Events

Share dilution is one of the most consistent sources of downward price pressure in small and mid-cap equities.

New shares enter the market, supply increases, and prices often adjust accordingly.

The problem is that the signals showing when dilution is happening are buried inside long, messy regulatory filings. Anyone who has tried to trade these events systematically quickly discovers that the real challenge isn’t the idea: it’s the data.

Filings arrive as dense legal documents, often hundreds of pages long, with the relevant information scattered across paragraphs of boilerplate language.

This dataset processes those filings into structured, machine-readable events, continuously scanning new filings as they appear.

Instead of dumping raw documents, the pipeline identifies dilution-related filings, extracts the relevant information, and timestamps the events so they can be used in point-in-time research.

The result is a clean feed of dilution and offering events that researchers can plug directly into systematic workflows.

Rather than reading filings manually, you can focus on testing questions like:

• How do equities behave in the days surrounding dilution announcements?

• Do certain types of offerings produce more persistent price pressure?

• Are there cross-sectional opportunities around newly announced share supply?

In other words, the dataset turns an unstructured regulatory firehose into something that can actually be tested.

S&P 500 Risk Regime

Another dataset we rely on heavily is the S&P 500 Risk Regime endpoint.

Short-term strategies often look great in isolation, but many of them quietly depend on the broader market environment.

Some strategies work well during stable periods of low volatility, others thrive during chaotic regimes where large realized moves increase and cluster.

The problem is that identifying those regimes consistently, and doing so point-in-time, is harder than it sounds.

This endpoint provides a simple solution.

Each trading day, the system classifies the market into a binary risk regime (1 or 0) representing the broader market environment.

Because the output is binary, it’s extremely easy to test as a filter, feature, or overlay.

Despite that simplicity, the signal goes back to 2011, giving researchers and traders more than a decade of regime data to test against.

With this data, one might explore questions like:

• How do short-dated options strategies behave across different regimes?

• Does a 0-DTE volatility selling strategy perform better when the regime signal is favorable?

• Do momentum strategies improve when filtered by regime?

• Does skipping trades during unfavorable environments improve drawdown characteristics?

In other words, instead of trying to manually determine whether the market environment is cooperative, the dataset gives you a direct signal you can plug into a strategy immediately.

Where This Is Going

Those are just a few of the datasets currently available, but in many ways, this is just the starting point.

The goal behind Alphanume isn’t simply to release a handful of interesting datasets; it’s to continue our day 1 mission:

Extracting every edge we can from every market we can get our hands on.

Equities are only one corner of the market ecosystem, but over the coming weeks, we’ll be aggressively expanding into prediction markets, futures, options, and crypto perpetual futures.

All held to the same standard:

If it can’t be used profitably, it shouldn’t exist.

Over the past few weeks, a number of researchers and traders have started using the platform, and your feedback has been incredibly helpful in shaping what we focus on next.

In many ways, that’s exactly how we want Alphanume to evolve: through smart, curious quants putting the datasets to work, stress-testing them, breaking things, and pushing us toward what actually matters.

And if you’re reading Quant Galore, there’s a good chance you’re exactly the kind of researcher we had in mind when building it.

Founding Researchers

To support the continued development of the platform, we’re opening a small number of Founding Researcher seats.

The idea is simple.

Rather than quietly building everything behind closed doors, we’d rather have a small group of sharp researchers using the datasets early, experimenting with them, and helping shape where the platform goes next.

If you’ve been reading Quant Galore for a while, you already know the philosophy: build things, test them, and see what actually works in real markets.

This program is essentially an extension of that idea.

Founding Researchers receive:

• Lifetime access to the full Alphanume dataset library
• Access to all future datasets as the platform expands
• Full API access for research and strategy development
• Early access to experimental datasets as they are released
• The ability to provide feedback that directly influences what we build next

The goal isn’t to create another passive data subscription, but to build a research environment where new datasets are constantly being tested, refined, and expanded into new markets.

Founding Researcher Access

For those interested in joining early, we created a small Founding Researcher program:

$499 (one-time)

We’re limiting this first round to just 20 researchers.

Once those seats are filled, the platform will move to a more traditional pricing structure as the dataset library continues to expand.

If you’re interested in exploring the datasets, building strategies on top of them, and helping shape where the platform goes next, you can learn more here:

[Explore Alphanume →]

Closing Thoughts

Quant Galore was never meant to be a place where we just run backtests forever.

The goal has always been to actually engage with markets: to experiment, to take real risks, and to see which ideas survive outside of a spreadsheet.

Alphanume is simply the natural next step in that process.

Now that we control the entire dataset infrastructure ourselves, we can get our hands dirty targeting the kinds of edges that larger institutions often can’t (or won’t) bother pursuing.

This allows us to stay fast, focused, and most importantly, ruthless, about hunting for new edges in markets.

Not an “interesting” Kaggle dataset that disappears in six months, but real pipelines, real research infrastructure, and a constant stream of new experiments across markets.

Quant Galore started as one person who was obsessed with systematic trading and wanted to become the best researcher possible.

Over time, we’ve grown into a community and network of incredibly smart and plucky people exploring strategies, deploying real capital, and pushing deeper into how markets actually work.

Alphanume is simply the next stage of that evolution.

A small, ruthless quant lab with much better tools.

Thank you for continuing to be part of the journey.

And as always,

Good luck, and happy trading. 🫡🫡

Quantitative trading is about many things; buying low and selling high, chasing momentum, capturing yield, arbitraging price imbalances — the whole lot.

But time and time again, it comes back to one idea:

The cross-section, the cross-section, the cross-section.

Now, if you don’t spend the majority of your life in code terminals and academic papers, the word cross-sectional might not mean much.

In practice, it’s just shorthand for “in relation to everything else.”

Looking at something on its own rarely tells the full story, but a broader context does (or at least helps).

For instance, if you’re looking at a 6’0 basketball player, you may deem him to be rather tall; however, if that same player is standing in a group where everyone else is at least 6’8, he suddenly doesn’t look as tall.

So instead of asking, “how much is X?”, the better question becomes, “how much is X relative to its peer group?”

That shift, from absolute to relative, is where many of the most persistent edges in markets begin.

To see just how powerful this concept is, let’s pay a visit to our old friend:

The Options Market

Despite the innumerable complexities of the options market, at the end of the day, it still largely boils down to buying low and selling high.

But how do you know what’s “low” and what’s “high”?

In options, that estimate is typically based around implied volatility:

Now, implied volatility is a rather tricky thing:

• On one hand, it clusters, mean reverts, and often signals stress in the underlying.

• On the other hand, it’s a model-derived construct — a number inferred from prices, but not a tangible asset you can hold.

To see what we’re getting at, let’s have a look at some data.

What Goes Up, Must Come Down — Sometimes

To begin, let’s have a look at the price of the S&P 500 with an overlay indicating regimes of high implied volatility:

As demonstrated, while it may not be a crystal ball, it is indeed useful at isolating periods where future realized vol is higher than usual.

But more importantly, every high vol regime ends.

When investors get worried and start paying a premium for options, implied vol spikes, but it never usually stays high.

To see another example of this, let’s look at the constant-maturity 10d implied vol for a random stock, say CELH:

The same dynamic appears, where periods of extreme relative implied volatility are typically followed by subsequent mean reversion.

We can take this a step further and zoom out to look at the behavior across a broad basket of liquid options:

At this point, you may say to yourself:

Well, this is where the theoretical nature of implied vol starts to kick in.

In the above examples, we used a constant 10-day implied volatility series — similar in spirit to how the VIX9D tracks a constant 9-day maturity.

Sticking to a constant maturity is analytically clean, but actually trading it is a bit messier:

To see this, let’s pitch a sample trade scenario:

From here, there are a few schools of thought:

1. Roll the 10-day tenor continuously.

   1. Each day, pull the option series closest to expiring in 10 days and short at-the-money straddles.

      1. This keeps you exposed to the exact maturity your model is based on, but it introduces path dependency. If the stock moves 5% on day one, you must close and reopen at a new strike and are thus constantly reshaping the position.

2. Short the nearest 10-day strip and hold to expiration.

   1. Instead of rolling daily, enter once and hold until expiration.

      1. This has a cleaner execution, but is now exposed to realized volatility risk. Even if implied volatility decreases as predicted, a large underlying move can overwhelm the trade if at expiration, one leg of the straddle is deep in-the-money.

3. Roll daily and delta-hedge continuously.

   1. In theory, this isolates pure volatility exposure.

      1. In practice, it requires constant trading, capital, precise automation, and optimized transaction costs. It’s elegant academically, but operationally heavy.

So, while you might be able to run a cross-sectional rank of vol to isolate stocks likeliest to make a larger move than normal, it’s a bit more difficult to fully capitalize on it with the same options that are already pricing in the move.

Now, while this highlights the inherent difficulty of options, fortunately, not everything is as hard.

To see that, let’s pay another visit to a dear friend:

The Stock Market

The power of the cross-section shines much more cleanly back in delta-one land, sometimes, almost too cleanly.

To demonstrate this, we’ll pull from a real-world strategy we’ve been running for quite some time:

Cross-Sectional Mean Reversion

The Quant's Playbook

Behind The Scenes of a Profitable Short Selling Operation

For most market participants, the playbook is simple: buy quality assets, hold on, and let compounding do its work. And honestly — it’s good advice. One glance at the S&P 500 over the last decade explains why it’s become the gold standard of investing…

Read more

7 months ago · 22 likes · 2 comments · Quant Galore

Now, when it comes to stock prices, the adage of “what goes up, must come down” has so many anti-cases that it’s unreliable on its own.

However, not all stocks are the same.

If we were able to isolate those, we could sell the highest tranche when it goes up, then buy it back lower after some time.

Thankfully, such a class exists — but not without some quirks.

To begin, let’s pull the full stock universe on a given date t:

Now, 5,000 names is quite a big breadth. To make things easier for ourself, it will help to first classify these stocks by size — we’ll go with a simple market cap classification to start:

Market Cap Tier Mapping:

5 → Mega Cap      (≥ $200B)
4 → Large Cap     ($10B – $200B)
3 → Mid Cap       ($2B – $10B)
2 → Small Cap     ($250M – $2B)
1 → Micro Cap     ($50M – $250M)
0 → Nano Cap      (< $50M)

That absolute bottom tranche, the 0s, is where our bread and butter lies.

As we’ve addressed before, these nanocap names, while capacity-constrained, represent the worst of the worst and almost uniformly head to bankruptcy in a series of dilutions, shady financings, and de-listings — a target rich environment for a short seller.

Once we have our target universe at that point-in-time, we can then move onto structuring this into a trade strategy.

Note: Accurate point-in-time market cap data is extremely important for running this. Nano-caps today may not have been nano caps yesterday, and in these names especially, the shares outstanding values can change by the month. We used Alphanume’s historical market cap endpoint to ensure we avoid look-ahead bias.

Now, we don’t want to risk getting into an overfitted quantitative framework, so for simplicity, we’ll define our strategy as follows:

1. For all nanocap stocks on day t, we calculate the distance of the stock price from a fixed-period moving average (e.g., 10 day TWAP)

   1. We use the prior day’s market cap as the current day’s wouldn’t be known until the end of the day.

2. We then rank all stocks in the grouping from highest percentile to lowest, based on that distance

   1. If SMX is 40% above its fixed period average price, it will rank higher than IBIO, which may be 8% above its average.

3. We short an equal-weighted basket of the 10 most-extended names and hold until the next rebalancing cycle.

4. Repeat.

Extremely simple, but let’s see what the data says:

Read more

This was a year for the quants.

To show why, we’ll start with a brief recap of our live strategies, beginning with our time-series momentum portfolio:

The approach itself is deliberately simple:

1. On the first calendar day of each month, we query all stocks with at least 6 consecutive weekly option strips and at least $50m of daily volume.

2. For each valid stock, we calculate a momentum score using a 12-1 lookback window (last 12 months of data excluding the most recent one) and sort the selection from highest to lowest scores.

3. We purchase the 10 with the highest score and hold them in equal-weight until the next month.

This is a textbook expression of the momentum factor; one that has persisted across markets and regimes for well over a century.

As the PnL snapshot from Interactive Brokers shows, the strategy experienced periods of both extreme euphoria and sharp drawdowns this year, particularly during the unwind of the AI and quantum-computing trade:

Even so, it finished the year with a solid gain, reinforcing a familiar lesson: simple ideas, applied consistently within the right universe, tend to endure.

Our next core strategy has been a quantitative, tactical approach to short selling:

You can get a better read on exactly what we’re doing here:

The Quant's Playbook

Behind The Scenes of a Profitable Short Selling Operation

For most market participants, the playbook is simple: buy quality assets, hold on, and let compounding do its work. And honestly — it’s good advice. One glance at the S&P 500 over the last decade explains why it’s become the gold standard of investing…

Read more

7 months ago · 18 likes · 2 comments · Quant Galore

Now, short selling carries a structural asymmetry that can’t be engineered away: the maximum gain is capped at 100%, while losses are theoretically unlimited. Even if the signal is strong, you’re guaranteed to see that grim-reaper over a long enough time horizon.

Eventually, we were reminded of that reality.

On an otherwise routine trading day, our morning process produced a typical basket of 10–25 names. As usual, we entered shorts at the opening auction and planned to cover at the closing auction.

Things were going as expected, until a well-known market figure made a very public comment:

What followed were trading halts, extreme volatility, and a price path that looked like this:

Reviewing the trade records later that day made the impact clear:

We ultimately covered the position at roughly 4× our entry price. While this was far from a worst-case outcome, it was a defining reminder that “two-standard-deviation events” are not theoretical.

Now, we run a portfolio approach precisely to absorb outliers like this; but still, the experience warranted caution. We paused the strategy for roughly a month while exploring other markets and re-examining the risk profile.

When we returned to the data, nothing fundamental had changed. The historical characteristics matched the live experience, including the overall positive return profile. With that context, we’ve begun re-integrating the strategy at size; this time with a more explicit acknowledgment of its tail behavior.

"Why not just use a stop loss?"

We often observe that adding a stop loss tends to drastically hurt the EV of a strategy, as it often triggers just from routine variance of the underlying price (path-dependency risk). 

This creates losses in otherwise profitable trades. Additionally, like with SPRB, an immediate extreme move paired with halts make it much less likely that the stop loss order would fill at the ideal price set. 

Nevertheless, in each of these strategies, every single one, one truth comes up again and again:

For our long momentum portfolio, the universe is deliberately restricted to stocks with deep liquidity and sustained options activity. We’re not asking whether investors might be willing to trade these names — that demand is already established. The challenge just becomes isolating relative winners within the sub-group.

Applying the same ranking logic indiscriminately across the entire equity market produces far less reliable results, despite no change in the signal.

With this universe, we don’t have to predict if investors would be willing to buy these shares, we already know that they are — extensively. All we need to do is isolate the relative performers of the group; still tricky at times, but much more doable and actually likely to succeed over the long haul.

The same principle holds on the short side.

Our short universe is constrained to stocks with market capitalizations below $50 million at each point in time. These names already represent the least institutionally favored segment of the market. From there, the task is once again relative selection, not prediction.

When this logic is applied to large-cap stocks like MSFT or TSLA, it consistently breaks down; another example of how an otherwise reasonable strategy hinges on the specific universe chosen.

How We’re Approaching The New Year

For better or worse, we keep finding ourselves drawn back to the cryptocurrency space.

We’ve previously outlined our primary crypto strategy, which you can read about here:

The Quant's Playbook

Quantitative Trading Is Awesome.

Imagine a business model where, before earning your first dollar, you must spend years building a research lab: data infrastructure, strategy development, and soft-launch pipelines just to get real-world feedback on your ideas…

Read more

5 months ago · 16 likes · Quant Galore

At a high level, it’s a monthly rebalanced long-short portfolio: long BTC, short a basket of structurally weak tokens via perpetual futures.

It’s a sound approach, and one we’re comfortable running in production.

Still, it felt… incomplete.

Crypto is defined by its extreme dispersion and occasional explosive right-tail events. Our initial universe of liquid perpetual futures contracts tended to suppress exactly that behavior, by design.

In many cases, their realized volatility is not meaningfully different from that of single-stock equities (e.g., at the time of writing, BTC implied vol is ~40, marginally higher than that of Crude Oil (33).

If we wanted to get a piece of some of that explosive action, we’d need to return to our core principle: deliberate universe construction.

Rather than starting with mature, exchange-listed tokens, we began exploring the opposite end of the spectrum — newly created assets, before they even appear on a centralized venue.

That decision immediately exposed the scale of the challenge.

We started by querying all newly launched Solana tokens within a rolling eight-hour window, then measured their returns over the subsequent eight hours.

In that brief span alone, we observed roughly 5,600 new tokens; the equivalent of thousands of IPOs occurring every trading day.

The outcomes were sobering, laughable, and interesting:

• Of the 5,600 tokens launched, only 2.4% generated a positive return over the next 8 hours.

  • Most observed no future price change due to 0 volume.

• Only 0.4% had an average notional volume of at least $10,000.

Now, to be fair, most of these coins were duplicates of other popular coins:

Instead of rage-quitting there (which might honestly be the best decision ☠️), we figured out a way to construct a more stable, yet fresh universe of tokens to choose from.

Once we had a more stable universe, we defined a crude, mock momentum strategy:

1. Each calendar day, at 8:00 PM, compute a momentum/volatility score for each asset and buy the top 10 in equal-weight.

2. The next day at 8:00 PM (24hr rebalancing), sell the assets and generate the new basket using the latest data/universe.

3. Repeat.

Here’s how that did:

Read more

Imagine a business model where, before earning your first dollar, you must spend years building a research lab: data infrastructure, strategy development, and soft-launch pipelines just to get real-world feedback on your ideas.

A rational person might look at that structure and walk away to do literally anything else.

But not us.

As we’ve transitioned from pure research into actual live trading, our public content output has tapered, but our internal knowledge and experiential nuance have grown exponentially.

Today, we want to open the curtain and share insights that only come from being fully immersed in the trenches; insights that we guarantee you simply won’t find anywhere else.

We want to again thank you for reading, for sticking with us, and for being part of this journey.

So, without further ado, let’s get right into it.

The 35 Million Request Problem

We need to admit to something… not great.

During our research-lab phase, we wanted readers to be able to replicate our experiments in real time. This served two purposes:

1. To give other budding quants real, hands-on tools to work with.

2. To help surface any errors or blind spots in our processes.

To replicate our strategies, you needed data – specific, granular, and lots of it. We assumed we were small enough that leaving an API key or two inside a code snippet would simply give a few people a head start before they eventually built their own pipelines.

In hindsight, we had no idea how the internet actually works.

On a perfectly normal, sunny day, we received a rather serious note from our data provider:

What we intended as a quiet “leg up” for a handful of readers somehow escalated into 35 million API requests across 700+ unique IP addresses — in 30 days.

To be fair, most of this was likely from forgotten cron jobs or plug-and-play servers. But the scale was… interesting.

Rightfully, our provider immediately shut off our keys pending further review.

However, it wasn’t long before this “oopsie” turned into a genuine moment of panic.

You see, for quite some time now, our main bread and butter has been short selling.

Specifically: shorting baskets of structurally weak microcaps; the <$50M names experiencing sharp, idiosyncratic volatility spikes. It’s a niche, but a highly effective one… as long as the data keeps flowing.

So, when the access first cut off, our initial reaction was, “Okay, one day off; tough, but survivable.”

But then, the second-order effects hit us.

Our entire short-selling operation is a tightly coordinated orchestra:

• Market-cap classification jobs (requiring up-to-date shares-outstanding)

• SEC-filing retrieval jobs that depend on those classifications

• Realized volatility forecasting jobs that depend on those filings

• And finally, the daily basket constructor that depends on the forecasts

If the data stops, the whole machine stops. Not just the trades — everything. And this is just for one strategy.

A single point of failure at the provider level could take our entire infrastructure offline. For a strategy that lives and dies on early-morning responsiveness, it was simply unacceptable.

So, we bit the bullet and spun up a new subscription, temporarily increasing our operating costs by a few thousand per year. Expensive? Yes. But the alternative was worse; way, way worse.

In theory, the solution is simply “just use multiple providers.”

But in reality, market data is still fragmented, with differences in universes, schema quirks, and cost structures that make multi-provider redundancy far from trivial. With that being the case, it’s not totally unreasonable to build around one primary source.

Nevertheless, it was a rather interesting and illuminating experience.

Now, onto other matters of business.

Our Equity Trading Engine

Our core U.S. equity short-selling strategy remains largely unchanged. You can get a deeper dive of what we’re doing here:

The Quant's Playbook

Behind The Scenes of a Profitable Short Selling Operation

For most market participants, the playbook is simple: buy quality assets, hold on, and let compounding do its work. And honestly — it’s good advice. One glance at the S&P 500 over the last decade explains why it’s become the gold standard of investing…

Read more

7 months ago · 15 likes · 2 comments · Quant Galore

Now, one drawback of this strategy is that the opportunity set can be relatively constrained. Some days will simply not have any prediction outputs and we thus sit it out. Some days, there are valid outputs, but there are no shares available to locate (we’re already using specialized locate brokers, so these are the super-capacity constrained nano-caps).

Most days though, we’re able to efficiently get down size and operate in a systematic manner.

However, while the opportunity set is variable, the cost of operations is not; and it only goes one direction: up.

On the surface it may appear as plain greed, but we came to think that we needed a way of continuously having at least some exposure — always, 24 hours a day, we need to be exposed to some sort of opportunity set that can keep the cashflow pumping.

With that mission set, it didn’t take long before we revisited an old friend.

Building a Crypto Desk

The beauty of crypto is that it trades 24/7, has an extremely wide opportunity set, and now with the invention of decentralized exchanges and perpetual futures, comes with the ability to run sophisticated strategies at scale.

However, the inherently decentralized nature of crypto makes building any suitable infrastructure rather challenging.

You see, with stocks, price data comes from Standard Information Processors (SIPs), corporate actions data comes from the SEC EDGAR database, and the exchanges operate within a specific time window.

In crypto, almost none of this is true:

• Most idiosyncratic flow of a token is driven by Twitter accounts or other influencers.

• Only the tokens with the deepest liquidity “graduate” to being listed on major exchanges

  • This creates a selection bias for a short-oriented trader as your universe is constrained to the “best” that were able to garner enough liquidity / interest.

• There are no true “official” data sources (excluding oracles).

  • One data aggregator (e.g. coingecko) might combine price data for a token taken from 5 exchanges, but one of the exchanges might only include data when a trade on that specific exchange is made, so when the aggregator includes data over that period, it can end up looking very different from the prices actually observed at the respective timestamp.

In other words: the data is messy, uneven, and inconsistent.

Nevertheless, we never shy away from a challenge; after all, there is always an edge in doing hard things others aren’t willing to.

So, we’ll walk you through how we were able to establish a small foothold in the space.

Porting Equity Models Into Crypto

At the end of the day, crypto is a market like any other: certain assets behave in certain ways for specific reasons.

So, we figured that to start, we’ll just port over some equity trading logic.

On our first venture into the space, we explored a simple strategy of simply going Long BTC and short ETH. The rationale was that this was effectively a relative value trade between the S&P 500 (BTC) and the Russell 2000 (ETH).

Now, for awhile, this was an extremely effective and high-sharpe trade:

Eventually though, the trade experienced a massive unwind and has since struggled to recover:

Although, this sucked, it didn’t really change anything about the core mechanism of a long-short strategy.

So, we thought:

“If Bitcoin is the bellwether of crypto, perhaps we just needed to be more creative in what we shorted against it.“

The rationale for choosing ETH was that it was the “little brother” of Bitcoin, but with some effort, we could probably find something with a stronger reason for why the trade should exist.

After some experimentation, we stumbled on something interesting: exchange tokens.

In order to understand how we got here, we should first take a cursory glance at how many exchange tokens work:

Read more

For most market participants, the playbook is simple: buy quality assets, hold on, and let compounding do its work. And honestly — it’s good advice. One glance at the S&P 500 over the last decade explains why it’s become the gold standard of investing.

Now, while this works for most investors, it doesn’t fit all.

There exists a class of participant who see the market as not just a way of capital to companies, but rather a mechanism that can be systematically leveraged for personal profit.

As quantitative traders, we are that class of participant.

To bring you up to speed, we still actively run our monthly-rebalanced long momentum strategy which has continued to perform exceedingly well:

However, when it comes to the buy-side of markets, there’s really only so much that you can do.

Our long only momentum strategy has delivered strong results, but it remains tied to the broader market. If the bull market continues, it should keep outperforming — but in a market-wide drawdown, strategies like this inevitably take a hit.

And if a trading business can be dragged into months of losses just because the market slipped, that’s not a robust business. The core mandate of quantitative trading is simple: generate profits in all conditions: up or down.

To mitigate some of that one-way risk, we began gearing our operations to focus on short-selling:

The Quant's Playbook

Quantitative Short Selling is Still Free Money... Kinda.

At The Quant’s Playbook, we take market opportunities very seriously. If we even get a whisper that there might be alpha lurking in some overlooked corner of the market, we break our backs to verify it, and if it’s real; we push it to production as fast as possible…

Read more

9 months ago · 18 likes · Quant Galore

At first, we messed around with purely quantitative strategies like chasing volatility and shorting small-cap stocks that became over-extended in pre-market trading.

Over time, we shifted toward deeper structural edges: how markets react to SEC filings and corporate actions, such as dilution events revealed in S-1 filings.

That pivot made the difference.

By anchoring our strategies to clear, rational mechanisms rather than noise, we found substantially more consistent success:

The Quant's Playbook

A Junior Quant's Guide to Corporate Actions

To quickly bring you up to speed: we have fallen in love with short selling…

Read more

9 months ago · 17 likes · 1 comment · Quant Galore

We last left off describing a rather trivial implementation of short selling a stock for 30 days after a given corporate event.

Since then, we’ve taken that seed idea and scaled it into something much bigger: a daily cash engine built on short selling.

In this piece, we’ll pull back the curtain on how we do it: synthetic index construction, complex order execution, and the mechanics of turning it into real profits.

So, without further ado, let’s get right into it.

It’s Like The S&P 500, But Reversed

You’ve probably heard the idea that small traders sometimes hold an edge over large institutions. On the surface, that sounds paradoxical, but sometimes, it’s true.

To see this, let’s examine our early approach of shorting a company for 30 days after they make a dilutive S-1 filing. When a company dilutes their own shares, it’s often seen as a desperate last-option move for raising cash, so most companies don’t do it (instead, good companies tend to buy back shares, reducing total float — the opposite of dilution).

These moves happen most often in nano-caps on the brink of delisting. A $40B hedge fund might see the same signal and know that the stock is headed lower, but they can’t size into a $50M market cap without distorting it or eating massive slippage; so they pass.

Smaller traders don’t have that constraint. You can press $100K into a setup like this; a rounding error to a megafund, but a high-expected-value trade for those willing to scoop up the scraps.

Of course, though, with every pro comes a con.

Shorting $5 nano-caps looks linear most of the time — until you meet the grim reaper: tail risk.

To see an example of this, let’s take a look at Forward Industries (NASDAQ: FORD):

In the market regime at time of writing (Q3 2025), it’s become a popular trend for stale, under-the-radar companies to announce that they’re running some new “crypto treasury” strategy, sending their shares higher on the news. A few days later, an SEC filing follows, revealing that the company is raising cash at those elevated levels. Not long after, the price drifts back down and the company is never heard from again.

The big picture is clear, but the risk remains that any one of these names could rally 10x on a gimmick theme before reality sets back in.

While these blowups are the exception rather than the rule, you can’t build a viable business if one day you wake up and lose 10x your capital for no good reason.

So, that sparked an idea:

What if instead of taking these single-stock wagers, we created an index of hundreds of these “toxic” assets to continuously short?

Idiosyncratic risk is unavoidable by nature, but it is largely hedge-able through sufficient diversification. So, what if we just created an inverse S&P 500 — instead of the 500 best companies, what about a universe of liquid, toxic companies only?

Such an index would virtually be a straight line down; but as a short seller, that’s the point. If we created such an index, we would aim to replicate it daily through short sale exposure by shorting the individual components.

Now, we already know that overnight borrow costs can be steep, so instead of just doing buy and hold, we opt for daily intraday exposure.

This has a few advantages:

1. No overnight borrow costs.

   1. In the land of small-cap biotechs headed for failure, overnight borrow costs can exceed 200% on an annualized basis. While you’ll still have to incur per-share locate costs (e.g., $0.003/share), it will be dramatically cheaper than funding an overnight position.

2. No margin interest.

   1. With most professional brokers, you can borrow up to 4x your starting capital under Reg-T margin. If positions are flattened before the close, there’s no interest expense.

3. Lower tail risk.

   1. Idiosyncratic risk doesn’t vanish, but realized intraday volatility is generally dampened by higher liquidity and tighter spreads during regular hours; unlike pre/post-market, where thin books make stocks easier to whip around

The structure is simple: each day we borrow as much as we can, short the weakest companies, close positions by the bell, and reset to do it all again tomorrow.

Of course, in this business, the theory is the easy part. It’s execution that demands the real elbow grease.

Index Replication: Easier Than You Think

At first, the idea of buying or selling hundreds of securities at once seemed daunting. Would we have to eat the bid/ask spread on every name? How could we coordinate all the orders to go out at the same time?

Surprisingly, it’s much simpler than it sounds.

The key lies in one of the most underappreciated, but genius features of modern exchanges: opening and closing auctions.

These auctions are designed to match all eligible orders at a single, consolidated price — the official open or close of the trading day. Think of them like massive, well, auctions: every order submitted before the cutoff is considered, and the exchange determines a clearing price where the most volume can be matched.

If you’re running daily backtests with OHLC data, those “open” and “close” prices aren’t just the first or last trades of the day — they’re the actual prices set in these auctions (for daily OHLC data specifically).

To participate, you have to specify it explicitly with Market-On-Open (MOO) or Market-On-Close (MOC) orders.

This mechanism is what makes basket execution clean and scalable.

Once you're plugged into the auction logic, trading at the open or close becomes far more orderly and, more importantly, far closer to your backtest than you might expect.

The only real exception is in ultra-illiquid names where auction volume is thin (e.g., stocks with average daily notional volumes of just a few thousand dollars). Those are easily avoided with basic filters.

So, now that we have a way of getting in and out of the market with minimal slippage, the next step is generating the orders themselves.

That too is easier than you’d think.

Most professional trading platforms support basket order functionality: you just upload a pre-configured CSV of orders and fire it off with a single click.

We first generate the daily basket in Python by iterating through the names in our toxic index and writing the orders for submission:

Next, we upload the file to our trading platform:

Once it’s loaded, we do a quick sanity check to make sure everything looks right, then hit execute and let the auction handle the fills.

Read more

To quickly bring you up to speed: we have fallen in love with short selling.

Once we beat the constraints of most retail brokers and figured out how to short virtually anything we wanted, we launched a blitzkrieg to explore what strategies we could build on this newfound access.

But this time, we knew better than to take a raw data-hacking approach.

When developing trading strategies, it’s essential to begin with a plausible, baseline rationale for why a price move might occur in the first place.

So before touching a single row of data, we asked ourselves:

“What known events result in predictably lower returns?“

Eventually, we landed on one of the most reliable drivers of large price moves: corporate actions.

Corporate actions are just the umbrella term for all events a company reports:

• Earnings

• Share splits

• Dividends

• Dilution events 😏

• Management changes

What makes these events especially attractive is that they occur on defined dates, which makes applying a systematic strategy intuitive; for example, “short for n days after the event on date t.”

Now, in this business, most ideas go nowhere.

So we live by a fail-fast operandi:

data collection → crude backtest → small-scale prod.

Once we formed a baseline theory around a particular corporate event, we ran a simple simulation and then jumped straight into production to see what the real-world results looked like.

To our pleasure, this started off a sequence of extremely profitable trading, as briefed below (apologies for formatting):

Now, this corner of the market — event-driven short selling — has legitimate alpha and capacity, but there are some serious nuances that you need to know to understand why the edge exists.

So today, we’re walking you through the full, real-world process of turning these murky filings into actionable trades: from ideation and data collection, to simulation, and ultimately, live capital deployment.

As always, we’ll share the code and tools so you can replicate (or debunk) everything for yourself.

Without further ado, let’s get right into it.

You’ve Gotta Read The Filings, Man.

Before we dive into the deep end, let’s start with the basics.

Our objective is to expand our reach in the short-selling business.

We want to know when a company does something bad and place ourselves in front of the inevitable.

So, we asked ourselves:

“What kinds of events are considered “bad” by the market?”

Well, for one, take dilutive events.

Here’s how it works:

• Company A starts with 10 shares, each priced at $10 → Market cap = $100.

  • The company issues 40 new shares → Total shares = 50.

  • No new value is created → Market cap still = $100.

  • The new theoretical share price becomes $2 ($100 ÷ 50 shares).

  • Existing shareholders are diluted and now own a smaller % of the company.

You’ve probably seen this play out with certain meme stocks, where a huge retail-driven run-up is quickly followed by a new share offering. The company takes advantage of the inflated price to raise capital; after all, they do generate net usable cash from these offerings.

But almost invariably: companies don’t do this from positions of strength.

Dilution is often a last resort, used by companies that:

• Can’t access the bond market

• Operate in high-risk sectors like biotech, where cash = runway

• Are trying to prolong the inevitable bankruptcy

So, at this point, we can form our first hypothesis:

If a company dilutes their shares, the forward returns post-dilution should be negative.

Given our specialized broker access to locate and short the shares, we can plausibly execute short-sales and capture those negative future returns.

Now, that we have the idea, let’s get some data.

We’ll start with a dataset from DilutionTracker (no affiliation):

You see, when a company plans to dilute their shares, the price doesn’t always drop right away. It usually happens in stages, like this:

1. S-1 Filing

   1. The company files a registration statement with the SEC, announcing its intent to issue new shares. This doesn’t guarantee anything, it’s just a heads-up that dilution may be coming.

2. S-1/A Amendment

   1. If the offering progresses, the company submits an amended filing with updated terms regarding pricing, share count, or selling shareholders. Still, there’s no guarantee the deal goes through.

3. Form EFFECT

   1. Once everything’s finalized, the SEC issues an EFFECT notice. This means the offering is now legally effective and the shares can be sold.

   2. Once this is out, the stock price immediately drops.

Because the offering might be delayed, canceled, or have its terms amended, the market doesn’t immediately price in the dilution.

So, now that we have our target event, there are a few paths we can take to form a strategy:

• (A) Build a model to predict whether the share offering will be confirmed within 30 days.

  • Since the price often doesn’t drop on the initial S-1 filing, we could pre-position before the EFFECT form hits, then buy back after the drop.

• (B) Short the day after the initial filing and hold for 30 calendar days.

  • Here, we’re betting, lightly, that the offering will be priced quickly, but more importantly that the filing itself marks the company as “bad”, and thus likely to produce negative forward returns.

Having faced this juncture countless times, experience says start with option B, then if the baseline crude results are good, we can then add a refinement layer.

If the simplest version of the strategy doesn’t work, optimizing it often becomes putting lipstick on a pig.

DilutionTracker’s dataset covers all non-IPO S-1 filings for micro and small-cap stocks, so we’ll use that for our first test:

1. On the next trading date after a dilutive S-1 filing is made, we establish a short position at the close.

   1. We’re not aiming for HFT speed, so we implement a realistic delay of when we’d actually be able to trade.

2. 30 calendar days later, we buy the shares back.

3. Repeat.

Here’s how that basic test performed:

Read more

At The Quant’s Playbook, we take market opportunities very seriously. If we even get a whisper that there might be alpha lurking in some overlooked corner of the market, we break our backs to verify it, and if it’s real; we push it to production as fast as possible.

Well, recently, we found something real.

Picking back up from our earlier short-selling experiment, we dove headfirst into the entire short-selling ecosystem and committed ourselves to building and deploying a strategy around it:

We started with a crude test: short the small-cap stocks showing the highest one-day volatility; no overthinking.

After verifying the historical simulation, we went straight into prod, paid some steep borrow costs, and to our surprise, did pretty well.

Eventually though, we hit a wall; one that every serious short seller runs into:

Basic retail brokers aren’t built for this.

Now, if you’re retail and looking to get into “big boy” trading, the industry standard is Interactive Brokers.

IBKR will generally let you short the shares you need, albeit at a steep borrow cost; but once you start venturing into the murky corners where the real edge lives: the $2 garbage fires, the pump and dumps — you’ll often see stuff like this:

You can sit there and watch the price drop 40% over the course of the day, but if they don’t have it, you don’t get it — period.

Naturally, being the plucky quant that you are, you think to yourself that there must be a way to be able to short the shares you need. Actually, screw the shares you need, you should be able to short anything you want.

So, after some digging, you find out that you were still a fresh-faced rookie in the short selling business and that there exists an entire network of specialized brokers that focus exclusively on short selling.

Doesn’t matter if you want to short TSLA or a $0.50 Omaha Refrigerator company — they will get you the shares.

We were already in motion when we hit this bottleneck, so the second we found out about these brokers, we signed up, deposited a sizable amount and kept trying to get our strategy back up.

Of course, as is tradition in this business, that freedom came with a price.

Today, we’re going to give you an in-depth tour of the shadow world of exclusive short-selling brokers, share a pretty interesting strategy we developed (with real trades to prove it), and dive into some damn fun quant stuff along the way.

So, without further ado, let’s get right into it.

The True Cost of Freedom

Alright, you’re a fresh-faced quant looking to dip your toes into short selling. You think to yourself:

“There’s always a handful of stocks that double in pre-market, only to fizzle out by the close. Why don’t I just short those?”

You run a quick, transaction-cost-free backtest and the results look killer. So, naturally, you jump straight in to see what the real-world costs actually are.

You fire up your production script, generate your daily basket, and head over to your broker — ready to pounce.

But before you can even risk a single dime, you’re hit with a message from your broker:

Upon returning to Earth from your rage, you put in a bit of elbow grease in search of a way to short these shares and eventually, you wind up at TradeZero (no affiliation).

You search for the same stock you were blocked from shorting and quickly realize this is a whole different game.

With specialized brokers like these, the model is flipped. You don’t just borrow shares that are available; you pay upfront to locate them:

The cost of a locate is typically charged per share, and most of these brokers require a minimum request — usually 100 shares. Just like traditional borrow fees, the cost changes based on demand and how difficult the shares are to source.

If it’s a low-float name with only 30,000 shares outstanding, expect to pay up.

Think of a locate like an option: you're paying for the right, not the obligation, to short the shares.

Say you’re offered a locate for 100 shares at a cost of $120. At that point, you’ve got three choices:

• Use the locate and submit a short sell order for those shares

• Credit the locate back to the system (sometimes possible)

• Let it expire unused at the end of the day

Now, in the above example, the cost for getting the ability to short 100 shares was $120. We can run a quick test on what that’s costing us right off the bat:

• 100 shares * $25.48 = $2,548 notional exposure

• $120 fee on that → 5% of total size (120 / 2.5k)

Now, as we covered in our first intro to the short selling business, this isn’t really that big of a problem. The expected variance of shorting garbage hovers around 15-20% per day, so that 5% hurdle is easily beatable.

The bigger issue is that this creates a kind of pseudo-barrier. Let’s say you’re starting with the $25,000 minimum needed for intraday trading. If you only want to risk 1% of your account on a single name, that’s $250.

But remember: you already paid $120 for the locate. If you only put $250 into the position, you'd need the stock to drop nearly 50% just to break even. To keep the breakeven around 5%, you’d need to short the full 100 shares, which puts about 10% of your total account on the line.

That kind of sizing might make sense in a high-quality momentum portfolio, but for shorting explosive small caps? That’s just reckless.

That said, the cost of this locate was an edge case and not the norm.

Just one day later, after the stock cooled off, the same locate became dramatically cheaper:

We’ve also encountered cases that add even more friction — like stocks under a short-sale restriction (SSR), which means any short order must be placed at a price above the last traded tick.

In the example below, we had a stock that was both hard-to-borrow and under an active SSR. Nevertheless, the locate was surprisingly cheap: just $1.35 for $130 worth of short exposure — roughly a 1% breakeven:

Single-use locates like this are often cheaper because once you pay, you’re obligated to short the shares; no backing out.

Locate pricing, in general, can swing wildly throughout the day as demand and supply shift, but operationally, it’s fast: it only takes about two seconds to quote and accept a locate.

So, at this point, we had conquered a major constraint: we could short anything we wanted — stocks, warrants, ETFs — whenever we wanted.

With that complete, this brought us back to the real challenge: actually being right.

Thankfully, after a lot of leg work, we were able to put together a pretty robust framework that we’ve already taken live.

Now, we’re usually pretty open about our strategies, often going as far as publicly open sourcing them entirely — but as you’ll see in a moment, there are a few details we have to keep close to the chest.

Stuff We Should Probably Keep to Ourselves

At a high level, we’re just shorting pre-market pump-and-dumps.

Sure, we could dress it up with some rationale like:

“Due to limited liquidity in early pre-market trading, price discovery tends to be inefficient and diverges from fair value — a mean-reverting dynamic we aim to exploit.”

But really, we’re just doing the “obvious” — and it works.

Read more

At The Quant’s Playbook, we typically focus on building brand-new quantitative trading strategies from scratch, putting them through rigorous tests, and deploying them in real markets to make money. However, that’s only one part of the equation when it comes to building a real quantitative trading outfit.

This post won’t be our typical strategy or live market exploration — this one’s more about the overlooked backend foolery that keeps the machine churning.

We’re going to take a much-needed look behind the curtain at how managing data works in a real, mid-frequency quant setup.

We’re not HFT, so there won’t be things like microwave signals or ultra high-speed tech, but there’s still plenty of interesting ground to cover.

So, without further ado, let’s get into it.

“90% of the game is wrangling data, only 10% is actually trading.”

Medium-frequency trading (MFT) is loosely defined as having a holding period ranging from a few minutes to a few months. Some might define it differently, but for our purposes, that’s the timeframe we’re referring to when we talk about MFT.

If you’re trading on this timeframe, your data needs start off fairly simple: your basic, garden-variety OHLCV data, like this:

You typically just need the raw historical prices to test whatever idea you have, and then you go on about your day.

However, over time, you start to realize that the price data of a single stock over a single time period is essentially meaningless on its own.

Substantially more information can be found on a cross-sectional basis — not just how this stock performed, but how it performed relative to a bunch of others and across different time periods.

So, after pulling data for one stock, you pull data for another. Then one more. Then you think, screw it: why not get data for every stock in the market?

Now, of course, the data has to come from somewhere. We heavily use and strongly recommend polygon.io.

And remember, we want to analyze the market as a whole. That means pulling data not for one or two tickers, but potentially thousands.

Here’s what that looks like:

1. Your code tells Polygon: Give me 5 years of data for SPY

2. Polygon reads the request, retrieves it from its database, and sends it back

3. Your code/system receives the data

This process, at worst, takes about 3 seconds, but remember, this is for thousands of stocks — so if we wanted the data on 5000 stocks, it would take ~4 hours just to get it all!

Naturally, you don’t want to go through that every time you want to test an idea. The smart trader in you knows: just eat the 4 hours once and save the data locally.

So you do.

You let the code run, maybe watch some South Park, and after a few hours, you're sitting on a massive 100GB+ dataset.

But right away, a few problems show up:

1. It eats space and slows your system.

   1. That 100GB+ file sits on your machine, clogging up storage and dragging performance down.

2. Backtesting out of this will be a nightmare.
   Every time you want to run a strategy, your code has to:

   1. Read-in the entire dataset

   2. Search it row-by-row to get the excerpt you need (e.g., ticker == “AAPL”)

   3. Then start doing the actual strategy computations.

3. Updating this data will be an even bigger nightmare.
   You have to:

   1. Pull the full dataset again

   2. Find which dates are missing

   3. Append the new rows

   4. Re-save the whole thing

      1. With every new update, the dataset gets bigger, messier, and harder to work with.

Thankfully, it doesn’t have to be this way.

In just a second, we’ll walk through the “right” way to handle massive datasets and run intensive computations without wrecking your machine or your workflow.

We’ll try to keep the rest of this as relatable as possible — but if you're a data nerd, you're going to love what’s coming.

“It’s all in the cloud now, bro.”

First things first, in quantitative trading, you don’t want to save your data locally.

Yes, you might have some proprietary data you’re hesitant to expose, but it only takes one mishap: the janitorial staff mops a little too close to your desktop, water seeps into the SSD port, and suddenly you wake up to no data, no access, and no real control over your core business.

If you’re working with a team across different locations, you need remote access. But even if you’re solo, there’s nothing worse than sitting at a hotel bar in a new city, getting a great idea then realizing your data’s locked up on your home machine. Ask us how we know.

So, first things first: we’re moving to the cloud.

While there are many services, we think it’s best to just go with the biggest dog in the game: AWS.

It’s the industry standard for a reason: not only does it offer specialized products for use cases specifically like this, but its reliability is the selling point — they’re like the U.S. Treasury of servers.

Sure, you might see the occasional site hiccup here and there, but serious data infrastructure? It basically doesn’t fail. Just think: when’s the last time your grocery store’s self-checkout crashed mid-transaction? Or ever seen Netflix fail to not bill you? It’s all AWS, basically.

We’ll be using something in the AWS ecosystem called an S3 bucket.

Think of it as a remote computer where you can store files — basically Dropbox, but instead of ahem private photos, you’re storing enterprise-grade data.

Now, to refresh context: we’re a medium-frequency operation just looking for a way to store a ton of data safely and efficiently.

So, now that we’ve got a place for it to live, the next step is getting it there in a way that lets us send and retrieve it almost instantly.

We’re going to do pretty much the same thing as before: pulling the data from Polygon, but instead of saving it as a CSV, we’ll use a Parquet file.

To see why, take a look at this sample large dataset of stocks:

This dataset is about 14 million rows long, but watch how drastically the file size drops when we save it as a Parquet file instead of a CSV:

Just changing the file type cut the on-disk size by more than a third.

Using Parquet instead of CSV doesn’t change the way we can interact with our data, so it’s essentially a no-lose upgrade.

That said, looking back at the sample dataset: the dates are out of order, there are multiple tickers mixed around, and we definitely don’t want to open the entire file every time we just need data for one ticker.

To solve this, we’ll be deliberate about how we structure our files.

Since we’re working with daily data, the simplest solution is to give each ticker its own folder.

We’ll structure it like this: Daily Data/[TICKER_NAME]

So if we want to save data for AAOI, we’ll file it under:

Daily Data/AAOI/AAOI.parquet

Here’s what that looks like on the AWS S3 platform:

Now, it’s totally understandable if the point of this extra separation isn’t immediately obvious.

The key advantage is that each individual ticker file is compressed down to just a few kilobytes. S3 is already highly optimized for fast data transfers, but when each file is that small, we can access huge amounts of data almost instantly.

To demonstrate the speed advantage, we’ll run a quick sample backtest.

One version will pull daily data for 10 stocks in our investing universe using the S3 Parquet folder structure. The other will pull the same data from the larger, messier imported dataset.

It’s a crude test, but even with the overhead of “talking” to the S3 server and navigating the folder structure, this approach was nearly 3x faster than working from the large dataset stored locally which didn’t require any online querying at all.

Final Thoughts

If you’re going to take this quantitative trading stuff seriously, you’re going to end up running hundreds, maybe thousands, of tests that lead to absolutely nothing. That’s just part of the game.

Eventually, though, you’ll find something.

Ahem — if you’ve been following along and replicated our time-series momentum strategy from a few months ago, then yeah, we’re literally putting a real alpha in your hands that we’re actually making money with — it’s kinda just levered beta, but still. Go get rich. (Kidding… kinda.)

The point is, once you’ve deliberately structured your infrastructure for the “fail fast” approach, everything changes. You can invalidate bad ideas as quickly as you validate the good ones.

Now, if a lot of the terms we covered today were jargon, don’t feel bad: outside of full-time data engineers and quant developers, most people have never touched Parquet files or S3 buckets.

You can of course still get by doing things your own way, but hopefully, this gave you a glimpse into what more structured, scalable infrastructure looks like when applied specifically to quantitative trading.

In our first Volatility Trading Bible, we walked through some more infrastructure like this — SQL tables on AWS, automated trading servers; but we’ve gotten a lot better since then. Not just in the quality of our strategies, but also in how we approach infrastructure with current best practices.

We have a vision to essentially package these real-world infrastructure concepts and real-world strategies that actually work and scale into 1 definitive series that you won’t find anywhere else on the planet.

We’re building something serious and if you’ve made it this far, you’re probably the kind of reader we’re doing it for.

Also, definitely join The Quant’s Playbook Discord. Talk shop about the strategies running, ones you’re running on your own, questions, or just stay in the loop.

Good luck, and happy trading. 🫡🫡

Still need to scratch that itch? You might enjoy these:

• A Junior Quant's Guide to +EV Options Trading

  • Basically, it’s how to tell if your trade idea is already priced in and whether an option is truly underpriced or just a bad bet.

• A Junior Quant's Guide to Chasing Vol and Shorting Stocks

  • The first step in our descent into short selling, kicking off with a hands-on experiment in volatility clustering.

• Quant Galore Crypto #002: Onboarding

  • We’re not done with our crypto experiments. This guide gets you fully set up to follow along with the quant-driven strategies we’ve got cooking.

Outside of capturing vague, esoteric edges, much of quantitative trading boils down to one thing — buying low and selling high.

Take our momentum strategy, for instance:

• Each month, we screen the most actively traded, optionable stocks and rank them using a 12-1 historical lookback combined with a custom momentum metric.

• We then buy the 10 highest-ranked names and rebalance the portfolio monthly.

Here’s a snapshot of this month’s live production performance as of the time of writing:

This was our first month in production, partially fueled by a bit of FOMO after seeing how strong the previous month’s performance was (+40%):

We recommend taking a look at our full breakdown of the strategy, and if you’re really ambitious, give our GitHub repository a look so you can run it yourself:

Time-Series Momentum GitHub Repository

We’ll be posting another update soon with new insights on execution, basket selection, and more. But for now, we’ve got some more urgent matters to cover.

So, although we’re running an active strategy that’s generating solid returns in a scalable way, we have to confront an uncomfortable truth:

If the broader market goes down, this strategy is dead.

Sure, the basket is relatively uncorrelated, diversified across sectors, and driven by idiosyncratic flows; but in the event of a systemic shock or broad market drawdown, correlations go to one and momentum names tend to fall the fastest and hardest.

At the end of the day, while we are capturing the momentum effect, we’re also essentially just long very high beta. When the market’s strong, we can significantly outperform the S&P; but when things turn south, drawdowns of 50% or more are well within reason.

Once we acknowledge this existential risk, the natural impulse of any trader is to start designing some complex hedging structure — a big protective payout if things go south.

But we’re not going down that road.

Hedging is generally negative expected value (EV) and option prices are pretty efficient, so we’ll often be accepting perpetual underperformance in the good times for only marginal relief in the bad.

Instead, we’d rather take a page from the multi-strategy legends: rather than hedge, diversify.

Specifically, by introducing a strategy that operates on the other side of the equation: short selling.

When we started this experiment, we had never placed a single short trade at scale. In short time, we were pulled into a rich and surprisingly profitable world filled with locates, borrow fees, and volatility-chasing.

The short selling game is massively underappreciated and with a bit of effort, far more accessible than you might think.

We won’t keep you waiting any longer; so, without further ado, let’s dive in.

A Primer on Short Gambling

To begin, we were essentially starting off with a totally blank page:

“Okay, we want to build a strategy that revolves around short selling — now what?”

Our first instinct was to just reverse our existing momentum strategy: if we're already buying the winners, why not just short the losers?

After some testing, it became clear there was a major obstacle:

In the world of short selling, borrow fees are everything.

Since this can get confusing quickly, let’s start with a high-level overview of how shorting actually works:

1. You identify a stock to short.
   Let’s say your momentum system flags Stock XYZ as a loser. You’re running the trade through your brokerage account at Interactive Brokers.

2. IBKR checks if shares are available to borrow.
   You can’t short XYZ if there are no shares going around, so IBKR looks across its network of counterparties to locate inventory.

3. Goldman Sachs has the shares.
   Goldman is holding 2 million shares of XYZ in custody for its clients — long-term holders like pensions or index funds.

4. Goldman lends the shares to IBKR.
   Goldman agrees to lend out the shares (charging a borrow fee), and IBKR passes them along to you, with a markup on top.

5. You short the shares.
   With borrow confirmed, IBKR lets you sell the shares into the open market. You’re now short XYZ and your PnL rises if XYZ drops.

6. ***You start paying borrow fees daily.***
   Here’s the kicker: borrow isn’t free. If XYZ is “hard to borrow” (low inventory), your costs might run 20%, 100%, even 900% annualized!

Interestingly, this entire mechanic — lending out long-held shares for short sellers — is a major business, reliably bringing in billions a year for firms like Goldman and Vanguard. Their “edge” is that they’re not taking market risk by buying shares and lending them out, but rather the original holders (pensions, index funds, clients) still keep the shares they own, Goldman just facilitates the borrow.

Nevertheless, the biggest challenge with short selling is the borrow fee that’s charged daily.

You see, if a stock is commonly known to be garbage with no future, you likely won’t be the only person trying to short it. If your ideal holding period is 1 month (like in our long momentum strategy) and the borrow fee is 300% annualized, you’re going to have to pay nearly 25% of your size:

• Daily interest = Annualized rate / 365 days = 300 /365 = ~0.82%

• Monthly interest = Daily interest * 30 days = 0.82 * 30 = ~25%

However, this need not be the end of our journey.

If the borrow fees are on the higher end, like 300% — that amounts to a daily interest charge of ~0.82%. By shortening our trade horizon from 30 days to just 1 day, the breakeven point shifts — instead of needing a 25% move to be profitable, we only need a 1% move to cover the cost of the borrow.

At that point, borrow fees become a much more manageable hurdle.

So, all we have to do is get exposure to the worst stocks that are likeliest to have the largest 1-day volatilities so that we can beat borrowing costs — easy, right?

Maybe not. But we wouldn’t have made it this far in this business without the willingness to at least try.

Just Predict Vol, Bro. It’s Easy.

Luckily for us, predicting volatility is a lot easier than predicting direction.

So, to begin, let’s re-visit a pretty well-known phenomenon:

Volatility tends to cluster.

In other words, if the past n days were highly volatile, the next n days are likely to be volatile as well.

There are numerous studies on the subject, in fact, it’s one of the earliest hallmark observations in quantitative finance; but you don’t need a research paper to see it in action, just look at any chart of the VIX (implied volatility):

So, if we know that the best predictor of future volatility is recent volatility, we can start by building a simple ranking metric:

1-day historical volatility

In other words, if a stock moved 50% yesterday, can we reasonably expect it to move at least 1% today — enough to cover the borrow fee?

Testing this is relatively trivial, but first we need to define our investable universe.

To avoid survivorship bias, we construct point-in-time universes that reflect which stocks were actively tradable at each moment in history. This way, we won’t foolishly make ourselves look like geniuses for doing things like buying NVDA back when it didn’t even have $1,000 in average daily volume.

Now, unlike our long momentum strategy, we’re not targeting the highest-quality, most liquid names. Instead, we want stocks that are just liquid enough to short — enough for your broker to locate shares, but sketchy enough to avoid just replicating levered beta all over again.

So, we’re going to loosen our criteria from those with the deepest options liquidity to those that had at least $5m in average daily trading volume. This instantly gives us a pool of ~2,500+ eligible stocks to choose from each day.

With this survivorship-bias-free universe in place, we sort by which stocks had the highest 1-day volatility and then observe what volatility looked like the following day.

Here’s a few recent, notable examples:

As you can see, these names aren’t exactly household favorites (KIDZ? GORO?), but this simple heuristic reliably surfaces stocks with high short-term realized volatility.

Now, of course, realized volatility != direction, so although we can reasonably conclude that a stock will have high realized volatility as soon as tomorrow, we’re still in the dark as to whether it’ll go up or down.

In order to make this work, we’re going to need some way of getting an angle on direction. This is the early stage of the research process, so this is the part where you just toss around ideas and see what sticks.

Challenge: You have a way of knowing which stocks are going to double overnight, you just need a way to systematically get the direction right, at least 51% of the time.

How will you do it?

Take some time.

Well, one idea goes back to what we already know about the SPX-VIX complex — higher implied volatility tends to be associated with lower forward returns:

So, what if we applied that same logic here? If we know a stock is about to experience elevated volatility, why not assume that volatility skews to the downside?

With that idea in mind, we can define a simple strategy:

Read more

ChatGPT is a great thing — arguably one of mankind’s greatest creations since the Internet itself.

While it’s phenomenal at general tasks and high-level reasoning, when it comes to trading, things get a little bit more nuanced.

Most of the time, when a paper or strategy uses GPT, it’s riddled with lookback-bias, unrealistic assumptions, or just plain naivety.

However, it doesn’t have to be that way.

Today, we’re going to get our hands dirty and explore how to use these tools effectively for real-world, practical quantitative trading.

We’ll run the full gamut from actionable prompts that generate fresh insight, to solving some tricky data engineering problems, and ultimately integrating it all into a live, profitable quantitative trading strategy:

This one’s going to be exciting — and we promise you’ll walk away with something valuable.

So, without further ado, let’s get right into it.

Big shoutout to @quant_arb over at — his Building an AI Agent Hedge Fund served as an inspiration for some of the ideas we’ll cover. Definitely worth checking out!

Just How Smart Is GPT, Really?

If you’re going to be frequently using generative AI tools, one thing is certain: you’ve got to do some of the groundwork yourself.

If you just ask it to “create a profitable strategy”, it’s likely to regurgitate the most upvoted comment from a Reddit thread — something that sounds clever but absolutely doesn’t work.

So instead, we’re going to start with a strategy that already works.

To do that, we’ll pull inspiration from our time series momentum strategy:

Prompt:

“We have the following quantitative trading strategy: every month, we first pull the stocks with liquid, weekly option listings. This basket is created to isolate the most actively traded and relevant names.

From this list, we create a momentum score to rank past performance characteristics into top-and-bottom deciles.

At the start of each month, we hold the top-decile for the duration of the month and then rebalance at the end of the month.”

This prompt simply stores it in GPT’s context window so that we don’t have to keep re-explaining it.

Now, this strategy already holds up well as-is. Just for reference, here’s how the top-decile performed out of sample in the month prior to this writing:

Again, we invite and encourage you to replicate this yourself and even verify it in real-time: Time Series Momentum GitHub | Quant Galore

That said, while the strategy already works well, we wanted to see if we could push it a bit further:

• What if we didn’t have to wait 30 days to realize PnL?

  • Could we pivot to intraday exposure?

  • Could we flip weekly options instead?

• Could we surface even better stock selections?

For our first experiment, we’ll give the intraday angle a shot. It’s definitely noisier, but by expanding our universe to the scrappier small-caps — names that may not have weekly options but can still move — we open ourselves up to way more optionality.

To kick things off, we’ll return to GPT. But just like before, we’re not expecting it to do all the work.

Here’s the simple intraday framework we’ll use:

1. Instead of using 12-1 historical data (the past 12 months, excluding the most recent), we’ll just look at market open to noon.

2. From there, we calculate a momentum score over that window.

3. Then, we rank by those scores and go long the top 3 each day before selling at market close.

4. Repeat.

Now, remember, while there are just a few hundred stocks with liquid weekly options, there are thousands of stocks without them.

Even after filtering for stocks with at least $5 million in notional volume on each historical day, we’re still left with around 2,500 U.S. stocks to process.

If we want to run this over just one year, that’s roughly 98,000 data points per stock (390 minutes × 252 trading days). Across 2,500 tickers, we’re talking about ~245 million rows — easily over 30GB. And with RAM usage scaling with disk size, unless you’ve got a machine packing 100+ GB of memory, good luck storing that all at once.

Thankfully, this is where GPT shines — tackling well-defined, closed-end problems. And data engineering like this is full of them.

So the question becomes: GPT, how can we work with this data without frying our entire machine?

Now, if you’re working with GPT a lot, you’re just not going to be typing out these well-structured long, descriptive prompts every single time.

Most of the time, it looks more like this:

Before using GPT, the original script for collecting this data had an estimated completion time of over 3 days, and it only got slower as RAM pressure increased.

However, after passing in the script and having GPT replace a few lines with saving to parquet and a few other RAM tricks, the estimated runtime dropped to just 22 minutes.

For closed-end problems like this (i.e., “how do I make the machine do X?”), GPT is a godsend.

So, we’ve got the data, the infrastructure, and the model — now let’s make our fortune.

If you’re already a paid subscriber, truly — thank you. ❤️ Your support powers better data, better tools, and better research.

If you’ve been enjoying the work and want to support what we’re building, consider becoming a paid subscriber. It means more than you think and helps us keep doing it right. 🫡

Read more

As a trader, you have an incredibly tough job — take the following scenario for instance:

On June 1st, an S&P 500 restaurant company announced quarterly earnings that came in way hotter than expected, and the stock jumped +25% overnight. The report was kept under tight wraps, so unless you were directly involved with the company, there was no legitimate way to know that in advance.

Sure, you could work your tail off trying to get ahead of the news — tracking parking lot visits, conducting interviews with customers, scraping executives’ LinkedIn posts to sentiment analysis models — the whole gamble.

But sometimes, you just can’t know the future.

Still, the potential rewards are too great to walk away. So, you, like all traders at one point, get a new idea for predicting the future — looking to the past.

After all, the saying goes: “history doesn’t repeat, but it rhymes.” Why shouldn't that apply to markets?

Now, we’re not new to this. We know that when “pattern recognition” comes up, it’s usually followed by more novice approaches — specifically, chart-based trading with shaky track records. We’re not here to dismiss those traders entirely, but let’s be honest — there’s a better way.

This is a common point all quantitative traders eventually land at, so it’s only right that we take some time to dive into some experiments trying to make a buck with this route.

This is a crossroads all quantitative traders encounter, so today, we're going to run a few experiments — not with the expectation of finding a crystal ball, but to give the pattern recognition game a fair shot, explore its strengths and weaknesses, and maybe uncover something interesting along the way.

Without further ado, let’s get into it.

Pattern Recognition, Without the Astrology

Now, in order to play the pattern recognition game, we need some kind of starting framework.

We’re a quantitative finance publication first, so we’re going to be a little plucky here and draw from our friends in the math department — but don’t worry, we won’t go so far into the weeds that you’ll need a graduate degree to keep up.

To begin, we’ll start with a surprisingly intuitive concept:

Euclidean Distance

It may sound intimidating, but this just a way of calculating the distance between two points.

When applied to a time series — like price or return data — it gives us a single number that summarizes how “far apart” two sequences are in shape and scale. A smaller number means the patterns are similar; a larger number means they aren’t.

To make this more intuitive, let’s walk through a real-world example.

We’ll start with one sample price series — the performance of the S&P 500 on a given day:

With a price series in hand, we can run an interesting experiment: when the day looked like this leading into the final hour, what usually happened next?

To answer that, we’ll need a way to identify the days that were most similar to the current one and then we can analyze what happened from there.

That’s where Euclidean distance comes in.

Because it gives us a clean, interpretable number, we can iterate through historical dates and find the closest matches using only the data available up to the 3PM cutoff:

Remember: The lower the Euclidean distance, the more similar the datasets. The higher the value, the less alike they are.

As demonstrated, this approach does a pretty decent job of matching the shape of time series, with the closest match often looking almost identical, at least optically.

Now that we have the tool, we can start to build a sample strategy to see how effective it actually is:

1. For any given trading day (up to one hour before close), we find the 10 most similar days based on Euclidean distance.

2. Of those 10, we take a majority vote to estimate the final hour’s direction.

   1. If 7 of the 10 similar days closed higher, we consider that a 70% likelihood the current day will do the same.

   2. If there’s a 50/50 split, the default is long.

3. Based on the predicted direction, we long or short $1,000 worth of SPY and hold for 1 hour until close.

4. Repeat.

Now, if you’re going to do this quantitative trading thing seriously, you need to be able to anticipate the results of a test before writing a single line of code.

So, before we dive into the results, let’s talk about what we’re up against:

• Information Blindness: This, like most pure quantitative approaches, is totally oblivious to real-world information. We’re matching data by similar shapes, but not factoring in things like regimes, idiosyncratic events (e.g., Fed talk), or any other catalysts driving price.

• Short-Term Variance: The shorter the timeframe, the higher the randomness. Most days are just noise. If the S&P happened to go up on some random Tuesday, it may not have been driven by anything meaningful and our shape-matching model could end up "learning" randomness.

So, with those limitations in mind — what do you think the results will be?

Take a second and try to predict it.

While you’re thinking:

If you’re a paid subscriber, truly—thank you. ❤️ Your support helps us keep pushing further: better data, better tools, better research.

If you’ve been enjoying the work and want to support what we’re building here, consider becoming a paid subscriber. It means more than you think, and it helps us keep doing this right. 🫡

Alright, now let’s dive into the results:

Read more

"You’re not predicting the future. You’re betting yesterday keeps happening."

Not long ago, we set out to understand how quantitative trading strategies really work — and since then, we’ve been sticking to a pretty reliable formula:

“Start with a broad strategy class, form a clearly-explainable market view, find the optimal expression, lever up, and go home.”

As we’ve covered in our Junior Quant’s Guide to Ultra-Leveraged Trading, we realized that generating alpha isn’t done by just rote-copying a methodology, but rather by taking the high-level concept as a baseline inspiration and then applying a proprietary angle to make it yours.

We made a decent bit of progress with our relative value approach, but naturally, we wanted more.

So, with the blueprint for strategy discovery in mind, our first step was to find a big-picture strategy class, then once we understood the core mechanics, we’d get our hands dirty and see what we could do differently.

After some searching, we landed on a crowded, but interesting corner of the market — momentum.

Now, we’ve briefly touched on momentum in the past, but we’ve upgraded our tools and knowledge substantially since then — so, with fresh eyes, let’s see how we set out to see just how much we’d be able to pull out of this corner.

But before we try to outsmart it, let’s see how this thing actually works.

The Basics of Momentum

• Core idea: Stocks with strong momentum continue to have strong momentum — the best performers continue to do well, the worst performers continue to do poorly.

• Typical application: The most cited momentum paper suggests a basic 12-1 monthly return sort. So, taking the returns of the last 12 months, excluding the most recent one, and using that as your ranking metric.

  • You’d buy the best performers in that decile and short the worst, creating a market-neutral momentum portfolio.

Simple enough: just buy the winners and short the losers — easy, right?

Well, as we’ll demonstrate shortly, the high-level concept is always the simplest part. Actually implementing it effectively is where things get tricky.

To see how, let’s first address the problem of creating our initial investment universe.

An investment “universe” is just the set of stocks that we’re choosing from. While we only want to have exposure to a few stocks, there are thousands in the available universe.

This introduces the first real problem: how do you narrow down the total universe?

Well, one approach is to start with just those that have liquid, weekly option expirations.

Options availability is directly tied to trader interest and liquidity — if a stock has a weekly option expiration cycle, it’s likely a stock that “matters”. This simple heuristic helps weed out penny stocks, illiquid names, and anything the market isn’t seriously watching.

However, this kind of data isn’t just sitting around in pre-packaged apps. If we want to narrow it down properly, we’ll need to do it ourselves.

Getting Our Hands Dirty

We’re going to be working with historical universes, so it’s crucial that we avoid survivorship bias.

A rookie mistake is to pull the stocks that are available right now and then use that as the universe for historical testing.

This is problematic because it ignores stocks that were delisted or became illiquid, and instead focuses only on those that survived to the present day. If a stock made it to today, odds are it performed decently—but you wouldn’t have known that at the time.

So, first things first, we head over to the polygon.io API and we pull all of the stocks that were actively traded on a given day:

Naturally, this will yield thousands of tickers, the majority of which are unsuitable to us.

So, one thing we can do is sort by those with the highest notional volume that day.

• Notional volume simply refers to the $ amount of shares traded, generally calculated as the volume-weighted average price (VWAP) multiplied by the volume of the day.

  • 10 shares traded at ~$10 a share gives a notional volume of $100 (10x$10).

We don’t want to go too complex early on, so we’ll just apply a simple heuristic of needing at least $50m worth of shares traded on that day.

This alone narrows down our list from ~5000 to less than 800, bringing some of the more recognizable names to the forefront:

From this smaller selection, we then want to query what the options chain for those stocks looked like on that day.

We want to see at least 6 consecutive weekly option listings, this will demonstrate that these are stocks that “mattered” at that point in time. If the consecutive option listings are non-weekly (e.g., Jan 17 → Mar 17 → Jun 17), we skip it.

Although pinging the API for each stock to check the dates sounds computationally intensive, this task only takes ~5 minutes for a moderately fast CPU.

Once we’ve cycled through our selection for the given date, we arrive at our final universe:

Starting with a messy list of ~5000 stocks, we were able to narrow it down by a factor of 14, leaving us with some of the most liquid and actively traded names as they existed at that historical moment — no lookback bias, no survivorship.

So, now that we have a smaller, workable universe, we need to work on our methodology to actually know which to long and which to short.

If you’re already a paid subscriber, truly — thank you. ❤️ Your support powers better data, better tools, and better research.

If you’ve been enjoying the work and want to support what we’re building, consider becoming a paid subscriber. It means more than you think and helps us keep doing it right. 🫡

A Sharpe Dose of Beta

First, we need a fair way to determine whether a stock was a strong or weak performer.

If we just use average historical monthly returns, things can get skewed. For example, if a stock doubled in one month but stayed completely flat the other 11, the average monthly return would be around 8% (100 ÷ 12) — which is a bit misleading.

So instead, what if we simply used the Sharpe ratio?

The sharpe ratio is just a measure of risk-adjusted returns — if the stock went up in a straight line with minimal volatility, the sharpe ratio will be high — if it went up with major volatility, it’ll be lower:

Now, while the sharpe ratio is great for describing the overall “shape” of the returns, it doesn’t give us much insight beyond that — a stock that went from $10 to $11 in a year with no volatility would have a very high sharpe ratio, but it wouldn’t exactly be the most suitable if we’re chasing outperformance.

We need a way to walk the line between chasing low volatility and high absolute returns.

To do that, we introduce another metric — beta.

Beta essentially just represents the sensitivity of a stock relative to a benchmark like the S&P 500 — if a stock has a beta of 3, it implies that for every 1% the S&P 500 goes up, the stock will go up by 3%.

So, using the same lookback period (last 12 months excluding last), we calculate the beta of each stock compared to the S&P 500. Once we’ve got Sharpe and beta in hand, we can start to build a high-level view of our dataset:

We create a metric, mom_score (momentum score), that’s essentially the beta multiplied by the sharpe ratio.

This way, we get a single, sortable metric that’s clearly interpretable:

• High mom score = high beta, high sharpe → strong positive returns

• Low mom score = high beta, high negative sharpe → strong negative returns

Using this metric, we can now sort the available stocks into top and bottom deciles — These two deciles form the bedrock of our sample momentum strategy:

1. Each month, we pull the available universe and use historical data to calculate the momentum score for each stock.

2. We purchase the 10 stocks with the highest scores and simultaneously short the 10 with the lowest scores.

3. We hold this long/short basket for 1-month.

4. Repeat.

To get a clearer picture of what this looks like in practice, here’s a sample long-short basket from our dataset:

Top Decile

Bottom Decile

As demonstrated, this sample portfolio performed as expected, with the net average return of the long basket outperforming that of the short basket over the same period.

Now, let’s zoom-out and see how this approach performed in aggregate:

A very crude implementation — but so far, not bad.

Now, as always, we have to address certain realities — there’s a few things that make this not as easy as it seems:

Read more

You don’t need a thesis when you’ve already seen the play.

While The Quant’s Playbook is primarily dedicated to quantitative investing and trading, every now and then we explore markets outside the traditional financial world — especially when there’s real edge to be had.

Sports betting is one of those markets.

Now, just like any other market — if you want to sustainably make money, it’s good to have at least some form of edge.

Generally, your edges will be in one of a few categories:

• Analytical — being able to process the same data better

• Behavioral — exploiting predictable human biases

• Informational — being able to access faster. exclusive, or underpriced information

Of the three, an informational edge is the most potent advantage you can have.

Models built on public data can only go so far, and behavioral biases aren’t always present or exploitable. But if you have game-changing information that others don’t — that’s almost as good as free money.

To get an idea of what an information edge might look like, let’s walk through an example:

Scenario: A star player gets injured moments before tipoff.

That single event can ripple across the betting markets:

• Without that player, the team’s offensive output is likely to drop, making the over/under line for total points temporarily overpriced. Say the market was pricing a 50/50 chance for 200 total points—without the star, a more realistic number might be 150.

• At the same time, the opposing team may now be undervalued on the moneyline (outright winner/loser bet), as their odds to win have quietly improved on the absence of the star competitor.

• Second-derivative bets may also be mispriced — for instance, if Player X consistently racks up assists by passing to the now-injured Player Y, their assist totals bet may be set too high, since their go-to option is no longer on the floor.

Of course, information like that is immeasurably valuable — but in most well-developed markets, such information is kept tight:

• If you’re an NBA coach, you’re not going to risk your salary, reputation, and job security just to tell your buddies that your star player caught the stomach flu on the bus to the game.

• If you’re a player, you’re constantly reminded that betting activity is under a microscope. Since legalization, scrutiny has only intensified. Sharing inside info — or worse, betting on yourself — isn’t just risky; it’s a career killer.

In most cases, by the time the news reaches you, the odds have already moved.

But not always. There are still ways to access proprietary information — and act on it faster than the sportsbooks. Sort of.

The Basics of Courtsiding

Courtsiding is basically as the name implies: you sit courtside, watch the play happen in real time, and place your bets before the sportsbooks can update their odds.

Example Scenario:

1. Say there’s a live bet on LeBron James to make at least 20 points. He currently has 15, and there are 12 minutes left in the game.

2. He’s passed the ball and makes a 3-pointer.

3. You already have the bet pulled up across multiple sportsbooks. The moment the shot goes in (or seems like it will), you place the bet at the stale odds still reflecting 20 points.

4. If you’re fast enough, you can either:

   • Instantly cash out once the odds adjust (buy at 50%, sell at 75%), or

   • Hold the position, knowing you locked in a value price before the market caught up.

Simple and rough, but this is actually a thriving practice for those in the know:

We’ll go into the deeper specifics in a moment, but despite what you may think, there are still significant delays between when an event happens and when you see it on screen.

The delays for major sports like the NBA are small, sometimes as fast as 12 seconds, but for things like European Tennis, you can sometimes bet on an outcome that was already settled a minute ago.

The main reason this edge still even exists is that the capacity is so low:

• If you’re a bettor, you can’t realistically sit courtside to every game that happens — generally, you can only do it at home games in your city, so just a few trials per month.

• If you’re a sportsbook operator, you can’t realistically have physical employees at every live game you offer.

  • Even if you could, so few bettors do courtsiding, so moving from a delay of 30 seconds to say, 7 seconds, would likely not justify the cost and training of those new, salaried employees.

If we were in the 1910s, this would be a novel, wide-open idea that we could easily print money with. However, as technology gets faster and faster, the delays, while inherent, are getting smaller and smaller — still beatable, but you’re going to need some skill.

So, now that you have a general understanding of the basics, let’s take a deeper look into the nuances of actually pulling this off where we show you exactly how it’s done and the real-world profits being made.

Before we dive in:

If you’re a paid subscriber, truly—thank you. ❤️ Your support helps us keep pushing further: better data, better tools, better research.

If you’ve been enjoying the work and want to support what we’re building here, consider becoming a paid subscriber. It means more than you think, and it helps us keep doing this right. 🫡

Limited-Time Offer

The Nuances of Courtsiding

Read more

“There are only three ways a smart person can go broke: liquor, ladies and leverage.”

If you’re a quantitative trader or even just a general market participant, we all know the goal is to make money. However, some of us like markets so much that we earnestly try to make a business of it. At that point, however, it’s not just about making a profit — it’s about making enough profit — enough for employees, enough for better data, enough for better tools.

Now, a well-known joke in markets is that the best way to make $1m is to start with $2m — otherwise, your other option is to just chase low-probability, high-payoff scenarios.

Although we aren’t seen-it-all grizzled veterans, we’re not exactly fresh, naive tourists to pursue such a foolish approach.

So, this presents a problem that every prospective fund manager is eventually faced with:

“If we have a solid way of getting reasonable returns with low volatility, how can we source the highest amount of capital at the lowest cost?”

In traditional finance, we can get there a few ways:

• Stocks: If you’re low-capital retail, you’re maxed out at 2x leverage for stocks under Regulation-T margin. Once you can put up a bit more capital, you’re then offered Portfolio Margin, which stretches things a bit further to 6-7x.

  • If you’re an institution (proprietary firm, hedge fund), you would go through what’s known as a prime broker (PB). The leveraged offered by a PB is about the same as portfolio margin but there are more bespoke services offered (e.g., short share locates).

• Bonds: Even at a basic retail level, you can lever up 30x when purchasing treasury bonds. So, within a single day, a $30,000 Charles Schwab account can accumulate a $900,000 treasury bond position:

  • While attractive, no one actually uses this for trading since the margin rate offered by a broker (e.g., 12%) is generally a lot higher than the yield on any treasury (e.g., 4%).

    • Additionally, if you wanted to do something like buying a big bond position before a payment and only accruing 1-day of margin interest, you’d still be paying the “dirty price” of the bond which already factors in accrued interest.

• Futures: Sure, futures definitely serve a real purpose for hedgers, insurers and whatnot, but really though — these are products basically designed for leveraged gambling.

  • If a trader decides to go with a discount futures broker, they may only need to post $500 of collateral for an S&P 500 futures contract (/ES). For reference, the notional value of an ES contract is 50 x index_price, so as of writing, that represents a notional value of ~$285k — effectively a 570x leverage rate.

Now, a hard lesson we learned from our 0-DTE days is that a product itself is not inherently an edge or a strategy — it may have very enticing features, but at the end of the day — it’s just an instrument. Whether or not it’s an effective instrument is entirely dependent on the specific underlying view you’re trying to capture.

So, now that we have a possible idea of how we can lever our capital up, we need to identify appropriate ways to use it.

We know better than to chase volatile, big payoffs, so our desired risk/return profile is bond-like volatility, with equity-like upside. The absolute percent returns might be small, but if we lever it up enough, the absolute dollar values should make it a worthwhile endeavor.

With that goal in mind, we set out to search for which kinds of strategies fit the bill and eventually, we landed on a pod-shop favorite:

Long-Short Relative Value

One of the first hedge fund strategies and ostensibly the most simple — you long one asset and short another — the offsetting PnLs roughly balance each other out for market neutrality.

You go from predicting the outright performance of any 1 asset to instead predicting the relative performance compared to another asset.

The predictions don’t even need to be something complex and proprietary, it can be common-sense stuff like estimating that large caps will fare better than small caps or that Bitcoin will hold its value better than a meme-coin.

Now, like most things — the nuance is where it gets tricky.

To see how, let’s take a look at a reasonable long-short trade:

Starting Theory: The S&P 500 Index will perform better than the Russell 2000 Index.

We’re stepping a bit out of our depth into the equity fundamental world, but it’s a concept that makes sense from a big-picture view — all theoretical academic factors aside; who will fare the best in the future U.S. economy? — the FAANG’s and the Berkshire Hathaway’s — or — the deep south egg-packaging firms and small, single-drug pharmaceutical companies?

Now, again, we’re not making an explicit directional view on “the market” itself, we’re just betting on the relative performance

1. If the market is positive, the S&P may go up 10% and R2K might only go up 3%, that 7% spread is our theoretical profit.

2. If the market is negative, the S&P may go down 10%, but R2K might be down 17%, that 7% spread is our theoretical profit.

Of course, this assumes that both assets remain correlated. If some rogue leader signs a new law that all S&P 500 members will be taxed at a 75% rate, but R2K members get a cut to 5% — the trade is over.

So, it’s not totally riskless, but realistically the correlation is likely to stick since both are driven by the same fundamental macro drivers. It’s a bit less quantitative, a bit less mathematically rigorous, but that can be all it takes to form the basis of a view.

With this being our starting point, we then run a very quick, raw test to see how this portfolio performed historically.

Just with a cursory test of the relationship, we see that even in times of distress (e.g., COVID, Russo-Ukrainian War, 2025 Trade War), the offsetting exposures balance out and the relationship generally holds.

There was a period in late 2020 to early 2021 where small caps outperformed — the consensus on why is that the small cap factor historically tends to outperform large caps immediately after recessions — Small Caps Have Been a Big Story After Recessions.

This gives us pause as, at the time of writing, there are some recessionary fears, so it’s a real risk factor to consider on a forward-looking basis — but we’re just in the experimental stage, so for now, let’s see what else we find.

Now that we have the view, we just need the right instruments. Thankfully, both the S&P 500 and the Russell 2000 have deeply liquid futures products, so all we need to do is use those instruments to systematically execute our view.

Here’s one way we might approach it:

1. At market open each trading day, we buy 1 /ES future and simultaneously short an equivalent-notional amount of /RTY futures.

   1. We profit if the S&P 500 performs better than the Russell 2000 index over the course of that trading day.

2. At market close, we close the position.

3. Repeat.

Now, when doing a deeper simulation of a strategy, it is very important to be as realistic as possible. With that being a motto, here’s some of the few testing constraints:

• Using NBBO (bid/ask) quote values instead of OHLCV values

  • For liquid products, OHLCV is honestly roughly fine enough, but as you get into more niche offerings, having to cross the bid/ask spread can be a night-and-day difference than just assuming you’d have been able to trade at the last price.

• Using a real fee model

  • Assuming costless transactions is another major mistake, so it’s best to take the actual fees your broker charges (it’s always on their website) and simulate using the exact, real costs you’d incur.

So, with those constraints in mind, let’s see how the approach fared:

As demonstrated, the curve of the intraday version is about similar to that of just holding the long/short portfolio indefinitely.

Roughly similar, but it’s evident that the continuous rebalancing and daily accrual of transaction costs act as a draw on returns.

Further, going with an equal-dollar weighted amount introduces a new problem — beta mismatching.

Assuming a rolling 90-day beta of 1.35 for the Russell 2000, we assume that for every 1% the S&P 500 moves, The R2K will move by ~1.35%. Now, over time this is fine as the larger losses add up resulting in eventual R2K underperformance, but on an intraday basis, this means that we often take losses on days where the overall market goes up (e.g., S&P up 0.7% today, R2K up 0.95%), simply because R2K is correlated, but more volatile.

There are ways to beta-weight the portfolio so that the beta is theoretically net 0, but futures are only available in whole units, so we’re always going to be a little under or over exposed to beta.

Now, this can be handled by just expanding the duration of the trades, from intraday to weekly/monthly for instance. However, holding a futures position overnight, even when hedged, requires you to post the full maintenance margin of both products. Yes, even at full maintenance margin, you’re still levered up, but it’s significantly less and represents a legitimate capital constraint.

So, this was definitely an interesting starter experiment and got us into the weeds, but now that we’ve seen the problems, we can start to innovate for solutions.

To do that, we need to look somewhere we haven’t yet.

Crypto Perpetual Futures

We’re not crypto natives, but the inspiration for this idea came from one of the relative value scenarios we pitched earlier:

“The predictions don’t even need to be something complex and proprietary, it can be common-sense stuff like estimating that large caps will fare better than small caps or that Bitcoin will hold its value better than a meme-coin.”

If we’re using a similar logic and considering Bitcoin to be the S&P 500 of crypto — the most widely recognized, widely adopted — what would be the Russell 2000?

Well, it would be Ethereum, a currency that’s just as known, but only as the little brother to Bitcoin.

So, following the process set in the first example, we’ll start out with a cursory test to see what the relationship looked like historically. To execute this view, we would simply just long BTC and short ETH.

It turns out, this has been a pretty interesting trade for the past 5 years:

Read more

From the start, our goal was to learn everything we could about the industry, openly share our successes and failures in public, then once we got better and found that one piece of research — we’d go for it — big.

Before going any further, we wanted to say that if you’re still here — thank you.

We know disappearing without warning wasn’t ideal and we apologize for it.

Just for still reading this, we are deeply grateful and want to make it up to you by coming back 10x harder.

We legitimately put our entire lives on the line for this mission — and now it’s time to show you what came of it.

What’s Coming

Before we announce what’s new, we have to announce what’s staying the same.

From the beginning, we wanted to deliver the kind of novel insights that you could really only know about by being in the proverbial “trenches”. Things you couldn’t get from Wikipedia or ChatGPT, but only from doing your own thinking and actually risking something.

So, we’re getting right back to that.

Just as a teaser, things really accelerated for us when we took a break from the land of niche option stuff and moved into crypto (alright, get your laughs in, we know) — but trust us, this stuff goes deep — managing risk across a network of decentralized exchanges, levering up 50x our initial capital for arbitrage plays, and stuff right from the dream of every quant. If any of that sounds like gibberish, don’t worry, we’ll break it down in just the manner you’re used to.

We’ll be doing deep dives into the exact specifications of our new strategies in the space, so if you’re even remotely interested in options, leverage, or just quantitative trading in general, you’re going to love this.

What’s New

To give you some raw perspective — running a quantitative finance publication is… peculiar.

Dropping fresh, novel quantitative insights every single week sounds great on paper, but in reality, for every post-worthy insight, there are 20 folders full of code experiments that ended up going nowhere — the necessary and natural cost of real research in any field.

We’ll never fake it just to fill space, however, we never want to keep you waiting again. So, we put our best minds together and designed a new content system that’s fresh, consistent, and — most importantly — free of slop.

There’s quite a few ideas in the pipeline, but one we’re particularly excited about is a brand new series where we dive into social media chatter across the major subreddits (e.g., r/quant, r/options), quant-twit, and other pockets of the quant world.

Every week, we'll pick some of the most insightful questions — and even some of the not-so-great ones — and break them down in the spirit of real generosity.

The goal isn't to dunk on amateurs, but rather to genuinely help by showing in-depth, practical experiments.

This is just one of many concepts we’ve cooked up — not everything will stick, but one thing’s for sure: every post you see will be built with care, substance, and an obsession with keeping it insightful, novel, and worth your time.

Closing Thoughts

Before we wrap up, we just want to say: thank you to everyone reading this.

Whether you’re new here or you’ve been following our journey for a while, we’re grateful you're a part of this next chapter.

And for those who stuck around during the quiet months — who stayed even when there weren’t new posts or new announcements — your loyalty means more than we can possibly say.

This comeback is for you.

Let’s do this. 🫡

You see, there’s been some trading — well, kind of a lot of it:

Naturally, from just being out in the field trying things, we learned a lot.

So, today, we’ll be doing a deep dive into what we discovered, some new insights, and a few new strategies that we’re getting ready to launch.

It’s All About The Price, Baby

Although we’re quantitative traders, we briefly lived a past life where we tried to apply the same concepts to sports betting.

To quicky recap, we settled on the conclusion that in sports betting, it’s all about the price. You see, making a net profit from sports betting isn’t about having a good model or understanding the given sport, it’s simply about paying a price that is cheaper than the “fair” price.

Professional bettors essentially just take the fair price from a “sharp” sportsbook like Pinnacle, then search for sportsbooks that provide a deviation from that line. When there’s a sportsbook that’s too far off, you bet big — do that 100 times a day and you’re “guaranteed” a profit.

We expand more on this, along with the results of our own experiment in:

The Quant's Playbook

Relative Value Quant Betting: The OddsJam Edition

Spring. A time of itchy eyes, warmer weather, and the return of chirpings at dawn. But above all, there’s something else starting soon — glorious, magnificent baseball…

Read more

2 years ago · 6 likes · 8 comments · Quant Galore

So, if we can say it all comes down to being a shark — hammering prices when they’re less than fair, can’t that same logic be applied to markets?

To test this idea, we first need a way to convert market prices into implied probabilities. One way of doing this is to use the prices on credit spreads, as explained by the following graphic:

Using the options chain featured above, we can say that at timestamp t, the market implied that there was a 70% probability that the index would be above 5880 at contract expiration — so, 70% represents the “square price” or the fair odds that we should look to improve upon.

Naturally, in similar nature to sports betting odds, this probability will generally end up being accurate. However, also like in sports betting, if odds do anything — they change.

Sometimes, the price of a sports bet at a given sportsbook will change based on things like dollar imbalances (e.g., too much or not enough $ on team A), stale updates, or just general variance. The same applies to markets, where as prices change, so do the odds of a given strike landing out-of-the-money.

To see that in action, take a look at what happened just minutes after the above screenshot was taken:

The index rallied upwards by ~30 points, so the same bet that was trading at odds of 70% (1.50 credit) was now trading at odds of 84% (0.80 credit).

So, if we assume that the odds at time t-1, 70%, were the fair odds, our view is that this current price is “rich”/“wrong”.

In +EV betting theory, this would represent a theoretical 14% edge (implied_odds - market_odds). If the odds at 70% are true and we took this bet 1000 times (buying the spread @ 0.80 until it gets back to 1.50), we would theoretically be guaranteed a profit.

Now, of course, knowing which price is the fair one is tricky — just a few minutes after the above screenshot, the odds changed again to 88%.

One simple way is to create a model that just uses the price at time t, say, 9:35 EST, as the true one. Remember, a model is just that — a way of modeling a theory —sometimes it’ll be wrong, but on average it should generally perform okay.

If put into a strategy, we would take all option prices at 9:35 that day and treat it as gospel. So, if at 9:35 the market implied there was an 80% chance for SPX to close above 6000, but a few hours later that probability changed to 25%, we would take that bet.

To quickly test that idea, we can use a modified version of our core SPX strategy:

• Core SPX Strategy: We use the value of the VIX1D index at 9:35 EST, paired with the present market regime to determine the optimal SPX spread to sell that day.

The historical win rate of the strategy is ~80%, so every price at better odds than that (spread price >= 1.05) offers us a theoretical edge. Let’s take a quick look at how the performance differed if instead of trading at the first available price, we only traded with implied odds of 70% (spread price = 1.5).

First, the baseline performance (trading at the first available price after the signal is generated):

Now, with optimized odds:

As you may have noticed, our base strategy experienced a bit of difficulty recently as the market flattened out and got more volatile (we’ll get to that in a sec), but nevertheless, the version with a 10% odds improvement absolutely dogs the un-optimized version.

Now, of course, there’s no free lunches and getting this optimized price can be a bit tricky.

In a study of a smaller time series, the price of this spread reached $1.5 only ~65% of the time and of that 65%, it ended up actually paying off ~73% of the time. So, when the market implied probability changes, it does end up actually decreasing the probability of the event realizing, but not in a drastic enough way to make the optimization unprofitable.

Nevertheless, if these bets at advantageous prices are peppered into our trades, we can systematically increase and ensure our edge.

Making sure that we actually get filled on those prices though is a fun exercise in algorithmic order execution:

Brain Teaser: An Order Execution Puzzle

Scenario: Everyday, the market will offer you $1.00 for something that has an 80% chance of paying off. If it’s wrong, you’ll lose $4.00. You’re smart, so you know that you need a price of at least $1.05 to come out ahead in the long-run. You also know that sometimes, the price gets as high as 1.50, which would cement your edge even further.

Problem: You don’t know what the best price of the day will be, sometimes it’ll be exactly $1.05, sometimes it might even be $4. How do you balance getting filled daily with making sure you’re also exposed to the best prices if/when they arise?

A sample solution is as follows:

1. Your fair probability is 80%, so you start off with a base limit order of $1.05 or the mid price if it’s higher:

   1. np.maximum(1.05, mkt_price)

2. You monitor prices within the first 2 hours and wait for the price of the spread to get to 1.50 (70% prob).

   1. If it doesn’t happen, you collect the full base credit anyway and move onto the next trading day.

   2. If it does, you sell more contracts up to the desired risk limit of the day.

   3. You only wait for 2 hours, since if the prob drastically changes in say, the last 10 minutes of trading, then it’s likely a legitimate bad bet at that point.

As the sample size grows, this process will increase the average trade price and prove to be more efficient than just taking the first available price.

Now, while getting an improvement on price is the most surefire way to profits, it won’t totally save a bad strategy.

To see this, let’s take another sample strategy: selling 1-DTE iron condors using the VIX1D value near close.

For this strategy, if we wait until say, 5 minutes before close, that gives us very little room for price improvement. So, rather, we can take the VIX1D value at 2:00 (2 hours before close) and use that as the baseline “true” value. That gives us 2 hours to let prices fluctuate, giving us the best chance to get a fill at an advantageous price.

So, here’s our sample strategy:

1. At 2:00 PM EST, we use the VIX1D to get the implied move for the next day.

2. Based on the implied move, we sell an iron condor directly outside of that range.

   1. We make a profit if the next day’s realized move is less than what the market implied (e.g., market implied prices to move 0.9%, but it only ended up moving 0.5%)

3. Since the prices at 2:00 are our “fair” odds, we use that as the baseline for improvement. So, for the remaining 2 hours we wait for a 10% improvement in price (e.g., “fair” price at 2 = 1.00 | 10% improved price = 1.10).

   1. If the price doesn’t ever reach that amount, the order doesn’t get executed and we don’t take a trade.

      1. We do a 10% improvement in spread price since a 10% difference in implied probability would be too infrequent at strikes this far OTM.

Let’s see how that compared to if we just traded outright every time:

When starting from 2 PM, the price ended up improving by 10% about 90% of the time. However, because pure short vol strategies like this tend to lose in clusters, even getting a 10% improvement doesn’t save the strategy.

So, if you have a strategy that makes money, figuring out the odds (e.g., historical win rate) and delaying execution for price optimization can make you a whole lot more, but the prerequisite is that the strategy is viable in the first place.

Now, with that covered, let’s move onto another matter of business.

Current + New Strategy Updates

At The Quant’s Playbook, we’ve been running 2 quantitative strategies in production.

To quickly recap, we have a strategy that uses a short-term prediction model to predict the next day direction of TSLA’s stock. Based on that prediction, we buy a call or put at near market close and sell it at market open the next day.

Because TSLA routinely experiences volatile moves that outpace implied volatility, its options provide greatly asymmetric returns which allow us to have a positive expected value even if we just go 50/50.

Put simply, this strategy, has been making us rich — month after month:

If you’re already a paid subscriber, truly — thank you. ❤️ Your support powers better data, better tools, and better research.

If you’ve been enjoying the work and want to support what we’re building, consider becoming a paid subscriber. It means more than you think and helps us keep doing it right. 🫡

Read more

For that reason, trend following is one of, if not the most, dominant set of strategies used in commodities and futures trading. However, it’s kind of a black box.

Yeah, we know that, at core; a long signal is generated by some moving average crossover, then the trade is exited when that signal goes away. Do this across a portfolio of 20 different commodities rebalanced monthly and you get performance like this:

But what exactly does that mean? What are the optimal historical periods for the averages? What methods are there for testing whether a trend is actually a trend or just a spurious movement? How do you know if your chosen moving average period isn’t just overfit to that commodity and will work in others and/or in the future?

These are serious questions that need serious answers, so if we’re going to take a stab at this, we’ll want a more systematic and reliable way of detecting trends.

Naturally, we can train a machine learning model to do exactly that.

This way, we can have the control and precision of only taking trades when our model gives the go ahead and taking action off the table when our model says to pull back. In theory, this should provide more stability than a traditional rules-based approach.

However, there’s a slight problem.

Traditionally, we would train the model on the historical data of the respective asset and use that to predict what might happen.

Our goal is to run this across a wide variety of commodity products which all behave differently — a trend in copper futures might look very different than a trend in, say, orange juice futures.

Just take a look at a comparison of the two’s time series:

We could, in theory, just train a model for each individual futures product, but this adds significant complexity and leaves us prone to overfitting to historical periods.

So, if we want to build a model that works well across multiple assets, we’ll have to think outside the box and try something new.

The Synthetic Data Edge

When we model something, we’re essentially saying, “Okay, here’s what the relationship between prices looked like in the past, try to see if you can spot those relationships repeating in this out of sample data.”

So, what if – now, just hear us out.

What if we just created the ideal dataset, trained our model on those ideal relationships, and then let it spot them in out of sample data?

That might sound a bit confusing, so let’s break that down:

Our mission is to detect when an asset is trending and when that trend is over.

We can manually create a dataset where we explicitly design it such that when feature_1 is above 0, the is_trend target will be a 1 — if it’s below 0, the is_trend target is set to a 0.

Once the model is trained on that “fake” dataset, we let it predict on out of sample data. If, for instance, the feature_1 for natural gas on 01/01/2025 is above 0, the model will output a 1, indicating an active trend.

So, we’re essentially saying: “In a perfect world, a trend will look like this. Go out and see if you can spot that in this new dataset”.

Doing this comes with a few potential advantages:

• We greatly, if not totally, reduce the risk of overfitting.

  • In this case, we mean overfitting as in: “the model is very good at predicting natural gas trends when it uses data specifically from March 2019 to February 2021.”

    • Since the data isn’t even “real”, we’ll get a fairer, absolute sense of how strong our features are as opposed to how well they performed over specific periods using data from other specific periods.

• We can test over substantially longer periods across significantly more assets

  • Since we no longer have to worry about training on say, 252 days of historical data, we can get point-in-time predictions by just passing in the features of that day.

    • Just seeing the performance on an extra 252 days (1 full market year) goes a long way in evaluating the efficacy of our approach.

So, let’s give it a shot.

To begin, we’ll first create our features.

We know that at the core of trend following is a moving average, so we want a measure of how far the current price has diverged from its historical average. For instance, if Live Cattle Futures are suddenly 10% higher than its 1-month average price, it might be the harbinger of a trend.

So, that divergence will be our first feature.

Now, we don’t want too many false flags, so we want to also compare today’s divergence to yesterday’s — if yesterday there was a +5% divergence, and today there’s only a +2% divergence, we want the model to know that this is likely not indicative of a booming trend.

So, we create another feature which is just the lagged divergence.

Finally, there’s a “little” known market phenomena that might give us a bit of juice:

The 52-Week High Effect

This effect essentially states that the closeness of a stock to its 52-week high leads to predictably higher returns in the short-term. The rationale for this roots largely from behavioral finance:

• Anchoring Bias: Investors often use the 52-week high as an “anchor”, a reference point for judging a stock's future potential. When prices approach and/or surpass this level, investors may interpret it as a signal of strength, pushing prices even higher as more buyers jump in.

• Herding Behavior: When a stock reaches a 52-week high, it garners attention, leading other investors to follow the trend, assuming that the market has positive information about the stock.

• Confirmation Bias: Investors who already own the stock may use this recent high as a confirmation of their original conviction/thesis and buy more shares.

• Loss Aversion: The 52-week high serves as a psychological barrier. Investors who were hesitant to sell before may sell less when prices exceed this point, as they want to avoid missing out on potential gains. This reduced selling pressure contributes to continued price appreciation.

Here’s a few papers on the subject:

• The 52-Week High and Momentum Investing

• Industry information and the 52-week high effect

Now, applying this to commodities is a bit tricky since sometimes a 52-week high won’t repeat — for instance, if in 2020, green lumber futures reached a high of $1,000 because of a major forest fire, that would be a poor reference point to use on a forward basis.

So, we can go with something a bit shorter, like the distance from the 3-month high. We’ll also add the lagged distance like we did for our first features (how far from the high it was yesterday).

Once we’ve conceptualized the features we’ll use, we can then build the dataset.

Now, we’re sure that there’s a sophisticated, Pythonic way to create a dataset like this, but after an hour of frustratingly fiddling around with numpy, we just ended up building it by hand in Excel — looks like there’s still some value in the old-fashioned ways after all.

Here’s what this dataset looks like:

An eye sore? Yes, but as demonstrated, when the price is getting closer to setting a new high and its divergence from the average is increasing, we let the model know: “this is what a trend looks like” (trend = 1).

Considering that the relationship is so clearly defined, we really only need 25 rows to act as the training set. Since it’s a small, simple dataset we'll go with a logistic regression model.

Can This Thing Actually Work?

To test if this will work, we’ll run our typical walk-forward testing.

So, each trading day, we’ll pass to our model just the data available that day — notably, the % divergence from the average price (1-month), the % distance from the prior high (3-month high), and the lagged values of each.

If our model predicts a 1, it is essentially saying to us: “this is a trend.”; for a 0, “this is not a trend.” We are only passing in 1 day at a time, so each prediction is what we would’ve actually seen on that given day.

So, let’s see how it did:

Read more

Sure, you also have to deal with data preparation, risk management and the million other things, but at the end of the day — you have to make a prediction.

As modern-century humans, we’ve pretty much perfected the art of prediction — heart attack risk, likelihood of loan defaults, text that accurately responds to given prompts — perfected it everywhere — except in Finance.

• Take a look at this new study where even traders who were given inside information in advanced struggled to break 50/50 — ‘Crystal Ball’ Breaks as Traders Fail to Get Rich in New Study

Most market participants have resigned to the idea that it all comes down to a coin-flip, but of course, quantitative investing wouldn’t be a multi-billion dollar industry if that were the case.

So, today, we’ll be doing a deep dive into the nuts and bolts of actionable, quantitative predictions, allowing you to see that it’s a much bigger game than just predicting a 50/50 up or down.

Once Upon a Time, There Was a Regression Model

We want to start simple, so we’ll start with the simplest form of model — regression.

Regression models are simple — lower/higher values of X, our input, leads to lower/higher values of Y, our output — easy.

While these are the “trust me bro, the final value will be somewhere around this general area, probably, more likely than not…” of models, that’s not a bug, it’s a feature.

To see why, let’s quickly scrap together a regression model that we can use to predict SPX returns.

But first, we must address the most crucial core concept in predictive modeling:

Garbage In, Garbage Out.

• Models are only as good as the underlying data we give it, so it’s crucial to make sure that our features (inputs) have solid fundamental sense.

So, on that thread, think about what kinds of things have reasonable reasons for why they’d be good at predicting our target — in this case, S&P 500 returns.

• Seriously, think for a second about what things might be drivers of future returns. For each variable you think of, try to iron out the rationale of why it makes sense.

One option is the VIX index:

• The VIX is largely derived from how expensive out-of-the-money options on SPX get

  • If investors are paying more for protection, it’s likely because something bad has happened, is happening, or will happen.

  • If investors are paying significantly less for protection, it’s a sign that the bad times are over, or at least perceptions of the bad times are easing.

If we want to model that simple relationship — higher expectations in vol = lower expectations of future SPX returns — a linear model would be perfect.

So, to start, we’ll create just 2 features from the VIX index, the 1-day return and the daily value of the index.

• The 1-day return represents how much the VIX went up that_day

• The daily value represents the value of the VIX that_day

• that_day is defined as the given date

Our target will be the return of the S&P 500 the next day.

Now, returns are not normally distributed and we might screw with our model’s head if the VIX reaches 100 but the actual next day return is only -0.03%, so we’ll convert this into a binary classification task.

So, if the next day’s return was positive, we convert that value into a 1, if it was negative (or flat), we convert it into a 0.

Here’s a look at what this data will look like:

As you can visually inspect in this snippet, when the VIX goes up (daily return > 0), the next day return tends to be negative (0) — when it goes down (daily return < 0), the next day return tends to be positive (1).

Once we have our dataset, we’ll deploy walk-forward testing:

• This is essentially going forward 1 day at a time, training the model on data only available on/before that day, then passing in that day’s data to get a prediction for the next.

  • As to the ideal training size for each day, we personally prefer 252 prior samples, with a max of 504.

    • There are 252 trading days per year, so 252 ensures your data has enough samples to establish relationships, while still being relevant enough to predict contemporary data. You don’t want to use data from 2013 to predict a 2024 outcome just because you’ll have more data points.

• This helps us get a better idea of how our model would’ve performed in real-life since it is the format we would actually deploy in production.

  • Compared to other sciences’ methods of say, cross-fold validation, we won’t be predicting hundreds of values at once, especially since each value is a future point in time — we would only have the data before today and we would pass in just today’s data for tomorrow’s prediction.

    • We’re not ruling out using cross-fold validation as it can still be effective in deducing model skill, but walk-forward testing keeps things as realistic as possible.

After running the model, we’ll run a few performance metrics to see how well it was able to capture this relationship.

So, let’s see how it did:

If you’re already a paid subscriber, truly — thank you. ❤️ Your support powers better data, better tools, and better research.

If you’ve been enjoying the work and want to support what we’re building, consider becoming a paid subscriber. It means more than you think and helps us keep doing it right. 🫡

Read more