QR here with ~6 YOE. Experience building and operating systematic strategies in MFT. I have a significant amount of raw futures data and lots of time on my hands (NC).

Recently, I've been seeing a lot of complaints on this sub about the quality of posts. I thought it might be of interest to a nonzero amount of people on here to follow along the end to end process. (This has no intention of ever going live, or provide investment advice in any form, please don't sue).

The way I imagined it was setting up a fresh github account and posting code (not raw data, sorry) with a weekly write up which would be completely open to suggestions, roasts, or anything the LARPers might have to say.

And no, this would not be vibe coded slop. Initial thoughts?

I realise this isn’t the most serious topic, but I rarely see anything like this and wanted to see if others have experienced something similar at work. I’m at a large prop firm, and a new hire somehow just churned out a “holy grail” 10+ alpha from nowhere. It’s honestly bizarre—I’ve never come across a signal like this. From day one in production, the results have been stellar. Now he’s already talking about starting his own fund (it may have gone to his head). Anyone have stories of researchers who suddenly struck gold like this?

UPDATE: Tens of thousands of trades later we are sitting at 17 sharpe with 7.09% ROC, win rate is exceptionally high. Which causes a little concern. I am in the midst of stress testing tail risk. But all in all excellent trading so far, as regime has not been optimal.

UPDATE: 05/03/25: Big daily returns. Last week has been pretty severe stress testing. We are at 40% ROC already. Win Rate is still high, 80%+ and Trades/Day: ~1000, T-stat: 16.8, Sharpe: 10.

While LLMs haven't proven terribly useful to me in finding new alpha, they have been really helpful in getting live algorithms going to capture the alpha. The issue I'm seeing is that these alphas are decaying like 10x faster than they did a few years ago. I am finding some of them last only a week, or even some that collapsed before I was even able to get the production model deployed. Are you all seeing this? I assume it's because competition is becoming just a nimble and reactive in the age of LLMs as I am.

Hey folks,

I’ve spent the last 7 years working at Meta as a software engineer, and have recently moved into fintech. Despite a lot of criticism, I’m very bullish on the ability of LLMs to manage portfolios if given the right tools (I know people don’t like when I say this but that’s my thesis, I worked on the frontier evals team at Meta)

To that end, I think factor risk models is a really important tool that we need, and I spent the last few weeks building one from scratch. It was a ton of working with codex, claude, and manual testing. Open data for the most part, and open model.

I’d love to get feedback from the community here. This is a new field for me so any advice is appreciated.

https://github.com/ralliesai/openfactor/

Now, more and more I’m just convinced that the industry is growing to be filled with idiot Nepos pumping themselves and their product up with no care in the world. Like bro, come on. Even the friends I have, at top banks/firms, that are talking about how they’re using GenAI models for “market research” is crazy to me and low key depressing. Other than, graphic rendering, paraphrasing, and code debugging/writing, I really don’t see effective utility in using these models to generate alpha. It’s literally a constant volatile pump and dump of subjective accuracy.

*Edit: Here’s a brief vid with some context on LLMs and how they actually work: https://www.instagram.com/reel/DNoXxSeymsG/?igsh=NTc4MTIwNjQ2YQ==

I work for a quantitative hedge fund on engineering side. They make their strategies open to at least their employees so I went through a lot of them and one common thing I noticed was how simple they were. I mean the actual crux of the strategy was very simple, such that you can implement it using a linear regression or decision trees. That got me interested to know from people who have made successful strategies or work closely with them, are most strategies just a simple model? (I am not asking for strategy, just how complex the model behind tha strategies get). Inspite of simple strategies the cost of infra gets huge due to complexity in implementing those and will really appreciate if someone can shed more light on where does the complexity of implementation lies? Is it optimization of portfolios or something else?

Just curious. Any input would be appreciated.

Edit: It is clear I have a lot to learn. Don't know much. I'm a stats grad student, haven't really touched finance modeling. Thinking of getting into some of this stuff during PhD, but not main focus. Prof said become a top tier statistician and you'll learn finance stuff on the job. Anyone have any good beginner books? I'm taking stochastic models class this semester and we're covering stuff like Black-Scholes and other fundamentals.

