My Portfolio
Research, Trading Systems, and Low-Latency Market Infrastructure
I build quantitative trading systems that sit at the intersection of market microstructure, machine learning, statistical research, and high-performance execution infrastructure.
My work focuses on transforming trading ideas into production-grade systems: from signal research and backtesting, to execution, risk management, monitoring, and live deployment.
The projects below represent my current work across graph-based alpha research, event-driven backtesting, low-latency execution, financial visualization, trade analytics, and multi-account trade management.
Featured Projects
Global Network Momentum Trading Strategy
A production-grade implementation of the Network Momentum strategy, designed to capture momentum spillovers across global assets using graph-based learning.
Instead of treating assets as isolated return streams, the system models markets as a dynamic network where information, momentum, and structural relationships propagate across nodes.
The strategy constructs adaptive asset networks using convex optimization, applies graph signal processing to propagate signals, and generates long/short portfolios through cross-sectional regression.
The full research pipeline includes walk-forward validation, hyperparameter optimization, parallelized computation, and strict no-lookahead controls for realistic strategy evaluation.
Core components
| Area | Implementation |
|---|---|
| Network construction | Dynamic asset graphs built from cross-asset relationships |
| Signal propagation | Graph signal processing over financial networks |
| Portfolio generation | Long/short cross-sectional regression |
| Validation | Walk-forward testing with no-lookahead bias |
| Scalability | Parallelized research and optimization pipeline |
Skills: Machine Learning, Statistical Research, Quantitative Finance, Python
PyCharting
A high-performance financial charting library built for fast, interactive visualization of large-scale OHLC datasets.
PyCharting is designed for quantitative researchers who need to explore millions of price points, technical indicators, and trade signals without relying on slow plotting workflows.
The system uses a FastAPI backend and a lightweight browser-based frontend to stream large financial datasets efficiently. It supports real-time interaction, zooming, overlays, multi-panel indicators, and trade signal visualization.
The goal is simple: make financial data exploration feel instant, scalable, and research-friendly.
Core components
| Area | Implementation |
|---|---|
| Backend | FastAPI data server |
| Frontend | Browser-based lightweight charting interface |
| Data support | Large-scale OHLC visualization |
| Research tools | Overlays, indicators, signals, multi-panel charts |
| Use case | Fast visual inspection of high-frequency financial data |
Skills: Python, FastAPI, Financial Visualization, Research Tooling
GitHub: alihaskar/pycharting
Low-Latency Event-Driven Backtesting & Execution Engine
A high-performance event-driven backtesting and execution engine designed around point-in-time correctness, realistic simulation, and production-grade architecture.
The engine is built to eliminate lookahead bias by treating every market update, corporate action, order event, fill, and portfolio update as part of a deterministic event stream.
It supports multi-asset strategies, corporate actions as real-time events, advanced order execution modeling, portfolio accounting, OMS/EMS components, and multi-timeframe strategy logic.
The goal is to bridge the gap between research and production: the same architecture used to test a strategy should be capable of supporting live deployment.
Core components
| Area | Implementation |
|---|---|
| Backtesting model | Event-driven, point-in-time simulation |
| Market data | Multi-asset support with corporate actions as events |
| Execution | Advanced order and fill modeling |
| Architecture | OMS, EMS, portfolio accounting, strategy layer |
| Strategy support | Multi-timeframe logic and scalable research workflows |
Skills: Python, High-Frequency Trading, Backtesting, Execution Systems
HFT FX Arbitrage Engine
A low-latency FX arbitrage system designed to detect and act on cross-venue price dislocations across multiple liquidity sources.
The system was built around hot-path optimization, shared memory architecture, zero-copy data access, lock-free ring buffers, CPU core pinning, and C/Python bindings for deterministic performance.
It includes latency tracking across transport, buffer, and processing layers, allowing the system to measure where every microsecond is spent.
The architecture is designed for high-throughput tick ingestion, real-time state management, and ultra-fast arbitrage detection across 16 venues.
Core components
| Area | Implementation |
|---|---|
| Venue coverage | 16 FX venues |
| Data transport | Shared memory and memory-mapped access |
| Processing | Lock-free ring buffers and hot-path optimization |
| Latency | Sub-20µs tick-to-trade target with full latency tracking |
| Throughput | Designed for 200M+ market events per day |
Skills: Python, Rust, C/Python Bindings, Low-Latency Systems, FX Microstructure
Trade Geometry Signal Analyzer
A quantitative diagnostic engine for understanding what happens after a trading signal fires.
Most trading research focuses on entry signals. This project focuses on the geometry of the trade after entry: how price moves, how quickly it reaches favorable or adverse levels, and how different exit rules behave across regimes.
The system analyzes maximum favorable excursion, maximum adverse excursion, time sequencing, TP/SL probabilities, volatility regimes, and trade archetypes.
This allows exit design to become more data-driven and less dependent on brute-force parameter optimization.
Core components
| Area | Implementation |
|---|---|
| Trade path analytics | MFE, MAE, time-to-target, path sequencing |
| Exit research | Probabilistic TP/SL outcome analysis |
| Risk design | Risk/reward frontiers and adverse excursion diagnostics |
| Regime analysis | Volatility-based behavior segmentation |
| Clustering | Trade archetype discovery |
Skills: Quantitative Research, Python, Risk Management, Trade Analytics
GitHub: alihaskar/signal_analyzer
MT4/MT5 TradeManager
A distributed trade replication and risk management system designed to synchronize trades across multiple master and slave accounts in real time.
The system integrates WebSocket-based event ingestion, REST-based execution, Redis state management, PostgreSQL persistence, reconciliation logic, and real-time monitoring.
It was designed for production-grade multi-account execution workflows where reliability matters more than cosmetic dashboards.
The system includes discrepancy detection, risk controls, fault-tolerant execution, account synchronization, and monitoring through Dash and Grafana.
Core components
| Area | Implementation |
|---|---|
| Trade ingestion | WebSocket-based event flow |
| Execution | REST-based order routing |
| State management | Redis and PostgreSQL |
| Reliability | Reconciliation, discrepancy correction, fault tolerance |
| Monitoring | Dash GUI and Grafana dashboards |
Skills: Python, Redis, PostgreSQL, WebSockets, MT4/MT5, Trade Replication
What Connects These Projects
Across all of these systems, the focus is the same:
Build trading infrastructure that is fast, realistic, measurable, and production-ready.
The common principles are:
| Principle | Meaning |
|---|---|
| Point-in-time correctness | No hidden lookahead bias or unrealistic assumptions |
| Execution realism | Model trading as it happens in live markets |
| Latency awareness | Measure and optimize the full path from data to decision |
| Research scalability | Make large experiments repeatable and parallelizable |
| Production discipline | Treat monitoring, reconciliation, and risk as core system components |
| Market structure awareness | Build around how markets actually behave, not how they look in clean datasets |
Areas of Focus
My current work is concentrated around:
| Domain | Focus |
|---|---|
| Quantitative Research | Alpha discovery, statistical validation, cross-asset modeling |
| Market Microstructure | Order flow, arbitrage, liquidity, execution behavior |
| Machine Learning | Feature engineering, graph learning, cross-sectional modeling |
| Backtesting Infrastructure | Event-driven simulation, PIT correctness, realistic execution |
| Low-Latency Systems | Shared memory, lock-free design, hot-path optimization |
| Trading Operations | OMS/EMS, reconciliation, monitoring, risk controls |
I build systems for the full lifecycle of quantitative trading: research, validation, execution, monitoring, and scaling.
The objective is not just to find signals.
The objective is to build infrastructure where signals can survive contact with real markets.