How to Build a Data-Driven Trading System (Part 1): Lessons from Testing Thousands of Strategies

How to Build a Data-Driven Trading System: Lessons from Testing Thousands of Strategies

Part 1 – Trading System Design Using a Proprietary Framework

Introduction

Every trader is drowning in strategies.

Indicators. Patterns. “Secret” setups.

But how do you know what actually works?

The truth is… you don’t.
Not until you test it properly.

This article is Part 1 of an ongoing series where I walk you through how I built a rule-based trading system using my own Python research framework.

Instead of guessing, we:

Generate thousands of strategy combinations
Test them across many stocks and multiple years
Keep only what proves stable, simple, and repeatable

This first part is all about the process behind that testing.

You’ll see:

How the framework is built
How the triggers work
How we narrow down promising systems from a huge search space

Why Use a Systematic, Data-Driven Approach?

Why bother with all this?

Because discretionary trading is:

Emotional
Inconsistent
Difficult to measure or improve

A systematic approach flips that on its head.

Instead of:

“This setup feels good.”

we move to:

“This setup has worked consistently across thousands of trades.”

By testing a wide range of indicator combinations across different tickers and different environments, we:

Reduce personal bias
Spot real patterns, not random noise
Avoid falling in love with one nice-looking chart

The best part?

Once your logic is in code, you can re-test the same system across:

New data
New markets
New time periods

…with zero guesswork.

Repeatable testing = repeatable decisions.

The Platform & Trigger Framework

All of this runs on a proprietary research tool I built specifically for this project.

At its core is a trigger framework that controls how entries are generated.

Here’s the idea:

There are 7 entry triggers
Each trigger can be set to:
- TRUE – must be active
- FALSE – must be inactive
- EXCLUDED – ignore it completely

Think of it like a panel of seven switches.

Each switch can say:

“Yes, I want this condition,”
“No, I want the opposite,”
or “Leave this out.”

This creates a clean, structured way to generate many different strategy logics from the same building blocks.

Search Space & Combination Logic

Let’s talk numbers.

Just for the entry side, using 7 triggers and 3 possible states each, we get:

3&sup7; = 2,187 possible entry configurations.

And that’s before we consider:

Exit rule variations
Different indicator parameters (RSI thresholds, MACD lengths, ATR multipliers, etc.)

Total permutations?
It gets very big, very fast.

Why explore such a large space?

Because some of the most powerful behaviors only appear when multiple conditions line up correctly.

If you only test one indicator at a time, you’ll never see those interactions.

Scoring, Pruning & Selection Criteria

Of course, not every combination is worth keeping.

Each strategy is evaluated on key metrics like:

Total Return
Return per Trade (RpT)
Win Rate (Batting Average)
Maximum Drawdown

Then we start pruning.

We prioritize systems that are:

Simple
- Fewer conditions, clear logic
Robust
- Work across many tickers, not just one favorite stock
Stable over time
- Don’t shine in one quarter and collapse in the next

In my research, simplicity + stability beats complexity + noise every time.

A system that is:

Easy to understand
Easy to explain
And behaves consistently across time

…is far more valuable than a “perfect” backtest that only works in one market regime.

Breakdown of Entry Triggers

In this example framework, the entry logic is built from seven core triggers.

Here’s what they check:

RSI-14 Range Filter
Checks if RSI(14) is between 30 and 70.
Goal: avoid extreme overbought/oversold zones.
We want trades in the “middle ground,” not at emotional extremes.
Bullish Engulfing Pattern
Classic candlestick reversal pattern.
Designed to capture short-term reversals where buyers step back in.
Often used as an early signal after pullbacks.
Price Above Monthly EMA
Compares current price to a monthly EMA.
Functions as a trend filter.
Helps favor stocks that are in recovery or early uptrend mode.
Price Above 12-Day High
Simple breakout style condition.
If price breaks above the last 12-day high, it can indicate fresh strength.
Used as a confirmation that momentum is actually pushing up.
MACD Rising (9, 18, 12)
MACD configured with custom parameters.
We want MACD to be rising, not falling.
This confirms that momentum is improving, not decaying.
Volume Above 2.5-Month EMA
Checks if current volume is above its own EMA (roughly 2.5 months).
Signals increased participation and conviction.
Strong, sustainable moves tend to come with strong volume.
7th (Optional / Rotating Trigger)
Depending on the phase of research, this slot can represent another structural or volatility-based condition.
For example: distance from long-term EMA, volatility compression, or regime filters.

Individually, none of these guarantees profits.

The magic appears when we decide:

