The Trades We Had to Sign NDAs to See
When your own customers make you sign an NDA, you start asking what they know that you don't. We spent months writing down the answer.
Not long ago, one of our customers asked us to sign an NDA before they’d show us what they were doing with our data.
The conversation started the way these things usually do: a higher request limit, an extra field in one of the feeds, a private endpoint, etc.
To explain why they needed it, though, they’d have to show us a piece of what they’d built. And evidently, the work layered on top of our data was valuable enough to need paperwork before we were allowed to even look.
In industry, this process is typically reversed: the vendor makes the client promise not to leak the data, but here, a client was protecting their work from us.
That conversation wasn’t the only one, either.
Rewinding a few months; we launched Alphanume, a research platform built on proprietary second-layer datasets: data designed to be used directly in trading, with the proof published up front.
In the months since, a cohort of power users has emerged. They pull the same endpoints as every other subscriber, and some of what they’ve built on top is genuinely impressive.
This left us chewing on a question:
“What do those users know that everyone else, with the exact same data, doesn’t?”
The answer turned out to be worth building a whole second platform for.
Two Camps, Same Ditch
From our conversations, we found the difference was that power users had substantially more domain knowledge. Deep, specific, unglamorous knowledge about how filings work, how volatility is quoted, how a borrow actually gets located, and so on.
Naturally, seeing the value (i.e., profit potential) sitting inside second-layer data requires that knowledge.
A dataset can tell you a company just filed to dilute its shares; whether that filing is a death sentence or routine housekeeping is a domain question, and the data can’t answer it for you.
So, where does someone even get that knowledge?
If you’re self-taught (and a large share of you reading this are, impressively), you already know the honest answer: everywhere and nowhere.
The typical trail looks something like:
A folder of half-finished backtest notebooks, with a
backtest_v3_FINAL.ipynbthat stops at cell 41.One indicator strategy that made money for four months and then stopped, and you never found out why.
A Coursera course, abandoned somewhere around week four, that still emails you.
The field then splits people into two camps.
One camp grinds theory forever, reads every paper, but never places a trade. The other goes live within a week on an RSI crossover and donates a few thousand dollars to the market’s tuition fund.
Both camps are missing the same ingredient: sequence.
On a trading desk, the knowledge arrives in order.
A junior sits next to someone who has seen ten of these before, and the apprenticeship transmits tooling first, then theory, then the trade, and lastly the nuance that keeps the trade alive. Nobody hands a first-year the exotic book on day two.
Self-taught, you get the same material, shuffled. The pieces are all out there, but the order is the thing nobody publishes.
So, We Wrote It Down
Today, we’re launching Alphanume Learn (learn.alphanume.com): an interactive research apprenticeship we bolted directly onto the data platform.
The first curriculum is Systematic Trading with Market Data: 12 modules and 65 lessons covering the full research process in the order a desk would teach it:
Every lesson runs real Python in your browser, against the same live Alphanume endpoints the power users hit, and the exercises grade themselves.
The browser part matters, as you start immediately, with zero setup. The early modules then show you how to build a proper tech stack locally, so the tooling outlives the course.
Reading about research and actually doing research are two completely different things, so we removed the reading-only option and every module ends with a knowledge check.
By the end, you take a market observation to a point-in-time dataset, then to a defensible backtest, then to an automated screen, with every step reusing the stack you built for the last one.
Module 1 is free, and the homepage has a runnable demo of the earnings study that requires no account at all.
Run the free earnings experiment →
Tooling First, Alpha Later
Now, “domain knowledge” here might sound a bit vague. So to get a more useful read on what that means, let’s walk through it.
First, we start with tooling that lasts:
A reproducible Python environment.
A SQL research database.
Git used as a research journal.
One API-ingestion skeleton that every later module reuses.
Maybe boring at first, but every impressive thing our power users do sits on top of plumbing exactly like this.
Then comes the theory of events that actually move markets. Earnings, filings, expirations: the moments where information forcibly enters the price, and the moments where it only pretends to.
Then you trade them, and this is where conditioning earns its keep. Take short volatility around earnings and run it across the full history on the platform, through three progressively stricter gates:
Sell every 30-day straddle indiscriminately, and you capture roughly nothing.
Restrict yourself to names where implied is rich against realized, and the trade wakes up.
Require the vol to also be stretched against its own history, and it changes character entirely (chart below).
Same data, three traders, but three completely different businesses.
Better yet, this research process compounds. The earnings module shows that some individual names overprice their expected earnings move nearly every quarter, and those track records are queryable name by name, point-in-time.
Once you know track records like that exist, you stop asking “does selling earnings vol work?” and start asking “in which names does it work?”
The Deep End
The back half of the curriculum is where the domain knowledge gets specific:
The index game: a model on the platform publishes exactly two integers at 10:30 AM ET, a lower and an upper SPX strike, never revised after publication. An entire module lives inside those two numbers: condors, butterflies, and verticals built on the band, health checks like rolling containment, and regime gates that tell you when to sit out.
Dilution, end to end: the last-ditch financing ladder, the S-1 to EFFECT mechanics (registration reprices the threat; effectiveness makes the selling legal), and the detail that saves you from the classic beginner mistake: not every S-1 is dilutive, and a human-reviewed flag separates the ones that matter.
Short selling, the way a desk would teach it: locates, recalls that end the trade whether you like it or not, and the dividend liabilities that nobody warns you about.
Automation: daily screens land in your inbox before the open, and Claude gets wired in as a junior analyst, while a separate adversarial session reviews the code for look-ahead.
Finally, a capstone: your own event study, end to end, defended. The grade rewards how well you know what you claim.
Nothing in the sequence promises you a permanent edge, and we’d distrust anything that did. Finish it and you’ll be substantially harder to fool, including by your own backtests, and everything else builds on that.
Now, the part you’re actually wondering about.
Who this is for: the person who knows enough Python to run a backtest, has run a few, and still feels like every new idea starts from zero.
And what it isn’t: a Python-from-zero course, a signal feed, or a list of trades to copy. The strategies inside are worked examples; the course is the research process that produced them.
If you’re an Alphanume Pro subscriber, or one of the Founding Researchers who took a lifetime seat at launch, the full course is included with what you already have. Sign in at learn.alphanume.com whenever you like.
If you’re new, Alphanume Pro is $99/month, and Learn comes bundled in: every module with the interactive code experiments, plus full historical and real-time access to the data platform and every model and tool on it.
Final Thoughts
This whole thing started as one person, unreasonably obsessed with systematic trading, writing up experiments for a small newsletter.
Eventually, it became a community of readers running the experiments themselves. Then a data platform once it became clear the most important part was infrastructure.
And now, with Learn, the piece we could never quite ship before: the knowledge itself.
Watching subscribers take datasets we built and push them somewhere we didn’t expect (occasionally somewhere we’re contractually forbidden from describing) has been the single most rewarding part of running this publication.
To everyone who supported this from the early newsletter days through the platform launch: thank you, genuinely. None of it gets built without you.
And to the next cohort of power users, the ones currently sitting on a folder of half-finished notebooks: the sequence is written down now. We’d love to see what you do with it.
As always, thank you for reading, and we’ll see you in the next one. 🫡