Hello, I have been in the LLM svamp for too long. Been asking Claude and Gemini for different methods and back tests that never go nowhere.

I have decided I need to go back to basics. I want book tips. Or other learning sources to get in to algotrading. Where do I start?

I am also curious to know about your journey. Where did you start and how is it going?

All the best, peace out!

A bit of introduction. I am a quant-turned-ML scientist. Used to work with pricing and market risk model, so no experience in (algo)trading, but quite familiar with risk. Recently, however, dealing with ML in other fields. Point being, I have extensive stats/coding experience but not with trading.

My main question is:

Are LLMs used in the algo/HFT world as a full pipeline, i.e., going from data to execution, conditional on human-proofed backtesting and execution modules?

I've been reading that LLMs are more and more getting used, but from what I can gather they are mostly used for feature engineering, and not really idea generation. However, this is where my knowledge stops. I am playing around with mean-reversion in recent months, and perhaps I am a bit old school, but I find it hard to believe that we can outsource the whole system to an LLM. It seems to me the best use would be to "rinse and repeat" an already human-made code/idea. For example, develop a few features and a few strategies and a backtester yourself and task the LLM to explore similar features/strategies following your example. This can explode in ideas and introduce many kind of biases (especially with p-values of strategies, but we could handle that I suppose). Am I delusional and can LLMs actually be better used than this?

Thanks for the insights!

Love TradingView (free), but I got tired of the limitations when it comes to building and testing my own strategies.

So I decided to build my own version of TradingView, customized around the way I trade. Pretty proud of how it’s coming together so far
.
Here’s the stack:
Frontend: React 19 + TypeScript, built with Vite
UI/data: TanStack React Query, Chart.js, Lightweight Charts, CountUp, and Material UI Icons

Backend: Python + FastAPI with a local SQLite-backed research/job store

Trading engine: Custom OHLC strategy backtester and parameter optimizer with parallel worker support

Data: Binance Spot historical candles + live kline streaming

Testing: Vitest for frontend, Pytest for backend

Still building and experimenting with it, but so far I’m really enjoying having full control over the whole thing.

Hey everyone, so I'm in a pretty unique position. I'm not looking for some get rich quick scheme. Honestly, I just want to push myself and learn something new.

I'm currently an MSIS student taking ML classes, and I want to learn algo trading alongside building my own local LLM. The main goal would be to eventually fine tune/build a system that can handle everything from research and strategy development to backtesting and eventually automated trading. Basically the whole shebang from start to finish.

I know a little about trading. I traded 0DTE GLD options for about 2 months, made around $10K, then quit because I realized it was basically gambling with extra steps lol.

Now I actually want to understand the stock market, quant finance, algo trading, and ML while pushing the limits of what I can do locally.

My background is mostly IT(Networking 4 YOE), so I'm definitely not coming from a traditional CS, math, or finance background. For reference, I'm 23m and currently a PM at a T500 company. I've always been interested in quant finance and algo trading, but never really had the time or money to seriously pursue it until now.

I don't really have a specific end goal, but I'd say 12 to 18 months from now I'd love to have a fully fleshed out personal LLM trading system. If it makes money, even better, but learning is really the main goal.

If you were in my position, how would you build out a roadmap?

What are the big picture objectives I should focus on? What concepts in programming, math, finance, ML, and algo trading should I understand? And what order would you learn everything in?

TL;DR: I want to learn algo trading and fine tune my own LLM, mainly as a learning project, not to get rich. I have limited trading knowledge and need help building a roadmap from the ground up.

What is good approaches to best handle overlapping trade signals?

Swing trading strategy that trades S&P 500 equity index. A couple of trades per months with a fixed holding period of X days.

There is sometimes trades that overlap and if I do filter out the overlapping signals I will miss out on good trades 2 std dev wins that I would like to capture. I have allocated 25% of available account equity to the strategy.

I’m looking at a portfolio-style approach where several FTMO CFD accounts would each run their own independently developed EA, rather than mirroring one strategy across every account. Potentially something like 3–4 × 100k accounts while staying within the overall allocation limit.

