Guide · Systematic trading

Building your first trading system: the minimum viable pipeline

Most first systems fail for the same reason, and it is not a bad idea. It is that the pipeline is skipped. People jump from a hunch straight to real money, or they build something so intricate that they can never tell whether it worked because of the market or because of them. This guide walks the minimum viable version of the full pipeline: the fewest moving parts that still take an idea all the way to live, with the honest framing built in from the first line. Your first system is a teacher. Design it so its lessons are readable, and it will do its job even on the trades it loses.

The tension worth naming up front is between completeness and simplicity. A system must specify everything, entry, exit, filter, size and stop, or it is not a system. Yet the more knobs you add to make it perform on past data, the less you can trust it on future data. The whole craft of a first build is resolving that tension in favour of simplicity: specify fully, but with as few tunable parameters as you can, so that a real edge has nowhere to hide behind curve fitting.

The pipeline as a gated flow

Think of the seven stages as a conveyor with a gate between each pair. A stage does not pass work forward because you are impatient; it passes work forward only when a specific question has been answered. If a gate fails, the idea either goes back a stage or is retired. This is the single structural habit that separates a system from a series of impulses.

Stage 1: the hypothesis, in one sentence

A system begins with a claim, not a chart. The claim is a hypothesis: a statement about market behaviour precise enough that it could be proven wrong. The discipline of writing it in a single sentence is not stylistic. It is a test of whether you have an idea at all. A vague intention like I want to catch strong moves cannot be tested, sized or reviewed, because nothing in it tells you what to do. A hypothesis names four things: the condition it keys on, the class of instrument, the action, and the timeframe. If any of the four is missing, the sentence is a mood, not a mechanism.

Keep the idea small enough that one rule set can express it. A first system that tries to encode three different beliefs at once is three systems tangled together, and when it fails you will not know which belief was wrong. One idea, one sentence, one system. The gate: hand your sentence to someone who does not trade and ask whether they could tell you, unambiguously, what would make it false. If they can, you have a hypothesis. If they cannot, you have more thinking to do.

Stage 2: rules with no discretion

The hypothesis becomes a system only when it is written as rules a machine could follow. That means the entry, the exit and the filter are each specified so completely that no judgement is left for the moment of the trade. Ambiguity is the enemy here, and not only because it makes the system hard to test. Ambiguity destroys learning: if a rule can be read two ways, then every outcome is contaminated by the on-the-day interpretation you made, and you can never attribute a result cleanly to the idea. The value of a mechanical rule is that it is repeatable, testable and reviewable, which is exactly what makes its lessons legible.

Stage 3: backtest with integrity

A backtest replays your rules over history to ask a single question: did this idea hold up. The trouble is that a backtest is trivially easy to make lie to you, and the lies are flattering, which is why beginners believe them. Four errors do most of the damage, and a first backtest that does not confront all four is measuring a fantasy. These four guards are covered in depth in the retail backtesting mistakes guide, and the mechanics of doing it in code, honestly, in the pandas backtesting walkthrough.

• Lookahead bias. Using information that was not available at the moment of decision, such as a value known only after the bar closed. It is the most common way a backtest cheats, and it makes rubbish look like genius.
• Survivorship bias. Testing only instruments that still exist today and silently dropping those that were delisted or merged away. What survived tends to have done well, so the sample is quietly rigged in your favour.
• Ignoring costs. Leaving out brokerage, taxes, spread and slippage. Frictions turn a great many paper edges negative, and for a short-horizon first system they can be the whole result.
• Overfitting. Tuning the rules so tightly to past noise that they capture the accidents of one dataset rather than any repeatable behaviour. It is the most written-about backtesting problem and still the most common.

The core first-system discipline against overfitting is to keep the parameter count low. Every tunable value you add is another degree of freedom the optimizer can use to bend the rules around the past, and a strategy with more than three or four optimizable parameters is at high risk of curve fitting. Prefer settings that sit on a wide plateau, where nearby values behave similarly, over a lone peak that only one exact number produces. Fewer parameters means more data supporting each one and a far more honest read on whether the edge is real. That upstream discipline, treating a backtest as a thing to be defended against rather than a scoreboard to be maxed, is exactly what the method we teach is built around.

Stage 4: the forward and paper test

