01 — Professional Profile

WHO I AM

14 years of trading experience, engineering robust systems for automated execution.

A full-time trader turned automation developer — I design and build the software that executes my own trading strategies on MetaTrader 5, so decisions are consistent, risk is controlled by code, and nothing depends on being at the screen 24/5.

14+

Years trading experience

19,250+

Lines of production Python

19

Core system modules

What I bring to a project

Trader's perspective: years of screen time in gold, BTC and EUR/USD inform every rule I automate — I know what a strategy needs to survive live conditions, not just a backtest.
Advanced Python engineering: production-grade, config-driven, defensive code — built to keep running safely when markets, brokers or connections misbehave.
End-to-end ownership: from strategy research and signal logic through backtesting, optimization, risk validation, desktop UI and live execution.
Risk-first mindset: every automated decision passes through explicit position sizing, exposure limits and circuit breakers before an order is ever sent.

02 — Core Technical Skills

STACK & CAPABILITIES

Core Technical Skills

The building blocks behind every strategy I automate — from raw market data to a monitored, risk-managed live position.

01 / LANGUAGE

Python (Advanced)

Core language for the entire platform — signal logic, execution, analytics, UI and research tooling in one cohesive codebase.

02 / BROKER LAYER

MetaTrader 5 (Python API)

Live order placement, partial closes, break-even and trailing management directly against the MT5 terminal.

03 / ALGORITHMIC TRADING

Multi-Strategy Systems

Five independent, pluggable strategies fused through a weighted multi-timeframe decision engine.

04 / DATA & ANALYSIS

Pandas · NumPy

Multi-timeframe indicator builds — EMA, RSI, ATR, ADX, VWAP, structure and breakout-of-structure detection.

05 / VALIDATION

Backtesting & Optimization

Bar-by-bar MTF backtester, parallelized grid-search optimizer, and Monte Carlo risk simulation before any strategy goes live.

06 / RISK MANAGEMENT

Position Sizing & Circuit Breakers

Risk-percent based lot sizing, asset-class-aware risk tuning, and daily loss circuit breakers.

07 / DESKTOP UI

PyQt5 Applications

Live desktop dashboards with multi-symbol chart rotation, licensing and broker switching.

08 / AUTOMATION & API

Telegram Bot API

Human-in-the-loop approval workflows, inline signal cards, and automated performance reporting.

03 — Technical Expertise

CAPABILITIES IN DEPTH

What I actually build

Five capability areas, drawn directly from a real, running system — not a checklist of buzzwords.

A

Trading Intelligence

Independent strategy modules combined through weighted multi-timeframe voting; automatic support/resistance zone detection with touch-count scoring; breakout and liquidity sweep-and-reclaim detection; a sideways-market filter that suppresses low-quality signals in range-bound conditions — plus a human-readable narrative generated alongside every decision, for auditability.

B

Execution & Risk Management

Risk-percent position sizing from live account balance, tick value and stop-loss distance; asset-class-aware risk tuning across metals, crypto and FX; break-even shifting, partial close, ATR trailing stops and pending-order expiry management; a daily loss circuit breaker and spread-quality filter ahead of every order.

C

Human-in-the-Loop Control

Rich, formatted Telegram signal cards with inline Approve/Reject buttons and live callback processing; a pending-signal store with expiry, execution tracking and duplicate-signal suppression; automated hourly, daily, weekly and monthly PnL and win-rate reports.

D

Desktop Application & Visualization

A PyQt5 dashboard with live multi-symbol chart auto-rotation, broker switching and license enforcement; Matplotlib-rendered multi-timeframe chart images with S/R overlays and signal-arrow history, shared directly to Telegram; an in-app notification centre and backtest pause/resume workflow.

E

Platform Safeguards

Live economic-calendar integration with pre/post-news trade blocking and automatic pre-news position close; cloud-synced settings with HWID-based licensing, remote configuration push/merge and live hot-reload.

04 — Featured Project

FLAGSHIP BUILD

Trader2Algo

A self-built, production-grade algorithmic trading system for MetaTrader 5 — rule-based strategies, a custom AI decision layer, and human-in-the-loop approval via Telegram, running live as a desktop application.

Objective

Replace manual chart-watching with a disciplined, always-on system that evaluates multiple strategies across timeframes, applies consistent risk rules, and either executes automatically or waits for a one-tap approval — without losing the trader's final say.

Technology Used

