BUILD: COURSE 3 | LESSON 1

Anatomy of a strategy: edge, setup, entry, exit, filters

Learning objectives

Name the six components every complete strategy must define — edge hypothesis, setup, entry trigger, exit rules, filters, and risk parameters — and explain what breaks when each is missing.
Convert a vague trade idea into rules precise enough that two people (or you and a backtest) would take identical trades.
Write your first one-page strategy specification, ready for demo testing.

Course P2 gave you a risk chassis: sizing, drawdown limits, exit discipline, portfolio caps. This course builds engines to put inside it. Before we walk through three concrete strategy families (trend, mean-reversion, breakout), you need the blueprint they all share — because the difference between "a strategy" and "some trades I liked" is not sophistication, it's completeness and precision. A strategy is a set of rules specific enough to be executed identically every time, and therefore (P2.1) the only kind of thing whose expectancy can be measured. Here is the anatomy, part by part.

Part 1: The edge hypothesis — why should this make money?

Every durable strategy starts with a one-sentence claim about market behaviour that would explain a positive expectancy. Examples: "strong trends persist longer than most participants expect, so buying pullbacks in trends gets favourable prices for continuation" (trend-following); "in quiet conditions, price stretched far from its average tends to snap back" (mean-reversion); "when price escapes a long consolidation, stop orders and latecomers fuel follow-through" (breakout).

Why insist on this? Two reasons. First, it disciplines every later rule: each filter and trigger should serve the hypothesis, which protects you from bolting on indicators because they look clever. Second, it tells you when the strategy should fail — a pullback-buying system should lose money in ranges; if it does, that's the strategy working as designed in the wrong regime, not a broken system. Without a hypothesis you can't distinguish "normal, expected losses" from "this never had an edge", and you'll abandon good systems at the bottom of normal drawdowns (remember P2.3: 5–10 loss streaks are routine). Be honest here: "the RSI crossed a line" is not a hypothesis. A hypothesis names who is on the other side of the trade and why they're systematically mispricing something — even if only roughly.

Part 2: Setup vs entry trigger — the condition and the gun

Traders constantly blur two different things:

Setup: the market state that must exist before you're allowed to consider a trade. Example: "EUR/USD H4: price above the 50 EMA, 50 EMA rising, and price has pulled back to within 0.5 × ATR of the 20 EMA." A setup can persist for hours. It is a photograph you could point at on a chart and a colleague would agree, yes, that qualifies — or no, it doesn't.
Entry trigger: the specific event that converts a valid setup into an order. Example: "an H4 candle closes back above the 20 EMA" or "buy stop 2 pips above the high of the pullback's lowest candle." Binary, timestamped, unarguable.

The test for precision is brutal and simple: could you write it as code, or explain it to someone who will execute it without asking you anything? "Enter when momentum looks strong" fails. "Enter on H4 close above the 20 EMA while setup conditions hold" passes. Precision isn't pedantry — it is what makes your journal a dataset, your backtest honest, and your discretion visible. (You can still allow discretion, but it must be named discretion: "skip the trigger if a red-calendar event is within 4 hours" is a rule; a queasy feeling is not.)

Part 3: Exits, filters and risk — where the expectancy actually lives

Exits. For any entry, the exit rules determine most of the P&L distribution — this was the whole message of P2.4. A complete strategy defines all three exits in advance: the initial stop (where the hypothesis is invalidated — beyond structure, at least ~1.5 × ATR per P2.2), the profit exit (fixed R target, trail, or condition like "close below the 20 EMA"), and the time/invalidations exit (what if the trade goes nowhere for N bars? what if news changes the picture?). Beginners obsess over entries; the walkthrough lessons will keep showing that entries are the least differentiated part of the machine.

Filters. Filters are conditions that block otherwise-valid signals: a regime filter (only take pullback buys when the daily trend agrees — e.g. price above the daily 200 SMA), a volatility filter (skip when ATR is below the 20th percentile — spread eats too much of R; or above the 95th — chaos), a calendar filter (no new positions 30 minutes either side of high-impact releases), a session filter (this setup only during London/NY). Filters are where most real improvement hides and where most self-deception hides: every filter you add makes the strategy fit the past better and the future maybe-not-at-all. Rule of thumb for this academy: a strategy earns one hypothesis and at most two or three filters. If it needs six filters to look good historically, it doesn't look good.

Risk parameters. Finally the strategy plugs into your P2 chassis: risk per trade (%), maximum concurrent positions, which correlated instruments it may trade (P2.5 groups), and the drawdown level at which the strategy — not you — is benched for review.

Part 4: The one-page specification

Put together, a strategy spec fits on one page, and writing it is this lesson's real work:

Name & hypothesis (one sentence each)
Market & timeframe (e.g. EUR/USD, GBP/USD; H4 signals, D1 regime)
Regime filter(s) (max 3, each justified by the hypothesis)
Setup (the photographable state)
Entry trigger (the codeable event)
Initial stop / profit exit / time exit
Risk: % per trade, max positions, correlation group, bench-the-strategy drawdown
Review cadence: journal fields to record; evaluate after N trades (N ≥ 30)

One honest warning before the walkthroughs: the next three lessons each present a classic strategy family with concrete example rules. None of them is presented as profitable as written. Published example rules — including ours — are teaching skeletons: their parameters are illustrative, their historical performance varies wildly by instrument and decade, and anything that worked verbatim for everyone would stop working. What you are learning is the anatomy, so you can build, test and own your version. The testing itself — how to find out whether your spec has an edge without fooling yourself — is Lesson 5, and it happens on demo, where bad first drafts cost nothing.

Key takeaways

A strategy = edge hypothesis + setup + entry trigger + exits + filters + risk parameters. Missing any component means its expectancy can't be measured or trusted.
The hypothesis explains why the edge should exist and predicts when the strategy should lose — which is how you tell normal drawdown from no-edge.
Setup is a persistent state; the entry trigger is a binary event. The precision test: could it be coded, or executed by someone else without questions?
Exits and filters shape expectancy more than entries; cap yourself at 2–3 justified filters to avoid curve-fitting the past.
Example strategies in this course are teaching skeletons, not systems to copy — your job is to spec, test on demo, and measure before any real money is involved.