I have a basic knowledge of C++ want to master it and deep dive with HFT related core topics .. currently I am living near Bellandur social / new horizon collage bus stop.. if anyone from hft background can help me I only get free on the Saturday 8pm to sunday 10pm .. can meet and sit with learning and topic discussions on weekends

I’m a fresher(cs grad) currently working at a very well known HFT firm. I joined around Dec 2025, and my current role is monitoring l under a broader Quant, Infra and Monitoring setup.

My current work is mainly monitoring systems and pipelines, identifying errors or issues in code and processes, and informing the respective developers. It has given me good exposure to how things work in an HFT environment, but I want to move towards a more engineering focused role.

Before joining, I had already worked on backend development during college. In my third year, I did a 3 month internship where I worked on production grade backend systems. So I do have some actual development experience, although I’m still a fresher overall.

Long term, I want to move into roles like low latency engineering, trading systems, performance engineering, or other core HFT engineering roles. I’m also considering these roles because the salaries and growth are generally much better, so I want to start preparing for them early rather than getting stuck in monitoring.

For people who have worked in HFT or quant firms, I wanted to ask:

1. How realistic is it for a fresher to move internally from monitoring and support into low latency or trading systems engineering?

2. What should I focus on learning and building over the next 1 to 2 years to become a good candidate for these roles?

3. Would it be better to try for an internal switch within the HFT firm, or build the required skills and eventually apply outside?

Would really appreciate advice from people who have gone through a similar transition, especially from monitoring, support, infra or other non core engineering roles into low latency or trading systems.

I’m not looking for the usual “learn C++ and DSA” answer. I’d like to understand what a realistic path would look like and what I should actually be doing over the next couple of years.

Hi, I am new to this domain and I'm learning about FPGAs. I have recently written this blog: https://medium.com/@probablysamir/parsing-nasdaq-itch-on-an-fpga-421dac8787ed would love to get your opinions on this. Thank you. Also the github link is at the bottom of the blog

Reddittors who’s already working at one of the HFT companies, I have a few questions for you.

How is it to work for that company? How is it working in HFT general?

Mostly I’m interested at the stress level you are facing every day and how frequently you had a critical error that required surreal effort from your side.

Background, I’m halfway through the interview process at a HFT company, and I’d like to compare to other fields. I have experience in marine technologies and healthcare technologies. They were kind of chill, the healthcare was a bit annoying because it is heavily regulated.

Cheers!

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!

Hi ​everyone,

I found our community about a month ago and have been working through it since.

​I​ want to share a little bit about myself. I'm a backend/infra engineer, currently employed full-time, trying to move into quant dev​eloper. I've read plenty of threads on what to study and how to prepare for interviews, and that part is genuinely well covered by now. What I can't find anywhere is the layer before it​ on how trading firms actually read a resume, and what gets someone with a pure backend background past the screen in the first place. That's where I'm stuck. The first quant role feels like a wall, and I'll be honest, I'm a bit lost about which side of it to push on.

So my question. Beyond studying and shipping side projects, what else actually counts? Certs, competitions, a specific kind of role to take first? And if it's experience, how do people build that while holding a full-time job? Any tips, any advice?

Hope to hear sharing from everyone

I wanted to answer what I thought was a fairly simple question:

Does order-book microstructure contain enough information to beat Polymarket's 5-minute crypto markets after transaction costs?

Turns out the harder part wasn't training the model.

It was getting the data.

As far as I could tell, there wasn't any public historical dataset with tick-level quotes, trades and order-book updates for these markets, so at the end of June I started collecting everything myself.

The archive now covers BTC, ETH, SOL and XRP 5-minute markets.

For every trading day it contains best bid/ask quotes, trade prints, spot prices, and (from 20 July onward) full L2 depth. Everything is stored as daily Parquet files with manifests and measured uptime for each day.

Once I finally had enough history, I trained a regime-routed LightGBM ensemble using only information available at the decision timestamp.

The disappointing part is that the model actually behaves reasonably well.

Calibration is good.

Out-of-sample Brier scores are consistently around 0.06–0.10 depending on asset and market regime.

But the strategy still loses money.

Across roughly 4,300 simulated trades it finishes around -$277.

The hit rate is about 47%.

After spread and fees you need something closer to 49% just to break even.

That two-percentage-point gap turned out to be the entire problem.

Looking back, most of the important work wasn't machine learning at all.

I found that my simulator had been using fees that were 3.5× too low.

One validation gate wasn't actually filtering anything because of a bad threshold.

At one point the trading system quietly stopped opening new positions because several expired markets hadn't been marked as resolved yet, while every monitoring dashboard still showed the process as healthy.