Python 3MetaTrader5 APIPyQt5 pandas / NumPyMatplotlibTelegram Bot API

Key Capabilities

Signal & decision engine — five strategies fused by a weighted multi-timeframe AI layer.
Human-in-the-loop execution — Telegram approval workflow with inline buttons.
Live desktop dashboard — PyQt5 UI with chart rotation and broker switching.
Risk & compliance — per-trade sizing, daily loss limits, spread filters, news blackout system.
Offline validation pipeline — MTF backtesting, parallel optimization, Monte Carlo simulation.

Trading / Automation Logic

The system streams live price data across multiple timeframes and evaluates several independent strategies in parallel. A weighted, multi-timeframe decision engine (local_ai.py) fuses those signals with support/resistance context, trend structure and volatility filters into one final decision — complete with a human-readable narrative explaining the reasoning. Trades are either executed automatically or routed to Telegram for manual approval; approved signals are re-validated and executed with freshly recalculated ATR-based stop-loss / take-profit levels and risk-based position sizing.

Trader2Algo — Risk, Testing & Scale

Risk Management

Risk-percent position sizing from live balance, tick value and SL distance.
Asset-class-aware risk tuning — separate profiles for metals, crypto and FX.
Break-even shift, partial close, ATR trailing stop, pending-order expiry.
Daily loss circuit breaker and spread-quality filter before every order.

Testing / Optimization

Bar-by-bar multi-timeframe backtester using the exact live strategy code path.
Parallelized grid-search optimizer scored on profit, win rate and drawdown.
Monte Carlo bootstrap resampling for risk-of-ruin and drawdown tail risk.
PASS / WARNING / FAIL gate before any configuration reaches live capital.

Validation & Reporting Metrics Tracked

The system's analytics and Monte Carlo engines compute the following on every strategy configuration before — and continuously after — deployment:

Win RateProfit FactorMax Drawdown (money & %) Risk-of-Ruin %Equity CurvePer-Symbol Stats Daily / Weekly / Monthly PnL

19,250+

lines of Python across 19 core modules — spanning broker connectivity, order execution, a licensing / cloud-settings system, an economic-news filter, and a full offline backtesting, optimization and Monte Carlo risk-validation pipeline.

05 — Trading System Architecture

SIGNAL PATH

From market data to a managed live trade

Each stage lives in its own isolated module, so strategies, execution logic and UI evolve independently.

STEP 01

Market Data

multi_tf.py · indicators.py

STEP 02

Strategy Layer

signals.py

STEP 03

Signal / AI Fusion

local_ai.py

STEP 04

Risk Management

risk.py

STEP 05

Trade Execution

trading.py · Telegram

STEP 06

Monitoring

performance.py

Layer	Module(s)	Responsibility
Orchestration	main.py	Bot lifecycle: settings sync, daily-loss circuit breaker, position tracking, main run loop.
Signal Generation	signals.py	Five independent strategies plus candle-pattern and multi-timeframe aggregation.
AI Decision Layer	local_ai.py	Weighted MTF scoring, S/R zone cache, breakout / sweep detection, SL/TP engine.
Multi-Timeframe Data	multi_tf.py, indicators.py	Per-timeframe indicator builds: EMA / RSI / ATR / ADX / VWAP / BOS / trend detection.
Execution	trading.py, approved_signals.py, risk.py	Order placement, position management, risk-based lot sizing.
Approval / Notifications	telegram_notify.py	Signal cards, inline approval workflow, PnL & performance reports.
Visualization	mtf_chart_image.py, dashboard.py	Chart rendering with S/R & signal overlays; live PyQt5 desktop UI.
Market Safeguards	news_filter.py	Economic calendar ingestion and news-driven trade blocking.
Analytics	performance.py, system_utils.py	Daily / weekly / monthly PnL, win rate, profit factor, per-symbol stats.
Research & Validation	backtest_engine.py, run_optimization_mtf.py, monte_carlo_engine.py	Historical MTF backtesting, parallel parameter optimization, Monte Carlo risk simulation.

06 — Backtesting & Optimization

RESEARCH PIPELINE

Nothing goes live without proving itself first

A three-stage offline pipeline mirrors the exact strategy and trade-management logic used in production, so results are directly comparable to live behaviour.

01 · Multi-Timeframe Backtest Engine

backtest_engine.py

