We develop AI scalping bots that analyze market microstructure in real time. Large players' algorithms use Level 2 order book data and microstructure signals to predict price movement a few ticks ahead. Without machine learning, you rely on intuition—but in an HFT environment, that doesn't work. We build solutions that process these signals and execute trades in milliseconds. We'll assess your project and offer a turnkey implementation, from prototype to production with monitoring.
The problem is that market data contains noise. Without proper feature engineering, the signal is lost, and trades execute at worse prices. That's why we focus on extracting features from Level 2 order book data: volume imbalance, aggressive order flow, microprice. These signals are unavailable to long-term strategies but provide an edge on a 1–10 tick horizon.
What Components Does an AI Scalping Bot Consist Of?
A scalping bot includes modules for data collection, feature engineering, prediction model, execution, and monitoring. We design each module considering latency budget and market specifics.
Microstructure Signals
Order Book Imbalance (OBI) — bid/ask volume imbalance. If bid volume is 5× larger, buying pressure is higher—likely upward movement. Formula: OBI = (bid_volume - ask_volume) / (bid_volume + ask_volume). ML improves the signal by weighting across order book levels.
Trade Flow Imbalance — difference between volume of buyer-initiated and seller-initiated trades. High imbalance indicates aggressive participants.
Queue Position and Order Flow Toxicity — assessing flow toxicity via VPIN (Volume-Synchronized Probability of Informed Trading) to predict adverse selection.
Microprice — weighted mid-price: microprice = (ask_vol * bid + bid_vol * ask) / (bid_vol + ask_vol). Deviation of trade price from microprice provides a short-term movement signal.
| Signal | Description | Feature Engineering | Prediction Horizon |
|---|---|---|---|
| OBI | Volume imbalance | Weighted by levels | 1–5 ticks |
| Trade Flow Imbalance | Aggressive order flow | Moving averages | 1–10 ticks |
| Microprice | Weighted mid-price | Deviation from price | 1–3 ticks |
How Does DeepLOB Predict Price Movement?
DeepLOB is a CNN + LSTM architecture that processes order book snapshots over the last N seconds. Convolutions extract spatial patterns, LSTM captures temporal dependencies. Output is three classes: up, down, or flat. Example implementation:
class DeepLOB(nn.Module): def __init__(self, depth=20, features=4): super().__init__() self.conv_layers = nn.Sequential( nn.Conv2d(1, 32, (1, 2), stride=(1, 2)), nn.LeakyReLU(0.01), nn.Conv2d(32, 32, (4, 1)), nn.LeakyReLU(0.01), nn.Conv2d(32, 32, (4, 1)), nn.LeakyReLU(0.01), ) self.lstm = nn.LSTM(32, 64, 2, batch_first=True, dropout=0.2) self.fc = nn.Linear(64, 3) def forward(self, x): # x: [batch, 100, depth*features] x = x.unsqueeze(1) conv_out = self.conv_layers(x) batch, _, h, w = conv_out.shape lstm_in = conv_out.permute(0, 2, 1, 3).reshape(batch, h, -1) lstm_out, _ = self.lstm(lstm_in) return self.fc(lstm_out[:, -1, :]) Models are trained on historical tick data with different horizons (1, 5, 10 ticks) and aggregated into an ensemble. We use PyTorch for training and ONNX Runtime for inference to reduce latency.
Why Is Latency Critical for Scalping?
Scalping requires a strict latency budget:
- Signal computation: <1 ms
- Order submission: <5 ms round-trip
- Full cycle: <10 ms
This requires co-location or proximity hosting, WebSocket feeds instead of REST (100× faster), and asynchronous code (asyncio). We optimize every stage—from data collection to order submission. For example, we design models so that inference fits within 100 µs on a GPU.
How to Assess Backtesting Quality?
Backtesting on tick data is the foundation for strategy validation. We use metrics: Sharpe ratio (>2.0), win rate (>55%), profit factor (>1.5). We always validate on out-of-sample data to avoid overfitting. In one project, we achieved a Sharpe of 3.1 on a 6-month test period, but only after adding a VPIN feature.
| Metric | Target | Comment |
|---|---|---|
| Sharpe ratio | >2.0 | After accounting for fees |
| Win rate | >55% | Minimum 1,000 trades |
| Profit factor | >1.5 | Ratio of profit to loss |
Risk Management in Scalping
Daily loss limit—stop if daily loss hits, so one bad session doesn't wipe out profits. Maximum position size—automatically close when inventory threshold is breached. Drawdown tracking with circuit breakers based on a rolling 5-day drawdown.
Typical beginner mistakes:
- Not accounting for fees: with 500 trades a day, fees can eat all profit.
- Overfitting the model to one market regime—strategy breaks after volatility changes.
- Ignoring latency: the signal arrives after the price has already moved.
Our Development Process
- Analytics — dissect market microstructure, collect tick data.
- Prototyping — create a baseline model and backtest.
- Optimization — reduce latency, improve fill rate.
- Production — deploy on co-located servers, integrate with the exchange.
- Monitoring — continuous model evaluation, P&L alerts.
What's Included in the Work
- Documentation of model architecture and trading API.
- Real-time monitoring dashboard.
- Training for your team (code, metrics, alerts).
- Quality assurance: stress tests and validation on out-of-sample data.
Our team has over 5 years of HFT development experience and dozens of ML model projects on real markets. Contact us to assess your project—we'll provide a turnkey solution. Get a consultation on latency optimization and microstructure strategies. We guarantee transparency: you receive not a black box, but interpretable signals and full documentation.
Basics of market microstructure are described on Wikipedia.