Systematic, algorithmic and quantitative trading versus discretionary trading.

Four words that get misused

Forums, courses and broker ads talk about "algorithmic", "systematic" and "quantitative" trading as if they were the same thing. They are not, and mixing them up leads to expensive mistakes: believing that automating an idea turns it into a tested strategy, or that using machine learning makes a system quantitative.

The first two rows answer the same question; the third, a different one; the fourth, yet another. That is why they can be combined: there are discretionary traders who execute with algorithms, systems applied by hand and automated systems that nobody has ever validated.

Two axes, not a scale

The figure at the top arranges these combinations on a plane. The horizontal axis measures how much of the decision lies in explicit rules; the vertical one, how much of the execution is done by a machine.

• Bottom left: discretionary trading. A checklist ("no trading before employment data", "stop always below the last low") moves the point to the right, but the decision still belongs to the person.
• Bottom right: manual systematic trading. The rule decides and the person enters the order at the broker. This is how many low-frequency systems start.
• Top left: algorithmic execution of human decisions. This is the norm at an asset manager: the manager decides what to buy and the desk uses algorithms to buy it with the least impact.
• Top right: automated systematic trading, the goal of this course. The rule decides, the program executes and the person supervises. In the corner, the highest-frequency quantitative strategies (statistical arbitrage, market making), where neither the decision nor the execution goes through a person.

Quantitative has no box of its own because it is not a position on the plane: it is a way of getting there. A system in the top right corner is quantitative only if its rules came from data and were validated with it.

What changes when the decision is a rule

Moving from the head to paper, and from paper to code, changes the nature of the decision. In the top row, the discretionary decision; in the bottom one, the systematic decision, which can also be tested on the past:

flowchart LR
  M1[Market] --> P[Trader decides] --> O1[Order]
  M2[Market] --> DT[Data] --> R[Rule decides] --> O2[Order]

What you gain:

• Reproducibility. Given the same data, the rule always makes the same decision. That allows testing it on the past (backtest) and comparing versions.
• Measurement. If the rule is written down, you can count how many trades it makes, how much they cost and how much each one gains or loses. An intuition cannot be measured.
• Scale. The same rule applies to a hundred assets with the same effort as to one.
• Discipline. The rule feels no fear and no hurry. The person who supervises it does: the most frequent mistake of a systematic trader is not in the rule, but in switching it off after three losses in a row.

What you lose:

• Context. A rule only sees what it is given. A regime change (a crisis, a shift in monetary policy) can break it without the rule noticing.
• Flexibility. Each exception ("unless…") is one more rule, one more thing to validate and one more chance to overfit.

A rule written in Python

You do not need to understand every line yet: the language is covered in module 0.3 and pandas in 0.5. The idea is to see what a rule looks like once it stops being a sentence. The data are the daily prices of SINT, a fictitious ETF generated for the course (link in "Resources"): five years of sessions, from 2021 to 2025.

import pandas as pd

precios = pd.read_csv("sint_diario.csv", parse_dates=["fecha"],
                      index_col="fecha")
precios["cierre"].tail(3)

fecha
2025-12-29    139.56
2025-12-30    139.98
2025-12-31    142.22
Name: cierre, dtype: float64

The rule: be long when the 50-session moving average is above the 200-session one, and out of the market otherwise. Written as a function, it takes a series of closes and returns a 1 or a 0 for each day:

def senal_cruce(cierre: pd.Series, rapida: int = 50,
                lenta: int = 200) -> pd.Series:
    """1 if the fast average closes above the slow one; 0 otherwise."""
    media_rapida = cierre.rolling(rapida).mean()
    media_lenta = cierre.rolling(lenta).mean()
    return (media_rapida > media_lenta).astype(int)

senal = senal_cruce(precios["cierre"])
senal.value_counts()

cierre
1    834
0    469
Name: count, dtype: int64

The zeros include the first 199 days, when there is still no 200-session average to compare against. Running the rule twice on the same data gives exactly the same result. It looks trivial, and it is the property that makes everything else possible:

senal.equals(senal_cruce(precios["cierre"]))

True

One detail remains that separates an honest backtest from an inflated one. A day's signal is computed with its close: until the market closes, you do not know whether the fast average ended above the slow one. So the trade can only be made from the next session on. In code, the position is the signal shifted by one day:

# the signal from the close is traded the next day
posicion = senal.shift(1).fillna(0).astype(int)
cambios = int(posicion.diff().abs().sum())
dias_dentro = posicion.mean()
print(f"Position changes in five years: {cambios}")
print(f"Days long: {dias_dentro:.1%}")

Position changes in five years: 9
Days long: 63.9%

Using senal instead of posicion would mean buying at today's close with information from today's close itself. That mistake has a name, look-ahead bias, and it is the most common one in systematic trading: a backtest that contains it always looks better than what the strategy can deliver. It will come back in almost every level of the course.

What makes a system quantitative

The rule above is systematic and, as soon as it is connected to a broker, algorithmic. Is it quantitative? Not yet: nobody has checked with data whether the parameters 50 and 200 make sense, how much it costs to trade, whether it works on other assets or whether its result can be told apart from chance. That is what the course calls the quantitative method, and it is the thread running through every level:

Clean data, hypothesis, honest backtest, statistical validation, risk, execution and monitoring. A system with a single moving average that has gone through that cycle is more quantitative than a neural network that nobody has validated.

Exercises

1. Classify these five ways of trading on the two axes (who decides, who executes) and say which ones could be quantitative: (a) a Telegram bot that forwards a "guru's" signals and executes them in your account; (b) a 60/40 portfolio rebalanced by hand every January; (c) a fund that buys the 50 stocks with the best 12-month momentum, tested against 30 years of data; (d) a futures trader who trades breakouts "when he sees volume"; (e) a TWAP algorithm that executes the sale of a block of shares decided by a committee.

2. This rule looks clear: "buy when the price breaks the high of the last 20 sessions and sell when it breaks the low of the last 10". Write three questions a programmer would have to ask you before being able to code it.

3. Change the rule's parameters to 20 and 100 sessions and compute the number of position changes and the percentage of days long. Why does the number of trades change so much?

senal_rapida = senal_cruce(precios["cierre"], rapida=20, lenta=100)
posicion_rapida = senal_rapida.shift(1).fillna(0).astype(int)
print(f"Position changes: {int(posicion_rapida.diff().abs().sum())}")
print(f"Days long: {posicion_rapida.mean():.1%}")

Position changes: 23
Days long: 61.9%