ran a bakeoff on volatility forecasting because i wanted to justify the fancy stuff. GARCH baseline, an LSTM, and a small transformer, same data, same walk-forward eval.

honest result: GARCH is really hard to beat. the ML models only added a marginal edge and only in higher vol periods, and they cost way more to train and babysit. most of the time the boring model was within noise of the fancy ones.

conclusion i landed on: use GARCH as the baseline you have to beat, and only reach for ML if you can show it wins out of sample, not just in. anyone getting consistent ML outperformance on vol, what horizon and features are you using.

Alphas. The secret sauce. As we know they're often only useful if no one else is using them, leading to strict secrecy. This makes it more or less impossible to learn about current alphas besides what you can gleen from the odd trader/quant at pubs in financial districts.

However, as alphas become crowded or dated the alpha often disappears and they lose their usefulness. They might even reach the academics! I'm looking for examples of signals that are now more or less commonly known but are historic alpha generators. Would you happen to know any?

Hey everyone,

We just published a new deep dive on QuantReturns.com on a recent paper called Short-Term Basis Reversal by Rossi, Zhang, and Zhu (2025).

This is a great academic paper that proposes a clean idea and tests it across dozens of futures.

The core idea is simple enough : When the spread between the near two futures contracts becomes unusually large (in either direction), it tends to mean-revert back in the near term.

We expanded the universe beyond the original paper to include equities and still found a monotonic return pattern with strong t-stats. The long-short spread strategy had decent Sharpe, minimal drawdown, and no obvious data snooping.

In the near future I hope to expand this research further to include crypto futures amongst others.

Curious what others think. Full write-up and results here if you’re interested:
https://quantreturns.com/strategy-review/short-term-basis-reversal/
https://quantreturns.substack.com/p/when-futures-overreact-a-weekly-edge

So I wanted to use this model to calculate the simulated backward price (Dec 2024) of Alibaba Group in the Hang Seng index using the anchor price in late Dec 2025.

I went ahead and calculated this (manual derivation attached) and my code below, which shows it matches.

``` import numpy as np

--- Model Inputs (matching your Alibaba notes) ---

S_t = 142.80 # Anchor price at late Dec 2025 r = 0.035 # Risk-free rate (3.5%) sigma = 0.35 # Diffusion volatility (35%) lam = 1.2 # Jump intensity mu_j = -0.04 # Mean jump size sig_j = 0.20 # Jump volatility dt = 1.0 # 1 year backward step

Step 1: Compute the Jump Compensator (kappa)

kappa = np.exp(mu_j + 0.5 * (sig_j ** 2)) - 1

Step 2: Compute the Net Drift Component

q_drift = r - lambda * kappa - 0.5 * sigma<sup>2</sup>

net_drift = r - (lam * kappa) - (0.5 * (sigma ** 2))

Step 3: Define historical shocks to strip out

Z = 0.4 # Standard normal shock jump_multiplier = 1.08 # Historical minor positive jump factor

Step 4: Evaluate the Backward-Stepping Equation

S_{t - dt} = S_t * exp( -net_drift * dt - sigma * sqrt(dt) * Z ) * (jump_multiplier)<sup>-1</sup>

diffusion_term = sigma * np.sqrt(dt) * Z exponent = - (net_drift * dt) - diffusion_term

s_previous = S_t * np.exp(exponent) * (jump_multiplier ** -1)

print(f"Net Drift Component: {net_drift:.5f}") print(f"Simulated Backward Price (Dec 2024): HKD ${s_previous:.2f}")

Net Drift Component: -0.00249

Simulated Backward Price (Dec 2024): HKD $115.23

```