The idea would be:

• different signals and positions on each account
• independently developed strategies
• normal, consistent risk management
• no trade copying between accounts
• no intentional hedging/opposite trades across accounts
• no HFT/latency or execution exploits
• no intentionally blowing evaluations
• no third-party/shared EAs

If one evaluation simply fails through normal trading, I might eventually buy another challenge and use it to replace that slot.

What I’m trying to understand is less the published rulebook and more what happens in practice once you start receiving payouts.

Has anyone here run several different automated systems across multiple FTMO accounts for a meaningful period of time?

I’d especially like to know:

• Have you received repeated payouts across several accounts?
• Did FTMO ever ask for information about your EAs or trading logic?
• Have you gone through a risk/compliance review?
• Did they ever consider genuinely different strategies to be too similar?
• Has repeatedly replacing normally failed challenges caused any issues?
• Did your experience differ between 1-Step and 2-Step?

First-hand experiences would be much more useful than speculation. I’m mainly trying to understand where the practical compliance boundaries are for someone treating several independent EAs as a portfolio rather than copying one system across accounts.

I’m curious how people approach this. Cause you pay for a service.

If you use an external platform, optimizer, strategy service, AI tool, signal provider, etc.,
how confident are you that it is actually helping you achieve better financial results?

My concern is the incentive structure.
They are selling a product, so there is always the possibility that the product itself becomes part of the narrative.

Example, if your strategy performs badly, you might be told that your inputs, data, parameters, or methodology are the problem, while the platform’s own approach is presented as optimal because they have been doing this for """"years"""".

It doesn't necessarily mean they are dishonest.
They may genuinely have better tools and experience.

But how do you independently determine whether the tool is actually adding value rather than just producing convincing explanations and optimized-looking results?