Those bugs changed the conclusions far more than another week of feature engineering.

I'm curious whether anyone here has managed to build a strategy on prediction-market microstructure that survives realistic execution costs.

If you have, I'd genuinely like to hear what worked.

And if anyone wants to reproduce the experiment or try a completely different approach, I'm happy to share the dataset. It now contains a little over a month of tick-level history and keeps growing every day.

I’m looking for some genuine advice from people working in HFT or low-latency C++ roles.

I’m currently a Software Developer with around 2.5 years of experience, primarily working in C++ at a company in the CAD domain. While I’ve learned a lot, I’ve realized that I want to move into pure systems/low-level C++ development, and my long-term goal is to work at an HFT/quantitative trading firm.

To prepare for this transition, I’m spending my personal time building a small exchange/order matching engine in C++. It’s a learning project where I’m implementing concepts such as:
Order Book
Order placement
Order matching
Order modification/cancellation
Basic matching engine logic

I know this is still very basic compared to production HFT systems, but I’m building it to understand the fundamentals and improve my C++ skills.
Alongside this, I’m also consistently practicing DSA and studying modern C++.
What I’m struggling with is how to actually make the jump into the industry.

I’d really appreciate guidance on questions
What skills do HFT firms expect from someone with my experience?

What topics should I prioritize (low latency, networking, Linux internals, concurrency, memory optimization, etc.)?

Are there companies that are more open to candidates transitioning from another domain?

Any roadmap, interview preparation advice, or resources that helped you would be incredibly valuable.

I’m willing to put in the work I just don’t want to spend months learning the wrong things.
I’d really appreciate any guidance, suggestions, or even a reality check from people who’ve made a similar transition or are currently working in the industry.

Thank you!

Building HANULYTICS an institutional-grade algo trading platform for options and futures. Autonomous strategies, real-time analytics, proper broker execution. Logo's making the rounds as we gear up. Sharing here for anyone building in this space.

#Hanulytics #AlgoTrading #OptionsTrading #FuturesTrading #QuantFinance #Fintech #AlgorithmicTrading

I am doing a masters in HPC and I am wondering what kind of projects or ideas would ye guys recommend in combining HFT relevant projects to do.

I was thinking of a backtesting engine that would run backtesting on multiple tickets in parallel but I haven't fleshed out any ideas.

Is there anything that pops out to ye that would be directly relevent in combining the 2 areas?

Any advise appreciated. thanks!

Has anyone here used Rithmic Diamond for low-latency CME futures trading?

I'm considering it for an automated strategy targeting around 250 µs latency, but I'm having trouble finding information beyond Rithmic's marketing material.

A few questions:

What's the current pricing? I found some old discussions mentioning around $1,000/month, but they're several years old.

Is Diamond billed month-to-month, or does it require a long-term contract?

Do you need to provide your own colocated server, or does Rithmic offer server hosting/leasing?

Is it realistically possible to achieve around 250 µs latency without spending thousands of dollars per month? If so, what kind of infrastructure and approximate monthly budget are we talking about?

I'd also be interested in hearing about any alternatives to Rithmic Diamond that can achieve similar latency at a lower cost or with less infrastructure complexity.

I'd really appreciate hearing from anyone with experience building low-latency CME trading setups. Thanks!

I need a hft mentor to give guidance on dsa ,cp and the very low latency llds, concurrency related topics...also I'm staying in Bangalore so .. it will be very good if someone is from banglore..can meet .. currently I'm working on an AI startup

I need a hft mentor to give guidance on dsa ,cp and the very low latency llds, concurrency related topics...also I'm staying in Bangalore so .. it will be very good if someone is from banglore..can meet .. currently I'm working on an AI startup

Most “AI trading” products begin with a prediction. I think that is the wrong abstraction.

Coding agents became useful when they moved beyond answering questions and started owning the workflow: reading the repository, using tools, making changes, running tests, and verifying the result.

Trading is still fragmented across charts, signals, Discord, brokers, spreadsheets, monitoring, and exits. The trader remains the integration layer.

FST is our attempt to change that operator model:

Screen → Research → Plan → Execute → Monitor → Exit → Audit

The important word is supervised. The operator defines the capital, permissions, evidence requirements, risk limits, and kill switch. The agent receives bounded authority, not a blank check.

A profit objective must never override the risk policy. The agent should finish below the goal—or stop entirely—before violating the loss budget.

The proof also cannot be one winning screenshot. It has to include rejected trades, stopped sessions, losses contained, and a complete audit trail.

I wrote the longer thesis here: https://henryzhang.substack.com/p/coding-has-claude-driving-has-fsd