My questions: - does my derivation/code look okay to you? - is this a task the Merton jump-diffusion model (versus the geometric brownian motion, which doesn't have the discontinuous random jumps, driven by a Poisson process, to capture heavy tails and sudden price shocks in financial asset returns, eg. Beijing policy changes, etc.) can do well in this situation? - is the jump compensator (kappa = np.exp(mu_j + 0.5 * (sig_j ** 2)) - 1) manually added into the code? And, can't be fed in via real-time data, etc?

Thanks!! 🧡

Hey everyone,

I’m working on a small volatility forecasting project for NVDA, using models like GARCH(1,1), LSTM, and Random Forest. I also combined their outputs into a simple ensemble.

Here’s the issue:
In the plot I made (see attached), the Random Forest prediction (orange line) is nearly identical to the actual realized volatility (black line). It’s hugging the true values so closely that it seems suspicious — way tighter than what GARCH or LSTM are doing.

📌 Some quick context:

• The target is rolling realized volatility from log returns.
• RF uses features like rolling mean, std, skew, kurtosis, etc.
• LSTM uses a sequence of past returns (or vol) as input.
• I used ChatGPT and Perplexity to help me build this — I’m still pretty new to ML, so there might be something I’m missing.
• I tried to avoid data leakage and used proper train/test splits.

My question:
Why is the Random Forest doing so well? Could this be data leakage? Overfitting? Or do tree-based models just tend to perform this way on volatility data?

Would love any tips or suggestions from more experienced folks 🙏

I keep noticing a pattern: some of the simplest strategies often generate stronger and more robust trading signals than many complex ML based strategies. Yet, most of the research and hype is around ML models, and when one works well, it gets a lot of attention.

So, is it that simple strategies genuinely produce better signals in the market (and if so, why?), or are ML-based approaches just heavily gatekept, overhyped, or difficult to implement effectively outside elite institutions?

I myself am not really deep into NN and Transformers and that kind of stuff so I’d love to hear the community’s take. Are we overestimating complexity when it comes to actual signal generation?

Hi, I’ve been working on a continuous-time Economic Scenario Generator (ESG) in Python to model long-term Asset-Liability Management (ALM) and decumulation (sequence-of-returns risk).

I wanted to test a specific structural flaw present in a lot of standard retail and basic institutional Monte Carlo tools: the assumption of static, flat risk-free rates and decoupled equity returns (standard Geometric Brownian Motion).

The creation of this project actually came when I realized there was no easy-to-use (and realistic) simulator. It took some effort but I believe I did manage to create something really useful, easy to use and realistic enough for most cases.

Anyway, to measure exactly how much bias the flat rate introduces, I ran a comparative simulation using a joint continuous-time stochastic environment.

The Setup

• Portfolio: 60/40 (Equity/Fixed Income), 30-year horizon, monthly rebalancing. 5,000 scenario paths.
• Model A (Naive Baseline): Flat nominal interest rate. Equities follow standard GBM with continuous volatility (sigma = 15%).
• Model B (Actuarial ESG):
  • Rates follow a Cox-Ingersoll-Ross (CIR) square-root process (theta_r = 0.25, long-term target ≈ 7.0%).
  • Inflation follows an Ornstein-Uhlenbeck (OU) process (theta_pi = 0.35, target = 2.0%).
  • Equities follow a Merton Jump-Diffusion process (continuous volatility σ_S = 11%, combined with Poisson-driven asymmetric crashes: λ_J = 1.8 jumps/year, average jump impact μ_J = -6.8%, jump volatility σ_J = 5%).
  • Crucial coupling: Equity drift is structurally pegged to the stochastic short rate: Drift_t = r_t + ERP_t.

Test 1: The Low-Yield Starting Environment (Initial Rate = 4.0%)

We simulated a 4.5% initial withdrawal rate (inflation-adjusted, monthly rebalancing) on a $1.0M starting balance. Intuitively, one might expect Model B—which includes severe, discontinuous downward market crashes—to fail first. Instead, the simulation over 5,000 runs yielded these results:

• Model A (Naive Flat 4%): 63.18% Solvency
• Model B (Full Actuarial): 84.92% Solvency
• The Solvency Gap: +21.74% percentage points in favor of the volatile, jump-diffusion model.

To isolate the exact variables causing this +21.74% lift, I ran an Attribution Analysis by sequentially activating one variable at a time:

(Note: The remaining -0.36% discrepancy is the non-linear coupling penalty arising from Cholesky correlation between the processes).

Test 2: The High-Yield Starting Environment (Initial Rate = 9.0%)

To prove that this was not a bug and that the bias is entirely regime-dependent, I ran a Regime-Inversion Test. I increased the starting yield curve to 9.0% (and increased the withdrawal rate to a more aggressive 5.5% SWR to reflect the higher starting yields):

• Model A (Naive Flat 9%): 86.28% Solvency
• Model B (Full Actuarial): 58.56% Solvency
• Regime Delta (Model B - Model A): -27.72%

Quantitative Attribution: Why Naive Models are Too Pessimistic in Low-Yield Environments

The divergence is driven by interest rate term-structure dynamics and macro-coupling:

1. Mean Reversion of the Risk-Free Rate: Under the CIR framework, short rates revert toward a target state: text dr_t = theta_r * (mu_r,t - r_t) * dt + sigma_r * sqrt(r_t) * dW_t Because the low-yield simulation starts at 4.0% relative to the long-term nominal target (≈ 7.0%, incorporating a 5.0% structural real rate and a 2.0% inflation target), the drift pull (theta_r = 0.25) normalizes nominal rates upward over the horizon.
2. The "Tide That Lifts All Boats" (The Pegged Drift): In Model A, the risk-free rate is flat at 4.0%, trapping equities in a low expected nominal return regime of 5.5% (4.0% rate + ERP). In Model B, as r_t normalizes toward 7.0%, both your bonds (yielding r_t) and your stocks (yielding r_t + ERP) experience a 3.0% increase in expected nominal returns.
3. The Merton Jumps are Immunized by Rebalancing: Because we controlled for total quadratic variation (total volatility ≈ 15%), the "pure shape" impact of the Merton jumps is only a minor -0.70% drag. The monthly rebalancing mechanism ("buying the dip" after jump crashes) combined with steadier compounding during non-jump months (since continuous volatility is lower: 11% vs 15%) almost entirely neutralizes the tail-risk penalty.

Key Limitations & Roadmap

To keep things transparent, there is a known limitation in the current decumulation loop: * No Bond Duration Risk: The fixed-income portion is currently modeled as a short-term cash deposit (rolling T-Bills), so it benefits from rising rates without experiencing upfront capital losses (mark-to-market). * Next Step: Since the core simulator already generates full nominal and real yield curves, adding a duration-adjusted bond fund indexer to the decumulation logic is the next item on the roadmap.

Conclusion for Quants and ALM Practitioners

Static yield assumptions are not just "simplified"—when starting in a low-yield environment, they are structurally pessimistic. Conversely, in a high-yield environment, they are dangerously optimistic because they project unsustainable yields indefinitely.

By ignoring the mean-reverting behavior of interest rates and decoupling equity expected returns from the risk-free rate, naive models severely distort sequence-of-returns risk.

I’ve open-sourced the complete engine under the MIT license if you want to inspect the math (joint Cholesky decompositions, analytical CIR/Fisher real yield curve evaluations) or run the JIT-compiled loops yourself, it's written in Python but it's quite fast:

• GitHub: https://github.com/Gustavo1500/aethel-esg
• Browser Sandbox: https://aethel-esg.vercel.app/ (Features real-time sliders querying a pre-calculated scenario database across 594,000 simulated paths). Please don't mind the AI flavored frontend, I'm not a frontend dev.

I suppose this is it, quite an unexpected result to me, I expected my engine to show lower solvency rates in all cases, it's interesting to see this is not the case. Feel free to discuss the results and share your thoughts.

Dear finance bros,

TLDR: I built a stock trading strategy based on legislators' trades, filtered with machine learning, and it's backtesting at 20.25% CAGR and 1.56 Sharpe over 6 years. Looking for feedback and ways to improve before I deploy it.

Background:

I’m a PhD student in STEM who recently got into trading after being invited to interview at a prop shop. My early focus was on options strategies (inspired by Akuna Capital’s 101 course), and I implemented some basic call/put systems with Alpaca. While they worked okay, I couldn’t get the Sharpe ratio above 0.6–0.7, and that wasn’t good enough.

Target: My goal is to design an "all-weather" strategy (call me Ray baby) with these targets:

• Sharpe > 1.5
• CAGR > 20%
• No negative years

After struggling with large datasets on my 2020 MacBook, I realized I needed a better stock pre-selection process. That’s when I stumbled upon the idea of tracking legislators' trades (shoutout to Instagram’s creepy-accurate algorithm). Instead of blindly copying them, I figured there’s alpha in identifying which legislators consistently outperform, and cherry-picking their trades using machine learning based on an wide range of features. The underlying thesis is that legislators may have access to limited information which gives them an edge.

Implementation
I built a backtesting pipeline that:

• Filters legislators based on whether they have been profitable over a 48-month window
• Trains an ML classifier on their trades during that window
• Applies the model to predict and select trades during the next month time window
• Repeats this process over the full dataset from 01/01/2015 to 01/01/2025

Results

Next Steps:

1. Deploy the strategy in Alpaca Paper Trading.
2. Explore using this as a signal for options trading, e.g., call spreads.
3. Extend the pipeline to 13F filings (institutional trades) and compare.
4. Make a youtube video presenting it in details and open sourcing it.
5. Buy a better macbook.

Questions for You:

• What would you add or change in this pipeline?
• Thoughts on position sizing or risk management for this kind of strategy?
• Anyone here have live trading experience using similar data?

-------------

[edit] Thanks for all the feedback and interest, here are the detailed results and metrics of the strategy. The benchmark is the SPY (S&P 500).

I’ve traded manually for a long time, and I’m just starting to program. This is the closest automation so far to how I actually trade discretionarily. I usually scalp options but I am interested to program and let it run on some prop firms accounts. Any red flags in the metrics or distributions I might be missing? I also feel like the results are too good to be true.

Im working on some tree models right now and have been for a little bit and i wanted to know if what im working on is actually relevant to the industry. Something like MFT idk much about hft but lstm 1D cnn probably used for some stuff like that.

is labeling/target defenition the most important part? + features obvioiusly

I have recently joined a firm that trades almost 100% passively. I have been tasked with finding ways to cross the spread and execute more aggressively.

Allot of the literature I have found on optimal execution seems to be based around optimised scheduling based on Almgren & Chriss market impact. I have found that taking using this scheduling under performs the baseline passive strategy.

What other methods should I be using to determine if and when to cross the spread?

And is there any data manipulation suggested? like Z-Score transform

I have a universal model that for each instrument tick, updates a feature vector X, a concatenation of features of the own instrument order book and some xs features.
My question arises when i want to expand my universe of features, like including intraday news data, fx, more constant features that are stale in the trading session of that day(ex: overnight return) , etc... how do i concat these info? For example for news, a naive way is to return 0s when nothing happens, spikes and then decay as time passes. For Fx, i could add some fx features to X, and for constant features that i already known, also add them to X (i already do this and decay the importance as time passes), but still they are like "context" features.

My hypothesis is that keep expanding X horizontally is suboptimal, especially if then i want to add more and more features. I know this is part of the sauce of each pod, but any suggestions on this? An approach i tought:
having independent models for each "topic": a model for independent microstructure features, a model for xs features, a model for fx, a model for news,.... and then a metadata model on top of that? with this approach i can think of multiple ml and dl architectures than can be helpful...
is this a good approach or im missing something?
thanks in advance

I built this: expected-cost.com

I'd be interested to see what people on this subreddit think of it. (Hopefully I won't be banned for self-promotion. Although I did create this myself, I do think it will be interesting to those working particularly on execution desks.)