A backtest, however careful, still judges the rules on data you had while building them. The next gate removes that privilege. In out-of-sample testing you set the rules on one slice of history and measure them on a later slice they never touched; in walk-forward analysis you optimize on an in-sample window, validate on the following out-of-sample window, and roll that pair forward through time. The purpose is precise: to tell a real edge from curve fitting. If performance collapses the instant the data is unseen, the rules were memorising, not generalising. The rule that governs this whole stage is one line: never judge a system on the same data you used to build it.

Then paper trade the finished rules forward in current conditions before a rupee is at risk. Paper trading will not teach you the emotions, that comes later, but it does something a backtest cannot: it forces you to execute the rules in real time, against live data, and it exposes the small ambiguities that only surface when the market is actually moving. If your paper behaviour drifts from your backtested behaviour, the rules were not as specified as you thought, and the honest move is to go back and finish specifying them.

Stage 5: the sizing and risk layer

Now the system meets money, and money is where beginners are destroyed. The layer that prevents it is not clever, it is arithmetic. You size from risk, not capital: fix a small fraction of the account you are willing to lose on one trade, place a hard stop at the price that proves the idea wrong, and let those two numbers determine the quantity. If the risk budget is a fixed rupee amount and the stop distance is known, then the position size is simply that budget divided by the per-unit risk. Conviction never enters the calculation, which is the point. The full arithmetic, including how the fraction interacts with a run of losses, is worked through in the position sizing guide.

Worked illustratively: if an account risks a fixed ₹1,000 per trade and the stop sits ₹5 below a planned entry, the size is ₹1,000 divided by ₹5, which is 200 units. Move the stop to ₹10 away and the size halves to 100 units for the same ₹1,000 of risk. The stop distance, not the account balance or your confidence, drives the size. That is the whole idea of a risk layer: it makes the worst single outcome a number you chose in advance, small enough that the system lives to trade another day and you live to learn the next lesson.

Stage 6: go live, small

The graduation is to the smallest real capital that still produces a genuine emotional response. This is the one lesson paper trading cannot teach, because a paper stop costs nothing to honour and a real one costs something every time. Go live small, keep the rules exactly as tested, and treat the first live phase as the final exam of your process rather than a profit run. The transition itself, what to carry over from paper and what changes the moment real money is involved, is the subject of the paper-to-live capital guide.

Two failure modes dominate the beginning of live trading, and both are discretion sneaking back in. The first is widening or moving a stop because a loss feels imminent, which converts a small planned loss into a large unplanned one. The second is over-trading, taking positions the rules never signalled, out of boredom or a wish to make back a loss. Notice that neither is a flaw in the idea. They are flaws in execution, and the mechanical rule set exists precisely to remove them. If you can hold the stop and take only the signalled trades at a trivial size, you have learned the thing the whole pipeline was built to teach.

Stage 7: monitor, review, and only then iterate

The last stage is the one beginners skip and experienced traders guard. You monitor the process, not the profit and loss, trade by trade: did you follow the rules, size from the risk budget, and honour the stop, every single time. You keep a log good enough to answer those questions honestly weeks later. Then you review on a schedule, against criteria set in advance, rather than reacting to the sting of the most recent trade. A mechanical system with a real edge still has losing runs; treating each one as a signal to change quietly rebuilds the discretion you spent the whole pipeline removing.

Only after a planned review, and only on evidence, do you iterate, and when you do, you change one thing and send it back through the pipeline: re-specify, re-backtest with the integrity guards, re-test out of sample, then live again. This is the loop in the first diagram, and it is what lets a first system grow up without ever being tuned live. Keep it simple, keep it mechanical, and let the review, not your mood, decide what changes. A first system that you can read, test and trust is worth incomparably more than a complicated one that made a little money for reasons you cannot name.

Where this fits, and what to build next

This page is deliberately the beginner cut: the minimum viable pipeline, stripped to the fewest parts that still reach live. Once the shape is second nature, the depth lives in two companion guides. For the full method, end to end, with the engineering and the edge cases, read how to build a trading system in India. For the development workflow itself, the tooling, the data handling and the iteration loop at production depth, read trading system development in India. Build the minimum viable version here first. Its whole purpose is to make you fluent in the process, so that when you reach for depth, you are extending a pipeline you already understand rather than assembling one you do not.