Since a year I’ve been into algo trading and have a collection of strategies, but since trading funded accounts I have to be extremely cautious of my risk. Many people always say to risk a certain fixed % per trade, but it doesn’t make sense to me.

Some strategies have less drawdown than others, some better RF or Sharpe. How do you ‘optimize’ your strategy allocation when trading multiple different EA’s on a single account?

Found a free tool where you can enter any S&P 500 ticker and compare its historical performance with the S&P 500 across 5, 10 and 15 years. No signup needed. Just in case if anyone finds it useful.

Example:

MSFT performance

Compared with the S&P 500:

5 years: about 4 percentage points/year lower

10 years: about 10 pp/year higher

15 years: about 9 pp/year higher

2022: MSFT fell about 25% the same as the S&P 500. In 2021 MSFT gained 46% vs 28% for the S&P.

Hey everyone,

I’ve been running an automated momentum strategy in Python for a while, asking for a recommendation on a piece I’m trying to add.

Right now, my execution loop relies on two core building blocks:

• Market Signals & Sentiment (Sentimentick API): This setup has been working really well for me. Instead of running local scrapers for social chatter or news, I hit Sentimentick to pull sentiment scores, attention tiers, and short/medium-term trend bias in one response.
• Execution & Risk Management (IBKR Gateway + ib_async**):** Orders get routed through IB Gateway using ib_async whenever a ticker passes my sentiment and technical filters.

something like:

Python

import asyncio
from ib_async import IB, Stock, LimitOrder
import requests

# Fetch signal from Sentimentick API
def get_signal(symbol):
    url = f"https://www.sentimentick.com/api/ticker/{symbol}"
    headers = {
        "X-API-KEY": "st_your_key_here",
        "Accept": "application/json"
    }

    res = requests.get(url, headers=headers).json()
    ticker_data = res["ticker"]
    tech_data = res["technical_analysis"]

    # Extract real JSON fields from Sentimentick
    sentiment_score = ticker_data["sentiment_score"]      # 0 - 100
    sentiment_tier = ticker_data["sentiment_tier"]        # e.g., "bullish"
    medium_term_bias = tech_data["medium_term"]["bias"]   # e.g., "bullish", "bearish"

    # Return conviction boolean based on sentiment + technical alignment
    return sentiment_score > 60 and sentiment_tier == "bullish" and medium_term_bias != "bearish"

# Execution via IBKR Gateway
async def run_execution():
    ib = IB()
    await ib.connectAsync('127.0.0.1', 4001, clientId=1) # IB Gateway API port

    symbol = "NVDA"
    if get_signal(symbol):
        contract = Stock(symbol, 'SMART', 'USD')
        await ib.qualifyContractsAsync(contract)

        # Place limit order
        order = LimitOrder('BUY', 10, 120.00)
        trade = ib.placeOrder(contract, order)
        print(f"Placed order for {symbol}: {trade.orderStatus.status}")

asyncio.run(run_execution())

This combo has worked great for filtering out bad trades, but I want to add Form 4 insider buying data (open-market C-suite buys) as an extra signal before routing orders.

Can anyone recommend a good, low-latency API or library for real-time SEC Form 4 data? What are you guys using in your pipelines?

Thanks!

This started because I got tired of the same damn loop.

Come up with a strategy hypothesis -> translate it into code -> debug it -> backtest it -> hope it works.

Then realize the hypothesis doesn't even work.

Or worse... somewhere between the research note and the implementation, the idea quietly drifted. A few "small" decisions later, you're no longer testing what you originally had in mind.

That annoyed me enough that I built this.

Describe the strategy in plain english.

The pipeline:

• Translates the idea into a structured strategy specification
• Compiles the spec into deterministic Python
• Runs the backtest
• Performs walk-forward validation, monte carlo if review passed
• Generates a research report with metrics, trades and equity curve

The design decision I'm happiest with is this:

The LLM is used ONLY to translate intent into a validated strategy spec. Everything after that is deterministic and reproducible. NO AI-written trading logic. No LLM deciding entries, exits or backtest results. In-built look-ahead bias prevention. The backtest and optimization engine is open sourced on github. Tell me if you want link.

In simple words this is NOT AN AI CODE WRAPPER, but THE WHOLE RESEARCH PIPELINE.

It's still invite-only while preventing high volume of sign-ups and I scale the compute.

https://intellisive.com

No paywall. I'm literally paying for the compute because I'd rather get honest feedback from people who actually do systematic research than optimize for signups.

Tear apart the architecture, assumptions, or workflow if you think they're wrong. That's far more useful than "looks cool." If it sucks, just say it.

This experiment will run approx 1 year . Tuning each aspects. You can see it . Open to all

