What Are the Core Indicators You Can Use to Build Trading Algorithms?

A practical breakdown of time, momentum, volatility, trend structure, and price behavior used in real systematic trading research

I came across a question recently that seems simple on the surface, but it’s one of those questions that gets more interesting the longer you’ve been building systems:

“What are the core indicators we can use to build algorithms?”

Most people expect a shopping list in response. RSI. MACD. Bollinger Bands. Moving averages. Maybe a few exotic ones. If you’ve spent any time around trading forums, you’ve probably seen the same handful of indicators recycled endlessly, often with the implication that the right indicator is what separates winners from losers.

After years of actually building systematic strategies, generating large libraries of conditions, validating them out-of-sample, comparing them to randomness baselines, filtering by correlation, and then assembling ensembles, my answer is far less glamorous.

What matters is whether you can describe market behavior cleanly and consistently, then test it properly for its statistical properties. The indicators themselves are just a language for expressing those behaviors.

Before going any further, one important clarification: what follows is not meant to be comprehensive. This is not “the full list of everything that works.” It’s a starting point, a core foundation that has proven robust for me. There are many other useful features and indicators a trader can add on top of this depending on market, timeframe, and style. Think of this as the skeleton, not the entire body.

Below is the actual indicator language I use expressed the way it shows up in TradeStation logic — and why each category matters.

Time Is an Indicator (And It’s One of the Strongest Ones)

The most overlooked indicator in trading is time. Markets are shaped by settlement cycles, institutional flows, hedging behavior, rebalancing, and seasonality. None of that shows up as a moving average crossover but it absolutely shows up in performance if you test it properly. I treat time as a first-class signal input. That includes simple, explicit calendar logic like:

• Day of week

  • DayOfWeek(date) = 1

  • DayOfWeek(date) = 3

  • DayOfWeek(date) = 5

• Grouped weekdays

  • DayOfWeek(date) = 1 OR DayOfWeek(date) = 2

  • DayOfWeek(date) = 3 OR DayOfWeek(date) = 4

  • DayOfWeek(date) = 4 OR DayOfWeek(date) = 5

• Day of month

  • DayOfMonth(date) <= 15

  • DayOfMonth(date) >= 16

  • DayOfMonth(date) >= 1 AND DayOfMonth(date) <= 10

  • DayOfMonth(date) >= 21

• Month, quarter, half-year

  • Month(date) = 1

  • Month(date) = 12

  • Month(date) <= 3

  • Month(date) >= 7

• Other simple time structure

  • DayOfYear(date) = 250

  • WeekOfYear(date) = 42

  • DayOfMonth(date) = 17

These kinds of time filters don’t predict direction. Their job is to slightly tilt the odds. On their own, they’re rarely impressive. Combined with other signal families, they often become stable contributors in a system.

Momentum & Mean Reversion: RSI as Pressure, Not a Signal

RSI is one of the most misunderstood indicators in retail trading. The problem isn’t RSI, it’s how narrowly it’s usually applied. I don’t treat RSI as an “overbought / oversold” switch. I treat it as a pressure gauge. What matters is where RSI is, where it was, and how it’s changing.

That shows up in logic like:

• RSI level states

  • RSI(Close, 2) >= 70

  • RSI(Close, 5) <= 30

  • RSI(Close, 20) >= 50

• RSI relative comparisons

  • RSI(Close, 2) > RSI(Close, 2)[5]

  • RSI(Close, 10) < RSI(Close, 10)[10]

  • RSI(Close, 20) <= RSI(Close, 20)[20]

Translation on the lower block:

RSI(2) of the current bar is greater than RSI(2) 5 bars ago

This is still just a starting point. There are many other momentum representations a trader can layer in, different oscillators, rate-of-change measures, or custom transforms, but RSI remains a simple, well-behaved building block when used this way.

Trend Strength (Not Trend Direction)

One of the most common reasons strategies fail is that they’re run in the wrong environment. Mean reversion ideas get destroyed in strong trends. Trend-following ideas get chopped up in sideways markets. That’s why I separate trend strength from trend direction. ADX is useful here, not as an entry trigger, but as a regime filter:

• ADX strength states

  • ADX(10) > 25

  • ADX(20) <= 20

  • ADX(30) > 40

ADX is not the only way to do this, there are plenty of other regime and structure measures that work well but it’s a clean, interpretable starting point that integrates nicely with other signal families.

Raw Price Structure (Massively Underrated)

Some of the most durable signals don’t look like indicators at all. They’re simply statements about how price is behaving relative to itself.

For example:

• Open / High / Low / Close relationships

  • Open > Open[5]

  • Open <= High[10]

  • Close > Low[20]

  • Close <= Close[15]

• Prior-bar context

  • Open[1] > Close[5]

  • Open[1] <= Low[10]

These kinds of conditions are incredibly portable across markets. They don’t rely on smoothing assumptions or fragile parameters. They just ask whether price is behaving differently than it recently has. Again, this is not an exhaustive list but a representative slice of a broader family of price-structure ideas a trader can expand on.

Pivot & Reference Structure

Markets react to shared reference points. Not because those levels are mystical, but because many participants are looking at the same information. That shows up in logic like:

• Pivot comparisons

  • (High + Low + Close) / 3 > ((High[5] + Low[5] + Close[5]) / 3)

  • (High + Low + Close) / 3 <= ((High[10] + Low[10] + Close[10]) / 3)

There are many ways to define reference structure, pivots are just one clean starting example.

Trend Structure: Moving Averages as Environment

Moving averages still matter, just not as magic signals. I use them to define structure and regime:

• Short vs long structure

  • Average(Close, 10) > Average(Close, 50)

  • Average(Close, 20) < Average(Close, 100)

  • Average(Close, 5) <= Average(Close, 40)

This isn’t the only way to define trend structure, but it’s a simple and effective starting point that plays well with other filters.

Volatility as a State Variable

Volatility is one of the most important contextual variables in systematic trading. Many strategies don’t actually fail, they’re just traded in the wrong volatility regime. I treat volatility relatively:

• Volatility expanding or contracting

  • NATR[0] > NATR[10]

  • NATR[5] <= NATR[20]

There are many other volatility representations a trader can explore, but relative volatility comparisons like this are often more robust than fixed thresholds.

Participation & Commitment: Volume and Open Interest

Volume and open interest rarely make great standalone entry signals. Where they shine is context. That shows up as simple structure logic:

• Volume comparisons

  • Volume > Volume[10]

  • Volume <= Average(Volume, 20)

• Open interest structure

  • OpenInt > OpenInt[15]

  • OpenInt < OpenInt[30]

Again, this is a foundation, not a limit. There are many additional participation-based features that can be layered in depending on market and data availability.

The Part Most People Miss

If you’re looking at this list and thinking, “That’s not that many indicators,” you’re right. That’s the point. This is not meant to be comprehensive. It’s meant to be a starting framework and a small, robust set of measurable behaviors that you can build on. There are countless other good features a trader can add once this foundation is in place.

The edge isn’t in discovering new indicators. It’s in expressing market behavior clearly, validating it properly, and then combining ideas intelligently.

Most indicators fail not because they’re bad ideas, but because they were:

• Over-optimized

• Traded in the wrong regime

• Highly correlated with other signals

• Indistinguishable from randomness when tested correctly

So when someone asks, “What are the core indicators for building algos?” my answer is simple:

Start with indicators that describe time, pressure, structure, volatility, and participation. Use them as a foundation, then expand thoughtfully from there.

The most important idea in this post is:

we should spend 10% of our time defining and creating indicators

we should spend 90% of our time testing indicators for statistical robustness

Hope this helps.

— Josh