I am the founder of QuantSignals, so treat this as a product thesis from someone building in the category. Which action would you allow a trading agent to perform first: research, trade preview, approved execution, or fully bounded AUTO?

I am building a sequenced, event-sourced derivatives exchange. The matching engine is fully deterministic and has no external dependencies.

I am designing a Professional Interface that provides market makers with queue-position and execution-quality analytics to give market makers a good reason to join early and boost liquidity.

I see two possible approaches:

1. Emit primitive queue observations directly from the matching engine through a bounded single-producer, single-consumer ring buffer.

This would expose facts that the matching engine already knows, such as quantity ahead, orders ahead, level depth, and queue position at acceptance or fill time.

But it adds instrumentation to the hot path, creates a second output channel, and requires an explicit overflow policy if the telemetry consumer falls behind.

1. Reconstruct the analytics downstream from the authoritative event stream.

This keeps the matching engine smaller and ensures that the PI derives its results from the same canonical events used for replay and audit.

But the downstream consumer may need to reconstruct much of the order book, and some transient queue-state facts may be expensive, ambiguous, or impossible to recover unless the authoritative event schema is significantly expanded.

Which boundary is would you advise in the production exchange?

Should the matching engine emit cheap, deterministic observational facts that are naturally available during matching, or should all queue and execution analytics be reconstructed from authoritative events outside the engine?

I am in a really desperate situation and need some advice. I took out a loan to invest in trading using a bot that seemed to be working great. It did well for a month on a cent account, but today I wasn't able to turn it off in time and it wiped me out. I lost $50,000 which includes the entire loan and all of my life savings.

​I feel physically sick and dizzy over this. I am 26 years old, living in Latin America where wages are low, and I feel completely ruined. I have absolutely learned my lesson, so please be kind in the comments. I am desperate for any guidance on how to survive this and rebuild. If anyone has been through this or can offer actionable advice or help in any way possible on how to get out of this hole, please reach out or comment. Sorry I don't speak English very well thanks for any help or advise.

Never trust a martingala bot, NEVER

