Module 0 — Orientation & Roadmap

Part I · Foundations (Fast Track) · Priority 🔭 Extension · Status: Draft v0.1 Prerequisites: none

Overview

This module is the control room for the whole curriculum. It does three things:

1. Maps the territory — the entire universe of algorithmic strategies compressed onto one page, organized the way Quantpedia organizes it: by holding period, asset class, and complexity.
2. Locates you on the map — an ML-pipeline builder running a live MT5 operation has a specific position: the curriculum’s center of gravity for you is Parts III–V, not the textbook order.
3. Installs the operating loop — the repeatable cycle you’ll run in every subsequent module: read → hypothesize → implement → validate honestly → paper-trade. If you already keep an experiment ledger (you do), this formalizes why it exists.

Read it once now, and again after finishing any Part — the map reads differently once you’ve walked some roads.

How to use this curriculum

Every module carries a priority tag calibrated against your working system (m1-trading-model):

The master syllabus defines four study paths; the recommended default for you is Path 1 (Extend the model zoo: M17 → M19 → M20 → M24). The Capability Map section there tells you which modules are new territory versus audit-and-extend — trust it over sequential reading order.

The Strategy Universe in One Map

Ask three questions about any strategy and you know where it lives:

1. How long does it hold? (ticks → years)
2. What does it trade? (one asset class or many?)
3. How is the decision made? (fixed rules → statistics → machine learning)

Figure: the strategy universe as a tree. Every module in Part III sits somewhere on this tree; every branch pays differently and dies differently.

flowchart TD
    root[Algorithmic strategies]

    root --> freq{Holding period?}
    freq -->|"seconds-minutes"| hft[HFT / scalping<br/>cost-dominated]
    freq -->|"hours-days"| intraday[Intraday / swing<br/>session-driven]
    freq -->|"weeks-months+"| pos[Position / systematic<br/>carry, trends, factors]

    root --> asset{Asset scope?}
    asset --> single[Single-asset directional<br/>FX, metals, indices, crypto]
    asset --> rel[Relative value<br/>pairs, baskets, cross-sectional]

    root --> brain{Decision engine?}
    brain --> rules[Deterministic rules<br/>breakouts, bands, seasonality]
    brain --> stat[Statistical models<br/>cointegration, HMM regimes]
    brain --> ml[Machine learning<br/>GBMs, nets, RL overlays]

    classDef decision fill:#fff4d6,stroke:#d6a300
    classDef process fill:#f3f3f3,stroke:#888
    classDef risk fill:#fde8e8,stroke:#c0392b

    class freq,asset,brain decision
    class root,intraday,pos,single,rel,rules,stat,ml process
    class hft risk

How to read this:

• The branches multiply: your R2 trend-breakout route is intraday × single-asset × hybrid rules+ML. Naming a strategy’s coordinates instantly tells you its cost profile, capacity, and main failure mode.
• The red node is deliberate: at seconds-to-minutes horizons, costs dominate signals (Module 7). Everything above the red node is progressively more forgiving.
• Relative value and directional strategies fail differently — direction dies in chop, relative value dies when the linkage breaks (Module 12).

The tree becomes practical as an inventory classifier — every system you run or ran gets coordinates:

# Classify any system into universe coordinates -> one inventory row.
def classify(name, holding, scope, engine, failure_mode):
    return {"name": name, "holding": holding, "scope": scope,
            "engine": engine, "failure_mode": failure_mode}

my_book = [
    classify("R2 trend-breakout", "intraday", "single-asset",
             "rules + ML meta", "regime shift / cost drift"),
    classify("retired RSI(2) fade", "intraday", "single-asset",
             "deterministic rules", "spread ate the edge at low TF"),
]

The eight families in one breath

Where Strategy Ideas Come From

Ideas are cheap; surviving validation is expensive — so source ideas where survival odds are highest.

Ranked sourcing channels for this curriculum:

1. Academic papers mined for implementability — the Quantpedia thesis: thousands of finance papers are published yearly; a minority contain complete, testable trading rules. Quantpedia’s screener indexes 900+ extracted strategies with rebalancing periods, markets, and source-paper links.
2. Factor databases as ground truth — Ken French’s data library and AQR’s datasets let you replicate published factor returns before trusting any implementation.
3. Practitioner blogs — QuantStart, QuantInsti, Robot Wealth, Alpha Architect: implementation detail papers skip (costs, fills, pitfalls).
4. Your own diagnostics — the least fashionable but highest-yield channel: SHAP surprises in your Meta model, a route that outperforms in unexpected sessions, spread patterns in your tick archive.

🧪 Evidence: Quantpedia’s research on post-publication decay found that strategy performance does decline after publication — but abnormal returns frequently persist for years afterward. Causes include limits to arbitrage (some players can’t trade it), slow capital inflows, and capacity constraints.

💡 Idea: The decay finding implies a positioning strategy for individual researchers: published-and-decayed is still tradable if costs are low and capacity is small — and unpublished corners (odd sessions, unpopular symbols, unglamorous timeframes) decay slowest because nobody bothered. You don’t need a secret; you need somewhere uncrowded.

Your Research Operating Loop

Every module in Parts III–IV rehearses the same loop. Internalize it once here:

Figure: the loop every strategy idea must survive. The exit at the bottom is earned, not assumed.

