git:20260901.c415df0 to git:20260901.85fc79b

---

name: ml4t-strategy-workflow

description: "End-to-end strategy development lifecycle from hypothesis to live trading. Use when starting a new strategy project or onboarding to the ML4T workflow."

when_to_use: "Use when starting a new strategy or auditing an existing development process for missing stages"

dependencies: [fetch-data, compute-features, run-backtest, transaction-costs]

metadata:

book_chapters: "1, 6, 16, 20"

library: "ml4t-backtest"

---

# Strategy Development Workflow

Strategies fail because developers skip straight to modeling. The correct process spends most time on hypothesis and data, with modeling as a small fraction.

## The Problem

A researcher downloads data, fits a model, runs a backtest, and sees a 2.5

Sharpe ratio. They deploy, then lose money because there was no documented

hypothesis, no feature validation, no cost model, and no holdout.

## The Pattern

### WRONG

```python

# Jump straight to modeling - no hypothesis, no validation gates

import lightgbm as lgb

data = load_data()

features = data[["momentum", "volatility", "volume"]]

labels = data["next_day_return"]

model = lgb.LGBMRegressor().fit(features, labels)

predictions = model.predict(features) # Predicting on training data!

# "Looks great, ship it"

print(f"R2: {r2_score(labels, predictions):.3f}") # 0.95 - overfitting

```

### CORRECT

```python

# Seven stages with quality gates between each

hypothesis = {

"mechanism": "Momentum persists due to slow institutional rebalancing",

"signal": "12-month risk-adjusted return predicts 1-month forward return",

"kill_criteria": "IC < 0.02 or non-monotonic quintiles",

"capacity": "ETFs with >$50M daily volume",

}

# Commit term sheet to version control before proceeding

# Stage 2: Data → fetch + validate

# Stage 3: Features → compute + factor research

# Stage 4: Model → CPCV + model validation

# Stage 5: Backtest → realistic costs

# Stage 6: Paper trade → live data, simulated fills

# Stage 7: Live → small size, slow ramp

```

## Quality Gates

| Gate | Condition | Fail Action |

|------|-----------|-------------|

| Hypothesis | Documented mechanism, kill criteria, capacity estimate | Do not start coding |

| Data | No gaps > 2 days, point-in-time correct, survivorship-free | Fix data pipeline |

| Features | IC > 0.02 (HAC-adjusted), stable across subperiods | Drop factor or redesign |

| Model | PBO < 50%, deflated Sharpe significant | Simplify model or revisit features |

| Backtest | Sharpe > 0.5 net of costs, max DD < 20% | Revise sizing or cost assumptions |

| Paper trade | Fills within expected slippage, no execution anomalies | Fix execution logic |

## Guardrails

- If Sharpe > 2.0 on daily equity data, assume lookahead bias or selection bias until proven otherwise - inspect with `ml4t-lookahead-bias` and `ml4t-deflated-sharpe`

- If in-sample and out-of-sample performance match closely, suspect data leakage

- If the strategy requires > 20% annual turnover to work, verify cost assumptions with `ml4t-transaction-costs`

- If no documented hypothesis exists, stop and write one before any other work

## Production Implementation

```python

import asyncio

from ml4t.backtest import Strategy, run_backtest, BacktestConfig # MyStrategy subclasses Strategy

from ml4t.live import LiveEngine, AlpacaBroker, AlpacaDataFeed

results = run_backtest(

prices=prices, signals=signals, strategy=MyStrategy(), config=BacktestConfig()

)

async def trade_live():

broker = AlpacaBroker(api_key, secret_key, paper=True)

engine = LiveEngine(MyStrategy(), broker, feed)

await engine.connect()

await engine.run()

asyncio.run(trade_live())

```

## Checklist

- [ ] Hypothesis documented in term sheet before any code

- [ ] Data validated for gaps, survivorship bias, point-in-time correctness

- [ ] Features pass IC significance test with HAC standard errors

- [ ] Model validated via CPCV with PBO < 50%

- [ ] Backtest includes realistic transaction costs

- [ ] Deflated Sharpe ratio computed across all trials

- [ ] Paper trading completed for minimum 4 weeks

- [ ] Kill criteria defined and monitoring configured before going live