Which ones must be TRUE
Which ones must be FALSE
Which ones are EXCLUDED

Performance comes from the logic of the combination, not the indicator alone.

Exit Triggers & Risk Management

Entries are just the beginning.

Survival and growth come from exit rules.

In this framework, exits are built from:

Profit Target
Stop Loss
Optional Trailing Stop logic

Example setup:

Profit Target:
Close + 4 × ATR(20)
Gives trades enough room to capture meaningful swings, not tiny scalps.
Stop Loss:
Lowest low of the last 3 days − ATR(13)
Based on both recent structure and volatility.
Helps avoid being shaken out by normal noise while still protecting capital.
Trailing Logic (optional):
Tightens risk as price moves in our favor.
Used to lock in gains without exiting too early on every pullback.

The goal is simple:

Let winners breathe, cut losers early, and avoid micro-managing every wiggle.

Top Strategy Combinations Compared

After scoring thousands of configurations, some clear candidates rise to the top.

For example:

Candidate A
Around 940 trades.
RpT ≈ 0.26%.
Balanced profile across return, win rate, and drawdown.
Good blend of efficiency and stability.
Candidate B
Around 1,630 trades.
Higher total return ≈ 408%.
Chosen as a leading candidate because it offers the best blend of:
- Total return
- Trade count
- Statistical confidence
Candidate C
Massive total return ≈ 820%.
But ~5,479 trades and significantly higher volatility.
Rejected because it’s too unstable and operationally demanding.

The key insight?

We’re not chasing the highest number at any cost.

We’re looking for strategies that:

You can actually trade in real life
You can scale without losing your mind
You can trust when markets get messy

System Adjustment Phase

Once strong candidates are identified, we enter the refinement phase.

This is where we adjust parameters carefully to see how they affect behavior, without “curve-fitting” to the past.

Some examples:

RSI thresholds
Testing variations like 10–35, 20–40, etc.
Seeing how changing the “acceptable zone” impacts trade quality.
MACD configurations
Adjusting fast, slow, and signal periods.
Balancing responsiveness vs. stability.
Volume filters
Testing volume EMAs from 1 to 6 months.
Checking which horizon best captures meaningful participation.
Exit rules
Trying different ATR multipliers on targets and stops.
Adjusting trailing stop length and logic.

The goal is not:

“How do I make this one backtest look perfect?”

The goal is:

“Which parameter ranges keep the system profitable, stable, and simple across different conditions?”

When multiple settings point in the same direction (e.g., “wider stops improve stability” or “too aggressive targets reduce RpT”), that information is gold.

Summary & Key Takeaways

Let’s bring it all together.

Here are the main lessons from Part 1:

No single indicator is enough.
Edge comes from well-designed combinations, not isolated signals.
Simple + stable > complex + clever.
A clean rule set that holds up across different markets is more valuable than a fragile masterpiece.
Statistical robustness is non-negotiable.
You want systems that work across tickers, sectors, and timeframes, not just one lucky sample.
This phase is about building the foundation.
We now have:
- A clear way to define triggers
- A framework to generate thousands of combinations
- A scoring system to rank and filter them

Future posts will use this same methodology to explore:

New sets of entry triggers
Different exit engines
Variations by timeframe, sector, and volatility regime

This is how you move from “I like this setup” to:

“I’ve tested this idea across thousands of trades. Now I know what it can really do.”

Frequently Asked Questions (FAQ)

Q: What is the benefit of testing thousands of strategies?
A: It helps us find patterns that are stable, not accidental. By comparing many configurations across many stocks, we can see which ideas keep working and which ones were just lucky.

Q: How do you prevent overfitting?
A: By:

Favoring simple logic
Looking for cross-market consistency
Measuring performance over time, not just in one period
Being willing to discard “beautiful” backtests that don’t generalize

Q: Can this system be used for live trading?
A: It forms the foundation for a live system, but there are more steps:

Forward-testing
Walk-forward validation
Automation and execution checks
Realistic position sizing and risk limits

Think of this as building the engine. The full car comes later.

Q: How often should the system be adjusted?
A: I recommend:

A structured review every quarter
A deeper review after major market regime changes (e.g., volatility spikes, macro shocks)

The goal is not constant tinkering, but disciplined adaptation.

What’s Coming Next

In Part 2, I’ll start walking through:

Actual example systems
Specific binary codes and what they mean
How performance changes when we invert or exclude certain triggers

If you’re interested in:

Having your own idea tested in this framework
Seeing more breakdowns of real systems
Or following this series as it grows

Make sure you subscribe, leave a comment, or reach out directly.

This is just the beginning.