flowchart TD
    idea[Idea from literature<br/>or own diagnostics]
    hyp{Falsifiable<br/>hypothesis written?}
    sharpen[Sharpen: metric,<br/>expected effect, trade-off]

    idea --> hyp
    hyp -->|"no: vague idea"| sharpen
    sharpen --> hyp
    hyp -->|"yes"| impl[Implement in pipeline<br/>behind config flag]
    impl --> val[Validate honestly:<br/>purged folds, real costs]
    val --> gate{Survives OOS<br/>and cost gate?}
    gate -->|"no"| autopsy[Autopsy: why?<br/>record in ledger]
    autopsy --> idea
    gate -->|"yes"| paper[Paper-trade on MT5 demo,<br/>compare vs backtest]
    paper --> live{Live tracks<br/>expectation?}
    live -->|"no"| drift[Drift forensics:<br/>parity? regime? costs?]
    drift --> idea
    live -->|"yes"| promote[Promote with<br/>sizing discipline]

    classDef decision fill:#fff4d6,stroke:#d6a300
    classDef process fill:#f3f3f3,stroke:#888
    classDef ok fill:#e6f4ea,stroke:#2e7d32

    class hyp,gate,live decision
    class idea,sharpen,impl,val,autopsy,paper,drift process
    class promote ok

How to read this:

• Most arrows point backward. Honest loops kill most ideas — that’s their job. A loop that promotes everything is a liability, not a pipeline.
• The two gates are independent: a backtest gate (statistics) and a live-tracking gate (operations). Passing one says nothing about the other (Module 24).
• Every rejection gets an autopsy record — dead ideas with documented causes are assets; they stop you re-running the same experiment next quarter.

The loop runs on paper. Before touching code, write a research card — four fields that make the idea falsifiable:

import json
from datetime import datetime, timezone

# One research card per experiment — appended BEFORE running anything.
card = {
    "id": "R042",
    "created_utc": datetime.now(timezone.utc).isoformat(),
    "hypothesis": ("XAUUSD M5 R2 candidates filtered to London-session "
                   "only raise net Sharpe vs all-hours baseline"),
    "target_metric": "net Sharpe on purged walk-forward OOS",
    "expected_tradeoff": "fewer trades -> wider confidence intervals",
    "integrity_guard": "session filter uses bar-open hour only; "
                       "no future-bar leakage",
    "status": "pre-registered",   # -> completed / rejected / infeasible
}
with open("experiment_ledger.jsonl", "a") as f:
    f.write(json.dumps(card) + "\n")

And the loop’s vital sign is read from that same file — a healthy research operation rejects far more than it promotes:

import json
from collections import Counter

rows = [json.loads(line) for line in open("experiment_ledger.jsonl")]
print(Counter(r["status"] for r in rows))
# Counter({'rejected': 27, 'completed': 11, 'pre-registered': 3})
# Healthy: rejections >> promotions. If reversed, your gates are loose.

📌 Convention: This mirrors the ledger discipline already running in your production repo — pre-registered hypotheses, recorded outcomes, holdouts consumed explicitly. The curriculum adopts it as house law: a holdout never ranks trials (Module 19 enforces this mechanically).

Reading This Curriculum Efficiently

Two structural facts save you time:

• Modules 4–6 (data, backtesting, measurement) are load-bearing. Every hands-on project in Parts III–IV assumes the artifacts built there: clean point-in-time data, an honest backtest harness, a tear-sheet generator. Do them before any strategy module.
• Strategy families are timeframe-portable, not timeframe-fixed. Learn momentum once in Module 10; its M30 and W1 personalities differ in parameters and pathology, not in core logic. Module 9 teaches the layering that combines them.

If you ever feel lost mid-module, the Curriculum Map shows which part feeds which, and the Suggested Study Paths give escape routes tuned to your gaps.

Hands-On Project

Deliverable: docs/research/strategy_inventory.md + one appended research card — your personal map annotations before the deep material begins.

Tasks:

1. Place every strategy/system you currently run (or have abandoned) into the universe tree: holding-period rung, asset scope, decision engine. Include the dead ones — they carry your tuition payments.
2. For each, write one sentence on its primary failure mode (costs? regime? linkage break? crowding?). Guessing is fine; precision comes later.
3. Choose your curriculum path from the master syllabus and write one paragraph justifying it against your Capability Map gaps.
4. Pre-register your first research card for the module you’ll start with (Path 1 default: the M17 model bake-off).

Acceptance criteria:

• Inventory covers ≥ 3 systems including ≥ 1 abandoned one.
• Each entry names a failure mode in plain language.
• Path choice quotes the Capability Map rows it targets.
• Research card has all six fields filled and status pre-registered.

Key Takeaways

• Any strategy is located by three coordinates — holding period, asset scope, decision engine — and those coordinates predict its cost profile and failure mode better than its name does.
• Ideas should come from channels with high survival odds: paper-derived rules with known economics, replicable factor data, practitioner implementation notes, and your own model diagnostics.
• Published edges decay but rarely die; uncrowded corners (odd sessions, unfashionable symbols) are where individual traders still find room.
• The operating loop — hypothesize, implement, validate, paper-trade, with autopsies on every death — is the real curriculum; the modules are its exercises.
• A holdout that ranks trials is spent; pre-registration and ledgers exist to keep it honest.

References

• Quantpedia — Classification of Quantitative Trading Strategies (Quantpedia × QuantInsti webinar notes; taxonomy axes, decay research, blind-spot thesis)
• Quantpedia — Strategy Screener (browse free entries to see well-documented strategy formats)
• Ernest Chan — Quantitative Trading, 2nd ed., ch. 1–3 (the researcher’s workflow, backtest discipline)
• Robert Carver — Systematic Trading, part A (framework-first thinking; positions over predictions)
• Marcos López de Prado — Advances in Financial Machine Learning, ch. 11–14 (backtest overfitting, deflated Sharpe, research governance)
• paperswithbacktest — awesome-systematic-trading (curated papers, libraries, books index)
• Next in sequence: Module 2 — Statistics Refresher