Replays historical M5 / M15 / H1 / H4 data bar-by-bar, reconstructing the exact multi-timeframe inputs the live strategy functions consume — so the same strategy code path runs in both backtest and production.

Full trade lifecycle simulation: ATR SL/TP, partial close, break-even, trailing stop.
Risk-based position sizing with min/max lot clamping.
Daily risk controls: max trades/day, cooldown, loss-limit breaker.
Win rate, profit, max drawdown from the resulting equity curve.

02 · Parallel Strategy Optimizer

run_optimization_mtf.py

Grid search across strategy-specific parameters combined with shared risk / trade-management parameters, scoring every combination with one composite metric.

Combinatorial parameter grid across each strategy's own tunable inputs.
Multiprocessing across all CPU cores via ProcessPoolExecutor.
Composite score: profit×2 + win_rate×5 − drawdown×10.
Live progress / log callbacks, optional Telegram delivery of results.

03 · Monte Carlo Risk Engine

monte_carlo_engine.py

Stress-tests a chosen configuration by resampling the historical trade sequence thousands of times, rather than trusting a single equity curve.

Bootstrap resampling of the real trade-profit distribution.
Slippage, commission, profit-noise and missed-trade stress factors.
5th / 10th / 90th / 95th / 99th percentile risk statistics.
Composite risk score with a PASS / WARNING / FAIL gate before going live.

07 — Strategies & Development Process

STRATEGY LIBRARY

Trading Strategies Implemented

Strategy	How it works
Trend Pullback	Enters in the direction of the higher-timeframe trend after a pullback to EMA / structure, confirmed on a lower timeframe.
Breakout	Detects structural breakouts (BOS) with confirmation candles and momentum filters, single-TF and multi-TF variants.
Liquidity Sweep	Identifies stop-hunt wicks beyond a swing high/low followed by a reclaim back inside range.
Mean Reversion	Fades short-term extremes back toward VWAP / Bollinger mid-band in range conditions.
AI5 Multi-TF High/Low	Cross-timeframe extremes model scoring setups against recent high/low structure across the configured timeframe stack.
Smart Money (SMC) Confluence	Optional fair-value-gap / swing-structure module layered in as an additional confirmation input.

HOW I WORK

Development Process

Every strategy earns its way to live capital through the same disciplined sequence.

01

Research & Strategy Design

02

Development

03

MTF Backtesting

04

Parallel Optimization

05

Monte Carlo Risk Validation

06

Live Deployment

07

Monitoring & Reporting

Before deployment, every strategy configuration passes through the backtest → optimize → Monte Carlo pipeline: the backtester proves the logic on real historical data using the identical strategy functions as production; the optimizer searches the parameter space in parallel across all CPU cores; and the Monte Carlo engine bootstrap-resamples the resulting trade sequence thousands of times to quantify risk of ruin and drawdown tail risk — before a single live order is placed. In production, nearly every threshold (risk %, expiry windows, zone counts, news buffers) is resolved through a live, file-watched settings cache, so the running system can be reconfigured without a restart, while every execution path still falls back to safe local defaults if that sync is unavailable.

08 — Why Work With Me

WHAT THAT MEANS FOR A CLIENT

Why Work With Me

This portfolio isn't a demo — it's a description of a real, running system. That's the standard I bring to every engagement.

Trader-grade reliability

Daily loss circuit breakers, spread-quality filters and news blackout windows are built in by default — risk controls are not an afterthought.

Automation expertise

A 19,250+ line, 19-module production codebase — from broker connectivity and order execution to licensing and cloud-config, built and iterated as one cohesive system.

Testing discipline

Every strategy passes through backtesting, parallel optimization and Monte Carlo risk simulation — with a PASS/WARNING/FAIL gate — before it ever touches live capital.

Professional development practices

Config-driven, defensive architecture with safe local fallbacks; two-stage trade execution that re-validates live prices before an approved signal is ever sent.

14 yrs

of hands-on trading in gold, BTC and EUR/USD sit behind every rule this system automates — the code reflects real market experience, not just an engineering exercise.

ALGORITHMIC TRADING

14 years of trading experience, engineering robust systems for automated execution.

Core Technical Skills

What I actually build

Trader2Algo

Trader2Algo — Risk, Testing & Scale

From market data to a managed live trade

Nothing goes live without proving itself first

Trading Strategies Implemented

Development Process

Why Work With Me

Let’s turn your trading ideas into reliable, intelligent automation.

ALGORITHMIC
TRADING