Trading bot development

Project Overview

We are building a high-performance, low-latency trading engine designed for microstructure-based execution strategies in a high-tax (STT) environment.

This is NOT a basic retail trading bot.

This system requires advanced system-level engineering, multi-core CPU architecture control, shared memory communication, and real-time observability dashboard.

The focus of this project is minimizing latency between signal generation and order execution while maintaining regulatory compliance (Order-to-Trade Ratio constraints).

The developer must understand low-level performance optimization, concurrency architecture, and Linux system behavior.

Core Technical Requirements Python Version (Mandatory)

The engine must use:

Python 3.13 Free-Threaded build (3.13t)

NOT standard Python 3.10–3.12

Reason: Standard Python uses the Global Interpreter Lock (GIL), which blocks true parallelism. In low-latency systems, a 1–2ms delay caused by GIL contention is unacceptable.

Multi-Core Architecture with CPU Core Pinning

The engine must:

Assign specific modules to specific CPU cores

Use os.sched_setaffinity (Linux only)

Prevent OS core migration (avoid context switching)

Modules include:

Sentinel (Risk & OTR monitoring)

Sonar (Market entropy / regime detection)

Oracle (Signal calculation loop)

Execution Engine (Order placement)

The goal is to eliminate unpredictable latency spikes caused by OS scheduling and cache invalidation.

Inter-Process Communication

Standard Python queues are NOT acceptable.

Communication must use:

multiprocessing.shared_memory

Memory-mapped buffers

Lock-free ring buffer architecture

Reason: Standard queues introduce locking and object allocation overhead, increasing latency.

The target is sub-millisecond internal communication between signal generator and execution engine.

Latency Measurement

The system must measure:

End-to-end order placement latency

Round-trip time (RTT)

Module processing time

Using:

time.perf_counter_ns()

Latency histogram logging

This data must be streamed to the dashboard.

Order Execution Logic

The system should:

Prefer passive limit orders

Include 200ms cancel logic

Manage Order-to-Trade Ratio (OTR)

Implement controlled order flooding logic (compliant with broker rules)

This is not a simple market order bot.

FRONTEND REQUIREMENTS (React Dashboard)

The frontend is NOT a trading UI.

It is a real-time monitoring and control cockpit.

Preferred stack:

React (Vite or Next.js)

WebSocket for live streaming

Lightweight charting (Canvas or WebGL-based)

Required Dashboard Modules Sentinel Panel

Real-time RTT graph

20ms lockdown threshold indicator

CPU usage per pinned core

Emergency status

Sonar Panel

Market regime indicator (Attack / Veto mode)

Entropy score display

Zero-trust gate status

Oracle Panel

Weighted Order Book Imbalance (WOBI) heatmap

Liquidity imbalance %

Signal strength score

Must use high-performance rendering (Canvas, not heavy SVG).

Execution Panel

Net Expected Value (NEV)

Fill rate %

Cancel rate

Order-to-Trade Ratio (OTR) status

Emergency Kill Switch

Dashboard must include:

Global kill switch

Sends signal to monitoring service

Monitoring service writes flag to shared memory

Engine halts immediately

Dashboard must NOT communicate directly with broker API.

Deployment Requirements

Linux-based environment (Ubuntu preferred)

Dockerized setup preferred

Separate processes:

Trading engine

Monitoring microservice

React frontend

Google Cloud compatible.

10 MOST IMPORTANT SKILLS TO ADD

Attach these skills on Freelancer:

Python 3 (Advanced Concurrency & Multiprocessing) Must understand GIL, free-threaded builds, shared memory.

Low-Latency System Design Experience reducing microsecond-level bottlenecks.

Linux System Programming Knowledge of CPU affinity, process scheduling, performance tuning.

Multithreading & Multiprocessing Architecture Deg multi-core optimized applications.

Memory Management & Shared Memory IPC Experience with mmap, shared memory buffers.

Financial Market Microstructure Knowledge Understanding order books, liquidity imbalance, passive vs aggressive orders.

WebSocket & Real-Time Streaming Required for live dashboard data.

React.js (Performance-Optimized UI) Real-time data rendering without UI lag.

Performance Profiling & Benchmarking Must measure and optimize latency.

Cloud Deployment (Google Cloud / Linux VM / Docker) Production-ready deployment experience.

VERY IMPORTANT

Add this to filter weak developers:

Applicants must answer the following:

Have you worked with Python shared memory or mmap before?

Have you implemented CPU core pinning on Linux?

How would you measure internal engine latency?

How would you prevent dashboard from affecting trading engine performance?

This will eliminate 80% of generic bot developers.

Budget: USD 350 (Fixed Price)

Proposals: 10 freelancers have applied