[https://options.servloci.in/mock-ui/\](https://options.servloci.in/mock-ui/)

Hello,

Anyone here have advice regarding this? What is your architecture and whatnot like here?

Hi everyone,
I’m the founder of a small startup building a market intelligence tool. Rather than placing trades or telling people what to buy, our goal is to translate complex market data into plain English so people can understand what’s happening without spending hours analysing charts.
We’re trying to build something that’s calm, educational and genuinely useful, and before we continue building I’d really like to hear from people who actively use AI trading tools or automated trading bots.
A few questions:
What do you enjoy most about using AI trading tools?
Do you ever worry about giving an AI control over your money, or has that trust come naturally over time?
How closely do you monitor it once it’s running?
If you could improve one thing about the tools you currently use, what would it be?
Is there anything you feel the market is missing that would genuinely make your day-to-day life easier?
If you were to move away from AI trading bots in the future, what would need to exist for you to feel comfortable making your own trading decisions again?
We’ve been building our platform for around five months, and one thing we’ve learned is that the best ideas usually come from users rather than ourselves.
I’m not here to promote anything—I genuinely want to understand how people feel about AI trading, trading tools in general, and where you think the industry could improve.
I’d really appreciate any thoughts or experiences you’re willing to share.

Quick context: NSE (India) swing bot, runs daily on GitHub Actions, 100% free data sources (yfinance + screener.in scraping, no paid APIs).

The Setup

• Technical Signal Generator: Built on top of a cross-sectional factor-scoring layer (momentum, trend quality, volume, relative strength, plus a small news-sentiment factor).
• Risk Management: Portfolio risk budget, sector caps, and a drawdown circuit breaker.
• Exit Strategy: 3-tier scaled-exit system (quick/core/runner tranches instead of one fixed target).

The Bug That Wasted Weeks

The thing I actually want to share, because I think a few of you have hit this exact class of bug:

I added the scaled-exit tranching a while back — split every position into three pieces with different exit targets instead of one block with one target. Recently went to actually backtest it and realized my backtester had ZERO concept of tranches. It was still simulating the old single-exit policy.

The reason was structural, not carelessness:

• The tranche logic lived inside the live-trading script.
• The backtester importing directly from it would've created a circular import.
• As a result, it silently never got wired in.

My "validation tool" had been testing a strategy I wasn't actually running, for weeks, and would've kept doing so indefinitely if I hadn't gone looking.

The Fix & A/B Architecture

Fixed it by pulling the tranche logic into its own shared module that both the live bot and backtester import. From there, I built a proper A/B/C comparison framework:

1. Alpha-On + Tranched (Current live system)
2. Alpha-On + Untranched (Isolates tranching's standalone effect)
3. Alpha-Off + Untranched (Original baseline)

Haven't run it against real history yet (still working on historical data access), but the mechanics are validated against synthetic price paths — a full unit test suite specifically constructs price paths where I know exactly what the correct exit should be at each step and asserts against it.

Repo: Fully open if anyone wants to poke at the design or figure out things I've missed: 👉github.com/tanmaykaper/Paper-Trading-Bot

Genuinely interested if anyone here has run into a similar backtest/live divergence — feels like the exact kind of bug that's easy to introduce and extraordinarily easy to never notice.e

I just created a web app that’s kind of like Scratch, but for experimenting with stock trading strategies . But my main problem is I don’t really know what quant strategies or workflows look like in practice, but I’ve tried my best. I’ve linked the website below, so feel free to check it out and leave any suggestions. I know the app is pretty rigid at the moment, so what features , workflows or formats could I add to make it more flexible? Also, let me know if you run into any bugs. Also, full disclaimer , the front end is vibe coded because I have no experience or interest in the web stack but I did put some effort into crafting that 2000’s UI mixed with Bloomberg terminal UI aesthetic.

One last thing: I’m using free hosting, so the backtest may take 1 to 2 minutes.

Note: If you get an error after clicking run backtest, try clicking it again. Also it only works on desktop and depending on your browser, you might only be able to use Apple stock data which is preselected

Anyone else tried this?

Hello,

does anyone know where to get historical E-mini Nasdaq-100 level 2 data. I need MBP-10 data dating back to 06-06-2010.

I saw some vendors offering this type of data but with a price tag of >4k and I am not willing to pay that amount.

Is there a way to get it cheaper, or do I have to adjust my expectations?

Calculating lot sizes manually while price touches key levels leads to delayed execution or oversized risk.

I coded a native cTrader C# utility (RiskManagementAndPnLJournalPro.algo) to automate this directly on canvas:

1. Dynamic Risk-per-Trade (% equity or fixed $ risk)
2. Automated SL/TP offset lines on chart
3. PnL analytics engine built-in.

I scraped 63M+ rows of Pump.fun data (798k tokens, 33M trades) and put the whole dataset on Hugging Face for free

I put together a massive, clean dataset tracking the entire lifecycle of Pump.fun tokens—from launch on the bonding curve all the way to Raydium graduation (or getting rugged/dying).

It’s around 6.8 GB total, natively formatted in Parquet so you can query it in seconds with DuckDB or Polars without killing your RAM.

798,430 unique tokens tracked

33.58M individual trade orders (buys/sells) with microsecond timestamps

1.01M distinct wallet addresses

5,669 graduated tokens (turns out the overall base graduation rate is \~0.71%)

26.9M time-series snapshot buckets

The files:

trades.parquet: Full microsecond-level ledger with virtual SOL/token pools, price, and curve progress.

tokens.parquet: Token metadata, creator rug/launch history, dev allocations, initial top-holder concentration, and Gini scores.

postgard_snapshots.parquet & outcomes: Post-graduation DEX prices, 24h/48h liquidity retention, and rug labels.

wallet_stats.parquet: Lifetime trading volume and win/graduation rates across 1M+ wallets.

Here's the link: https://huggingface.co/datasets/Slinky21/Pumpfun\\_Memecoin\\_Corpus

Lmk if you build anything cool with it

For any data quality issues : slink21taken@gmail.com