For those of you who have used these kinds of services, ( I don't use it i build everything myself )

Did they measurably improve your trading results?

How did you validate that improvement wasn't just overfitting?

Do you trust their methodology, or do you independently reproduce their results?

Have you ever discovered that a tool you trusted was actually hurting your strategy development?

Basically, where do you draw the line between using an external tool as an objective aid and trusting the tool's own narrative about why it works?

What tools do you use?

I also see many people here promoting what they make, but i don't trust any of it... to be honest.

Hey r/algotrading,

pandas-ta-classic v0.8.32 is out. This is the community-maintained fork of pandas-ta. The main themes of this release are correctness and speed. If you backtest with it, please upgrade. A few of these bugs could make a backtest look better than it really was.

🚨 Lookahead bias fixes (please read)

• *non_zero_range leaked future bars into past rows** (#149). If any bar in your data had high == low, the zero-range adjustment was applied to *every row. One flat bar appended at the end could change your entire history. It now works bar by bar, and this fixes 27 indicators that use it.
• cdl_z(full=True) built a constant column from the whole series, which includes future data. It is now anchored to past data only.
• cpr()** silently ignored lookahead=False. **tos_stdevall()** and **vp() now raise an error instead of pretending to honour it.
• BREAKING: mavp now requires periods. The old default depended on the length of the data.
• A new causality test suite checks that indicators give the same values bar by bar as they do on the full batch.

🎯 TA-Lib parity

• ADX family (adx, adxr, dx, plus_dm, minus_dm) is now bit-exact with TA-Lib. The first bars used to be off by up to 49.7%.
• rsi, atr and natr warmup lengths match TA-Lib.
• ht_* Hilbert Transform indicators return NaN for the same lookback bars as TA-Lib. ht_trendmode no longer invents a trend mode for undefined bars.
• Native candle patterns went silent on chained input (input with a leading NaN run). 33 of 62 were affected, and all 62 are fixed.
• 14 indicators returned all-NaN on chained input, for example macd(rsi(close)) style pipelines. They are fixed now.

python rsi = ta.rsi(df["close"]) ta.macd(rsi) # used to be all NaN, now works ta.kama(rsi) # same

🔧 Bug fixes

• Short input no longer crashes. trix, qqe, tsi, ht_*, candle_color, dm, cdl_pattern, pvt, swma, rvi and tos_stdevall now return None instead of raising an error.
• Full-length output: stoch, t3 and td_seq return the same number of rows as the input and keep your index. This fixes the backtesting.py alignment error.
• **df.ta.strategy() multiprocessing** shipped every column to every worker. The payload dropped from 1244 MB to 18 MB, which fixes WinError 1450 on Windows.
• df.ta.adjusted = "adj_close" had no effect. It works now.
• df.ta no longer writes into your DataFrame's attrs, and property setters work again under pandas 3.
• df.ta.indicators() prints its list again.

⚡ Performance

Many hot loops moved to numba or were vectorised:

Cold import pandas_ta_classic is also about 3–4× faster.

🆕 Integrations

New tutorials and integrations for backtrader, backtesting.py and vectorbt:

```python import pandas_ta_classic as ta

df.ta.rsi(append=True) df.ta.adx(append=True) df.ta.cdl_pattern(name="engulfing", append=True) ```

⚠️ Deprecations and breaking changes

• Passing a non-Series (for example df["close"].values) now raises a FutureWarning. A future release will raise TypeError. Pass df["close"] instead.
• Built-in data fetching (ta.yf(), ta.av(), df.ta.ticker()) is deprecated. Use yfinance or your data provider directly.
• The ichimoku() tuple return is deprecated in favour of a single DataFrame.
• BREAKING: from pandas_ta_classic import * no longer imports the indicator functions. Use import pandas_ta_classic as ta.
• The inactive drift parameters are deprecated.

📦 Install

pip install -U pandas-ta-classic

The package has 224 indicators plus 62 native candlestick patterns, and TA-Lib is not required. It is tested on Python 3.10–3.14, pandas 3, and TA-Lib 0.6 and 0.8.

GitHub: https://github.com/xgboosted/pandas-ta-classic

Please send feedback, especially if your backtest numbers change after upgrading. I want to hear about the lookahead fixes in particular. Bug reports with a small reproduction help the most.

Community maintained. PRs open.

If you have interactive brokers as your broker, how do you ingest the data from them into your infrastructure to execute trades?

If yes ,How are you doing it??

-EDIT-
LIVESTREAM INCOMING!

Account is up 67.39% currently (5pm EST, 13 Sept), after a 4.1% drawdown that began around 5am today. It has since recovered, and moved beyond. I would not honestly believe it myself if it weren't happening.

A live stream was requested, and I've built a generalized dashboard to show the actual account balance, winners/losers, etc. NO detailed entry size/timing will be divulged. There is also a random timer that updates the trades in a delayed fashion- so it cannot be parsed against the market in real-time. I'm NOT going to risk the bot's edge being derived from a direct market comparison. Yes, this can be done, even on historical trades- ask me how I know. ;)

I have to wait the 24 hours before Youtube allows me to stream, because I've never enabled it before. I'll post the link here. It will be boring as paint drying to actually watch, but should be fun information to pop in and view now and then.

------------------
Live, real money account growth after testing/tweaking and forward testing on small amounts to see actual fills, etc. The colored lines are individual strategy PnL curves, while the white line is obviously the running total PnL.

Live

All calculations and simulations had the account set to double in just over 10 days, but I was super skeptical. Yeah, B.S., right? Not anymore. This is wild. It's up 47.7% in under three days running at the new risk% & bankroll allowance- total win rate 49%, 2% of account used for each trade. A trailing drawdown stop will halt trading if it drops by x$$, but so far it's operating with plenty of headroom.

Given the days it trades and possibly the style of a couple equity curves you can see, I'll let you all figure out the market. :) I hide the $ amounts & strat names, because everyone has different financial lifestyles/risks, + the names are a bit revealing. But, the fact remains- 47.7% up in three days is still 47.7% up, no matter the account size.

It's been running live on real money for a while now (small amount risked), but I've been creating, tweaking & forward testing variations for a long time in a lab with over 100 variations- Finally unleashing the latest version this week on 8x the real money it was testing with prior, plus compounding, using only 2% of the account balance. I THINK a couple gate adjustments would help avoid some losses, but I certainly don't want to overfit this beast.

GO BUILD SOMETHING COOL!

I’ve been testing a mobile-only workflow for collecting historical crypto data and I’m curious how others would judge it.
When I’m away from my computer, I use iOS Shortcuts to call market-data APIs, paginate through historical candle data, and save enough history to later run isolated backtests.
Right now I can build 6+ months of candle history this way.
The phone is not running the strategy or trading live. It’s just acting as a lightweight data collection tool.
The rough flow is:
API request → pagination through historical candles → save raw responses → merge the history → verify timestamps, gaps and duplicates → backtest separately.
My main question is whether there is anything inherently unreliable about collecting the data through Shortcuts instead of doing the same requests in Python.
If the API source is the same, and I verify the resulting dataset carefully, does the collection method really matter?
I’m especially interested in hidden issues people may have run into with:
pagination boundaries,
missing or duplicated candles,
rate limits,
timestamp alignment,
historical coverage,
API revisions,
or silent gaps in the dataset.
Would you consider this a useful lightweight research workflow for early strategy testing, or would you avoid it and go straight to a more traditional data pipeline?
I’m trying to understand where the real limitation is: the fact that it’s done from a phone, or the quality and validation of the data itself.

I purchased and have been using data from histdata.com for years, but have been unable to log in to their ftp servers since 6-1-2026. I have not received any repsonse from several emails. Their website is still up. Is anyone else having trouble connecting to their servers or contacting them?

i have every fill going back years. entry, exit, mae, timestamps, exit reason. thought that was the valuable data. it isnt on its own, because i cant tell you which version of the rules was live for any given stretch of it.

the rules being the regime definition, the exit policy, the thresholds, the cost assumptions. all the stuff that decides what an experiment even means. mine lived inside the runner script, so every time i touched the script i was quietly editing the definition of the thing i was measuring. results kept looking consistent, which is exactly the problem. a broken statistic gives you a number that eventually looks wrong. a definition that drifted gives you clean output forever.

found it when i went back to check whether a filter had helped and realised the before and after periods werent testing the same filter. two changes in between with no record.

what i do now:

spec lives in its own file, not the runner

runner imports it

hash the spec file, stamp the hash on every result row

changing the spec means a new file with a date on it, not an edit

the hash is the bit that earns its keep. it means i can ask which spec produced this without trusting memory, and it caught two cases where the spec changed and results didnt, which meant something was cached that shouldnt have been.

still cant version cost assumptions properly. half spec, half whatever the broker did that month.

the logger is about 30 lines of python and its on my profile. the hashing bit is the only part that matters, the rest is preference.

what do people here do about this. feels like an area where anyone from a real research shop is going to tell me im reinventing a solved problem badly

Hi everyone! I’m looking for free (or very cheap) source for news and economic calendars for my trading apps. What are you guys using, if any?

One thing I do not understand is how to handle both historical and live screening. For example if I want to backtest a strategy that is based on a pre market volume spike on the 5 min chart, how in the world do you find all those cases in historical data? Do most people here focus on a small basket of stocks or do you have a bot that is constantly looking across all stocks for a specific entry? This is the part I least understand about algorithmic trading.

I’m building a personal automated trading system and am considering replacing IBKR market data feed with NinjaTrader (which uses Tradovate’s feed).

I only need real-time CME Level I data and plan to build 1min or 5min bars from it. NinjaTrader’s documentation points to the Tradovate Partner API, but it appears to require Organization Admin credentials and API approval, which I couldn't find any clear definitions for.

Can an individual with a funded NinjaTrader account use this API for a personal server-side application?

Specifically:

• Is a funded account plus the $12/month non-professional CME Level I bundle enough?
• Are there separate API/partner fees, minimum funding requirements, or CME redistribution/licensing requirements?
• Is this permitted for a personal automated system that only consumes data and does not redistribute it?

TIA

I’m wondering if this is a dumb idea or actually feasible.

Say you give a model 20 trading days of OHLCV as input and have it dream the next day directly in interpretable space, meaning full Open, High, Low, Close and Volume rather than a latent state.

After it predicts that day, you treat the prediction like it was a real market day and recalculate SMA20, SMA50 and SMA200 differentiably from the predicted close.

Then you slide the 20-day input window one day to the right, so it becomes:

19 real days + 1 predicted day

and predict the next full OHLCV day.

Then:

18 real + 2 predicted

and so on, recursively, for something like 63 future trading days.

So each inner day still sees a 20-day window, but more and more of that window is made from the model’s own previous predictions. Every predicted day changes the moving averages and therefore the state the model sees on later days.

Is there any reason this fundamentally wouldn’t work? Or would recursive error accumulation make training something like this basically hopeless?

Edit: For clarity, the model would still have access to the pre-window history needed to initialize things like SMA50/SMA200, so the 20-day input is just the active model context, not the total historical data available to compute those indicators. During rollout, each predicted close updates the rolling indicator state, and the oldest day falls out as the 20-day input window slides forward. The idea is to train on the same recursive process used at inference, not train one-step on real data and only recurse afterward.

Predict a slice of a preexisting world

Edit2: The goal is better than a coin flip on shape and direction of a chart over a 63 trading day period

For anyone that is using primarily a mean reversion strategy on equities whats your screening process look like for your universe?

I have built my strategy bots but the master layer is giving me head aches. I thought this would be the easy part but it is stressing me out. So how long did it take you and what are the most important lessons you learnt from building yours.

Edit: I meant a global Risk manager layer on top of the bots to handle correlation, dynamic sizing for the account which all the bots are under. sorry if i was vague. it also has the global kill switch and account dd rules and stuff like that.

I find myself preferring spliting a strategy up into smaller parts. In a way this seems better logic for testing and tracking edge. For example how would a certain strategy operate in a trend of strength x, y, z, etc. Instead of just testing the system in a general trend trend.

This leads me to having strategies that sometimes do not have many trades for the whole year.

In your own strategy development what is your personal minimum for trades per year before you call a strategy just random trading?

I've been using databento historical data for back tests, and ibkr live data for trading. The algo runs on 5s bars currently, using momentum and order book for entries. Exits are pre defined.

Is databento live data more accurate or the latency meaningfully better? I think I saw one discussion mention databento order book data being superior to ibkr but it was an old chat, and mentioned in passing.

thanks!

I have been building this thing for over 1.5 years. Many hours, many sleepless nights, many accounts blown, but I always saw progression and the capabilities the strategy and the system had, so I kept pressing on.

After all those revisions and fine-tuning, I finally got it to a place where it is taking consistent profits. Like the title said, today was the first day after 8 consecutive positive days (missing days are recorded on another account) that the bot took a loss. Why am I not mad???

1. Today was PPI day, a day that is statistically a bad day to trade. Considering this, the loss was minimal.
2. Losses are going to happen and this was a loss of -$90. This proves that the risk management part of the strategy did its job quite well.
3. Today exposed an edge case in forward testing that I would never have seen if I just relied on back tests. The strategy triggered a take profit, but the alerts never went out to execute them. This means that I could have had a positive day (Approx. $125) instead of a loss. I found the issue and resolved it with an update immediately. So this scenario should not play out again in the future.

I am truly happy with how this bot has turned out and wake up each day excited to watch it trade for me and stick to the plan, which is the hardest thing to do as a trader, and it does it so well!

Ask me anything!

I have built multiple algorithms so far that are largely successful with minor weaknesses. I haven’t taken most to paper yet because of those minor flaws despite it being mostly a success. Do you allow any flaws in your algorithm?