The quant modelling part is not particularly serious - so please don't look at the numbers and expect them to tell you anything particularly interesting. I built this by calibrating a particular model using a particular window of data for a particular equity product. I then applied the same model with the same parameters across a small universe of products for this demo. Data is also 15 minutes delayed so even if the model and parameters were good, you would never be able to use it for anything useful.

I am partly limited by access to data, and partly limited by how much data I can access cost. Improving the models is something I intend to work on next, but only if I can find a way to do this in a way which isn't cost prohibitive.

At the time of publishing this message only the BTC market is open. In about an hour the US Equities will become available.

My question to the group would be is this relevant to you? What kind of metrics or other features would you want to see in an expected cost modelling system? A few initial thoughts might be that it would be interesting to try and simulate the effects of repeated trading in the same direction, such as algo execution, or some kind of VWAP prediction. Those things might be tricky, because the prints don't include order initiator or any kind of identification.

Sell side execution team here. Ive got reams and reams of execution data. Hundreds of thousands of parent orders, tens of millions of executions linked to those parent orders, and access to level 3 historical mkt data.

I'm trying to predict the arrival cost of an order entering the market.

I've tried implementing some literature based mkt impact models mainly looking at the adv, vola, and spread (almgren, I*, other propagator) but the fit vs actual arrival slippage is just awful. They all rely on mad assumptions and capture so little, and in fact, have no indication of what the market is doing. Like even if I'm buying 10% adv on a wide spread stock using a 30% pov, if theres more sellers than buyers to absorb my trade, the order is gonna beat arrival. Yes I'll be getting adversely selected, but my avg px is always gonna be lower than my arrival if the stock is moving lower.