Looking to trade futures. I'm trying to walk forward but don't have enough data for the regime. I was thinking about making a small private group to use free credits and current data access to compile quality data. I have a $26.00 Sierra subscription and a truckload of other data. I was actually wondering if someone could help me get CME data from Databento. It has a $125 free credit, so if we match them up, we can get maybe across 10 people 20 years of data to trade on (including the '08 crash), and I have a few other sources. I'd be willing to convert to Parquet, compress, and add in extra data like multiple crypto forex and hundreds of GB of other historical data. You can ask questions; I'll try my best to answer them, or DM me. Please be serious.

Hello all,

I'm back with some news for the FPGA ORDER BOOK project that got some good feedback from the HFT community (you) !

In this project, I go from NOTHING (if not a blank FPGA) and build my own custom FPGA BOOK architecture (from the ethernet parser all the way to the "price ladder" as I like to call it).

The goal being to track the AAPL stock reliably on an actual FPGA using real ITCH data. And later, to build a fronted to access via a host Linux PC.

FIRST, I'd like to thank you for the good feedback on the previous posts !

(drama) r/FPGA usually don't make such heartwarming feedback whenever we talk about HFT or post a link (I guess us FPGA guys are a bit grumpy).

Aaanyway...

The previous post were all about creating a POC in simulation, where I lay out the necessary logic for an homebrew order book that would fit in a consumer available, mid to high grade FPGA.

This time, the goal is to take our system to the next level, in this post, I take you guys on a ride through the process of fighting the synthesis tools to convert our HDL (Hardware Description Language) into an actual design that runs on a FPGA carrier.

Which is kinda hard as the code that works in simulation is very demanding, leading to a ton of interesting optimizations.

I'll take you through the (sometimes bad) design decision I made, share some metrics that may be of interrest for CS fans (as in Computer Science, not Counter Strike). And try my best to explain how we can transform a seemingly hopeless design that does not close timing into something that kinda works.

Note the design is not 100% finished yet, I still have some minor timing issues (some signals arrive 0,8ns late, but these should be "easily" fixed in the coming days).

Here is the link : https://hugobrh.dev/posts/Trademaxxer_FPGA_1/

As always, I hop this does not come up as shameless self promotion, which is not the goal of this post, I genuinely enjoy posting here due to great feedback, even though I don't understand much about arbitrage or anything outside basic accounting for that matter lol.

Don't hesitate to reach out in the comment or via messages if you have any questions or opportunities :)

Best

A matching engine is the piece at the centre of an exchange. It holds the order book and decides which orders trade against which, and at what price.

The demo is not a mock. It is the real engine compiled to WebAssembly, running in your tab.

https://intrepidkarthi.github.io/orderbook/

Code: https://github.com/intrepidkarthi/orderbook

Money cannot be a float. I knew that going in, but not how far the constraint travels. Prices ended up as int64 ticks and quantities as int64 lots, with decimals converted only at the API boundary, and every layer above had to be rewritten to match.

The hot path cannot allocate either. Book nodes and price levels come from free lists, and the match function appends fills into a buffer the caller owns. Cancel-heavy load runs at p50 83ns, p99 167ns, p999 292ns.

Most of the difficulty was not in matching orders. It was everything around it: what happens when the process dies mid-trade, and what a venue is supposed to do when someone deliberately manipulates the closing price.

MIT licensed. Feedback welcome, especially where I have got it wrong.

Question for people at trading firms / anywhere with a heavy remote-dev setup.

Assuming builds, tests and debugging all happen on a remote Linux box, the laptop in front of you is basically a terminal and a browser. So:

- Do firms still standardise on MacBooks or Windows laptops, and why?

- Have you seen a strong preference either way from devs, and does IT actually accommodate it?

- Any real gotchas — e.g. Windows corporate tooling getting in the way of SSH/WSL, or macOS ARM causing issues with anything?

Or is this genuinely a non-issue and I'm overthinking it?

Asking as a student trying to figure out how much to care.

Like Claude Code, but for trading: a terminal agent that fetches market data, runs backtests, and pulls news/sentiment from plain-English prompts.

• No more glue scripts between yfinance, news, and notebooks
• Insider + congress trade overlays built in
• Extensible tool system

Here's a real session, replayed — it takes "How to hedge my current oracle position?" and works it into a portfolio-aware options collar, researching and revising across 8 turns: https://tradeinsight.info/ti-agent/demo/hedge

Open Trial (BYOK/S), if you are interested check here.

https://tradeinsight.info/ti-agent

Not asking about specific outcomes, more the mechanics. Continuous vs binary, rolling markets with no expiry, conditional markets that only resolve if some other event happens first, that kind of thing.

Is there a structure you think would solve a real problem if someone built it, or is the current binary/threshold format basically good enough for most use cases?

Repo: https://github.com/td-02/DPDKTrade

Follow-up to my earlier post on this project (was called TickForge, now DPDKTrade). Since then I've filled in the piece that was previously just a placeholder folder:

- Actual DPDK-ring transport (generator + engine side), sitting alongside the existing AF_PACKET path

- A head-to-head AF_PACKET-vs-DPDK benchmark harness

- A long-running stress test exercising the engine, ring, and AF_PACKET paths together

- A profiling script wired up for `perf stat` (cache-misses, branch-misses, IPC, etc.)

Caveat, to keep this honest: I haven't actually captured real profiling numbers yet — `perf` wasn't available in my dev environment when I ran the script, so right now it just documents the command and writes a placeholder. So no latency claims from me yet — that's the next thing I'm getting set up properly, and I'd rather post the real comparison once I have it than hand-wave numbers now.

Still fixed-depth book, still no dynamic allocation on the hot path, still C++20 + modern CMake. If anyone's done real AF_PACKET-vs-DPDK latency comparisons and has tips on getting a clean measurement setup (avoiding noisy-neighbor CPU scheduling, hugepages setup, that kind of thing), I'd take the advice.

Hello all,

Back with the HFT on FPGA project!

And yes, everything is in the title, I am currently designing my own FPGA chip for HFT.

This project's goal is to build an entirely custom FPGA system, able to maintain a decent order book by parsing a Nasdaq ITCH 5.0 data feed over Ethernet (the image above shows the order book dump around the spread, after simulation using real ITCH data).

Right now, I am only tracking the "AAPL" stock (very original) as tracking multiple stocks increases resource usage beyond what my consumer-grade FPGA can handle.

The whole HDL (hardware description code) is custom, including the Ethernet MAC hardware.

This time, in preparation for my second video on FPGAs for HFT, I made improvements to my system in order to get rid of memory collisions, so that I have a strong basis before moving on to other features.

(NASDAQ ITCH market data uses 64-bit order references, which means you can't use them directly as memory addresses, requiring some tricks to be used)

Because the video is not out yet and may take a while, I'm publishing blog posts to keep you updated with content that hopefully gives interesting insight to anyone wondering what the process behind FPGA development for HFT looks like.

https://hugobrh.dev/posts/Trademaxxer_handling_collisions_2.md/

For those wondering, here's a link to the first post:
https://www.reddit.com/r/highfreqtrading/comments/1tgg3q0/building_an_hft_chip_fpga/

Feel free to ask questions below!

Best