This repository holds a modular, research-grade quantitative backtesting engine designed for scalable hypothesis testing, deterministic execution modelling, and extensible strategy development. I built this project as part of an ongoing quantitative research initiative focused on clean architecture, reproducible research, and production-ready system design.
Modern quantitative research demands:
- Deterministic execution modelling
- Clear separation of signal logic and execution logic
- O(N) computational efficiency
- Modular extensibility
- Transparent assumptions
- Reproducibility
I built this framework to support 100+ independent hypotheses within a scalable object-oriented architecture. It is not a toy backtester - it is a structured research engine.
The system follows principles inspired by:
- Object-Oriented Programming (OOP)
- Domain-Driven Design (DDD)
- MVC separation of concerns
- Modular strategy injection via Protocol interface
- Deterministic modelling to avoid look-ahead bias
- No iterrows()
- No DataFrame concatenation inside loops
- O(N) time complexity
- Precomputed indicators
- Strict bracket order modelling
- Clean separation between:
- Signal generation
- Execution modelling
- Performance analytics
┌──────────────────────────────────────┐
│ Strategy layer (EntryTrigger) │
│ - SMACrossover │
│ - SMA + RSI │
│ - (100+ WIP hypotheses) │
└──────────────────┬───────────────────┘
|
▼
┌──────────────────────────────────────┐
│ BracketBacktester (execution engine) │
│ - Deterministic SL │
│ - Deterministic TP │
│ - Long/short logic │
│ - O(N) evaluation │
└──────────────────┬───────────────────┘
│
▼
┌──────────────────────────────────────┐
│ PerformanceReport (analytics engine) │
│ - CAGR │
│ - Sharpe │
│ - Max drawdown │
│ - Profit factor │
│ - Holding period │
│ - 30+ metrics (WIP) │
└──────────────────────────────────────┘
The execution engine (see backtester.py) follows strict deterministic assumptions:
- Signal generated at bar close.
- Entry occurs at the close of the signal bar.
- Stop-loss and take-profit set immediately.
- Exit evaluation begins from the next candle.
- If price action hits both SL and TP in the same candle, then SL is assumed first.
The above logic avoids:
- Intrabar look-ahead bias
- Unrealistic fill assumptions
- Optimistic execution modelling
Strategies implement the EntryTrigger Protocol:
class EntryTrigger(Protocol):
def prepare(self, data: pd.DataFrame) -> None: ...
def should_enter(self, index: int) -> Tuple[bool, str, str]: ...
Examples included:
- SMA crossover (see sma_crossover.py)
- SMA + RSI filter (see sma_rsi_trigger.py)
This engine allows scaling to:
- 100+ independent hypotheses
- Regime filters
- Multi-indicator composites
- Volatility filters
- Market structure filters
- Machine learning-driven signals
The analytics module (performance) computes:
- CAGR
- Sharpe Ratio
- Max Drawdown
- Profit Factor
- Number of Trades
- Average Holding Period
The analytics layer is intentionally separated from execution logic to support:
- Alternative return aggregation methods
- Portfolio-level analysis
- Multi-asset aggregation
- Walk-forward testing
from backtester import BracketBacktester
from sma_crossover import SMACrossoverTrigger
trigger = SMACrossoverTrigger(fast_window=5, slow_window=50)
BracketBacktester("AAPL").run(trigger)
See example runner: main.py
I intentionally designed this framework to scale:
- Unlimited hypothesis classes
- Clean injection interface
- Indicator precomputation per strategy
- Constant memory footprint
- Numpy-based loop
- No row iteration overhead
- Multi-asset portfolio engine
- Concurrent strategy evaluation
- Cross-sectional signal ranking
- Factor library integration
- Walk-forward validation
- Parameter sweep optimisation
- Monte Carlo robustness testing
This system is structured to support:
- Trailing stop-loss
- Volatility-adjusted SL/TP
- Multiple take-profit targets
- Time-based exits
- Position sizing models (Kelly, volatility parity)
- Portfolio-level risk constraints
- Commission modelling
- Intrabar interpolation modelling
- Sortino ratio
- Calmar ratio
- Omega ratio
- Trade expectancy
- Equity curve resampling
- Bootstrap Sharpe confidence intervals
- Hyperparameter grid search
- Bayesian parameter optimisation
- Regime classification filters
- Feature engineering pipeline
- ORM integration for database storage
- REST API interface layer
- CLI interface
The system follows:
- Strong OOP design
- Strategy pattern via Protocol
- Separation of concerns
- Deterministic modelling
- Clean domain boundaries
- Reproducible research outputs
- Timestamped logs and dataset snapshots
It is intentionally structured to support migration toward:
- Full MVC architecture
- ORM-backed persistence layer
- Distributed compute execution
- Cloud-native deployment
- No slippage
- No commissions
- No partial fills
- Single position at a time
- Fully allocated capital per trade
- Deterministic exit ordering
This framework is part of an ongoing quantitative research initiative.
- Further research and publications: https://www.quantanalysis.org.uk/
- LinkedIn: https://www.linkedin.com/in/bciocoiu/
This software is provided for research and educational purposes only. It does not constitute financial advice.
This framework is released under the MIT License to encourage open research and systematic strategy development.
If you use, extend, or build upon this work in academic research, production systems, or derivative frameworks, citation of the original repository is appreciated:
- Bogdan Ciocoiu - Systematic Trading Research Engine: https://github.com/bogdan-ciocoiu/systematic-strategy-research-platform
- Further research publications and commentary: https://www.quantanalysis.org.uk/
- Professional profile: https://www.linkedin.com/in/bciocoiu/
This repository represents an evolving quantitative research engine built with scalability and production-grade architecture in mind. The objective is not simply to backtest strategies - but to build a structured, extensible research platform capable of supporting institutional-level systematic strategy development.