The Anatomy of a Trading Algorithm

Different Systems, Same Skeleton

In the last lesson we said an algorithm is a recipe. Now let's open it up. Whether it's a ten-line script on a laptop or a system trading millions of times a day, almost every automated strategy is built from the same six parts, wired in the same order. Learn the skeleton once and you can make sense of any trading system you meet — including the AI-powered ones, because in the simplified architecture we use throughout this course the AI most commonly lives in just one of these six parts.

Here's the whole machine on one page. Follow the arrows left to right, then notice the dashed line looping back underneath:

That single picture is the map for the whole course. Every later lesson zooms into one of these boxes — backtesting tests the rules, the AI lesson lives inside the signal engine, the execution lesson unpacks stage five. Let's walk each part once, in order.

1. Data — The Raw Inputs

Everything starts with data: prices and volume, company fundamentals, economic figures, even news headlines. A system is only as good as what it's fed — feed it wrong or delayed data and every decision downstream inherits the error. That's why the whole next lesson is about data quality. Garbage in, garbage out is not a slogan here; it's the first way systems fail.

2. Signal Engine — Where AI Lives

The signal engine boils that flood of data down to something simple: a score, or a signal. "This stock looks cheap relative to its average" might become the number +0.8; "this one looks stretched" might become −0.5. In the simplified architecture used throughout this course, this is the box where machine learning most commonly fits: instead of a person writing the formula, an AI model can learn one from examples. (More advanced systems may also apply machine learning to execution, routing, risk, and monitoring — but the signal engine is where it shows up first.) Crucially, the model doesn't place trades — it just produces a number. Everything after it is still plain rules.

3. Strategy Rules — Turning a Signal Into an Order

A signal on its own does nothing. The strategy rules translate it into an intended order: "if the signal is above +0.5, buy 10 shares; if it drops below −0.5, sell." This is where a raw score becomes a concrete decision — what to trade, which direction, and how much. We spend the next lesson on exactly this translation, because vague ideas make untestable rules.

4. Risk Checks — The Brake

Before any intended order becomes a real one, it passes through risk checks — and this is the part beginners skip and professionals obsess over. A risk layer asks: Is this position too large? Have we lost more than our daily limit? Has something clearly broken? If the answer is bad, it vetoes the order, no matter how strong the signal was. The drawdown limit and the "kill switch" — a master off-button — both live here. In the diagram, this is the amber box for a reason: it's the brake, and a system without brakes is the classic way automation turns a small mistake into a catastrophe.

5. Execution — Reaching the Market

An approved order still has to reach the market. The execution layer connects to a broker — usually through a broker API, a programmatic doorway we cover later — and sends the order to be filled, handling the same order types a human uses: market, limit, and stop. This stage is where speed, latency, and slippage show up, because the price you wanted and the price you get can differ in the moments an order travels.

6. The Feedback Loop — Closing the Circle

Finally, the dashed line. Once an order fills, the result — the price paid, the new position, the profit or loss — flows back to the start, so the next decision is made with fresh information. A monitoring layer sits on this loop, logging every fill and watching for trouble. Without the loop, a system is flying blind between trades; with it, the machine is always reacting to what just happened. That's the full skeleton: six parts, one circle.