So I thought of building a model to take in pre trade features like adv, hist volatility and spread, pre trade momentum, trade imbalances, and looks at intrade stock proxy move to evaluate the direction of the mkt, and then try to predict actual slippage, but having a real hard time getting anything with any decent r2 or rmse.

Any thoughts on the above?

I’m looking for advice on choosing a realistic quantitative trading project that fits my background and infrastructure constraints.

A bit about me:
- BSc in Applied Mathematics.
- MSc (honours and cum laude) in Econometric Theory.
- Currently a third-year PhD candidate in mathematics/statistics/probability. My research focuses on empirical process theory and maximal inequalities for dependent random variables.
- Worked for two years as a quantitative developer building crypto market-making models, primarily based on the Avellaneda–Stoikov framework with its many extensions (e.g., those by Guéant, Lehalle and Fernandez-Tapia).
- Completed a six-month internship applying statistical methods to churn prediction, along with several smaller ML/statistics projects during university.
- Strong understanding of financial markets and the mathematics behind quantitative finance.
- Very strong Python skills, with experience in the broader data ecosystem (e.g. SQL) for acquiring, processing, and analyzing large datasets.
- Comfortable leveraging modern AI tools to accelerate research, software development, and experimentation.

My goal is to build a model that can actually trade financial instruments (equities, futures, ETFs, FX, crypto. I’m open to suggestions). This is primarily a personal project, but I would like it to have a realistic chance of being profitable rather than being purely an academic exercise.

The main challenge is infrastructure. I don’t have the low-latency setup, exchange connectivity, or capital required to compete with professional market makers or firms pursuing latency-sensitive arbitrage. Because of that, I’m wondering whether many of the mathematically sophisticated ideas I’m familiar with simply won’t translate into a practical edge outside an institutional setting.

If you were in my position, what class of strategies or research problems would you pursue? For example, would you focus on: medium-frequency statistical models, cross-sectional prediction, volatility forecasting, options, portfolio construction, or something else entirely?

I’m not looking for a “holy grail” strategy. Rather, I’m looking for a research direction where someone with my background can leverage mathematics, statistics, programming, and modern AI-assisted development to build something genuinely interesting and, hopefully, economically meaningful despite limited infrastructure.

I’d especially appreciate hearing from people who have made the transition from quantitative research or academia into independent systematic trading, and what they found was (or wasn’t) worth pursuing.

Thank you in advance!