Signal to noise ratio from Business into forex trading?

[PTScalper]

Hi scalpers, traders.

As you all know if you made some business, that main purpose of CEO is to be able to understand what is just noise and actual signal.
I mean to understand what is important and what not. Because main purpose of business is to deliver value to customers and spend as low as possible in that process to create profit and keep alive.

The same it is with forex trading, you need to make as much as possible money with as low as possible losing trades.
You have to learn how to spot opportunity and how to filter noise.

[LondonScalper]

Business SNR maps oddly well to discretionary scalping: most alerts are noise; the job is a small set of A+ conditions.

I treat “new indicator / new pair / new session” like scope creep in a project — needs a written reason or it doesn’t ship.

Where did business habits help you — and where did they make you over-process the tape?

[LondonScalper]

main purpose of CEO is to be able to understand what is just noise and actual signal. ... The same it is with forex trading

Business SNR maps cleanly onto a scalp book once you drop the jargon.

Most of what hits the screen is noise: another indicator, another pair, another “urgent” alert. Signal is a short list of conditions you’ve already paid tuition to recognise. My working definition: if I can’t explain the ticket in one calm sentence before entry, it’s probably noise wearing a costume.

Desk habits that keep the ratio honest:

• Fixed universe (few pairs) — expansion is a project, not a whim
• Session windows only; curiosity outside them is unpaid overtime
• Review losers for process breaches, not for new indicators

CEOs cut low-value work; traders should cut low-value tickets. Same muscle.

Where do you personally draw the line between “useful experiment” and noise — time-boxed trials, or a hard one-in/one-out rule on tools?

[FTtrader]

Hi scalpers, traders.

As you all know if you made some business, that main purpose of CEO is to be able to understand what is just noise and actual signal.
I mean to understand what is important and what not. Because main purpose of business is to deliver value to customers and spend as low as possible in that process to create profit and keep alive.

The same it is with forex trading, you need to make as much as possible money with as low as possible losing trades.
You have to learn how to spot opportunity and how to filter noise.

Hello PTscalper,

You hit the nail on the head. In trading, just like in business, the "noise" will drain your capital (and your energy) through a thousand tiny cuts if you don't have a systematic way to filter it out and wait for the actual "signal."

Since your prompt is philosophical rather than a specific set of technical rules, I have designed a CEO Signal vs. Noise Filter in Pine Script (v5) based on your exact analogy.

Here is how it translates your business logic into code:

The Opportunity (The Idea): It uses a Fast and Slow Exponential Moving Average (EMA) crossover to spot potential momentum shifts.

The Noise Filter (The CEO's Desk): It uses the Average Directional Index (ADX) to measure market chop. If a crossover happens but the ADX is low, the script marks it as "Noise" (gray cross) so you don't waste your money. If the ADX is high, it marks it as a real "Signal" (Buy/Sell label).

Code: Select all

//@version=5
indicator("CEO Signal vs Noise Filter", overlay=true)

// --- Inputs: Setting the CEO's Parameters ---
fastLen = input.int(9, title="Fast EMA Length (Opportunity Spotter)")
slowLen = input.int(21, title="Slow EMA Length (Baseline)")
adxLen = input.int(14, title="ADX Length (Trend Measure)")
adxThreshold = input.int(20, title="ADX Noise Filter Threshold")

// --- 1. Spotting Potential Opportunities ---
fastEma = ta.ema(close, fastLen)
slowEma = ta.ema(close, slowLen)

plot(fastEma, color=color.blue, title="Fast EMA")
plot(slowEma, color=color.orange, title="Slow EMA")

// --- 2. Filtering the Noise ---
// ta.dmi returns three values; we only need the ADX to measure if the market is actually trending or just chopping.
[diPlus, diMinus, adx] = ta.dmi(adxLen, adxLen)

// --- 3. Business Logic (Signal vs Noise) ---
// A real signal happens when EMAs cross AND the market has enough momentum to overcome the noise threshold.
longSignal = ta.crossover(fastEma, slowEma) and adx > adxThreshold
shortSignal = ta.crossunder(fastEma, slowEma) and adx > adxThreshold

// Noise happens when EMAs cross, but the market has no real momentum (ADX is below threshold).
noiseLong = ta.crossover(fastEma, slowEma) and adx <= adxThreshold
noiseShort = ta.crossunder(fastEma, slowEma) and adx <= adxThreshold

// --- 4. Chart Execution ---
// Plotting Actual Signals (The high-probability trades)
plotshape(series=longSignal, title="Actual Buy Signal", location=location.belowbar, color=color.green, style=shape.labelup, text="BUY\n(Signal)", textcolor=color.white)
plotshape(series=shortSignal, title="Actual Sell Signal", location=location.abovebar, color=color.red, style=shape.labeldown, text="SELL\n(Signal)", textcolor=color.white)

// Plotting the Noise (The trades you should ignore to save capital)
plotshape(series=noiseLong, title="Ignored Noise Long", location=location.belowbar, color=color.gray, style=shape.xcross, text="Noise")
plotshape(series=noiseShort, title="Ignored Noise Short", location=location.abovebar, color=color.gray, style=shape.xcross, text="Noise")

[FTtrader]

How to use this in TradingView:

1.) Open TradingView and open a chart.

2.) At the bottom of the screen, click on the Pine Editor tab.

3.) Delete any code that is currently there, paste the code above, and click Save.

4.) Click Add to Chart.

You can adjust the "ADX Noise Filter Threshold" in the indicator's settings. Raising it to 25 will filter out even more noise (making you take fewer trades, but higher quality ones), while lowering it to 15 will let more signals through.

[FTtrader]

MetaTrader 4 (MQL4) Implementation

This script evaluates on completed bars (index 1 and 2) to ensure your signals lock in permanently and do not repaint while a live candle is forming.

Code: Select all

//+------------------------------------------------------------------+
//|                                        CEO_Signal_vs_Noise.mq4   |
//+------------------------------------------------------------------+
#property copyright "CEO Filter"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 clrLimeGreen
#property indicator_color2 clrRed
#property indicator_color3 clrDarkGray
#property indicator_color4 clrDarkGray

// --- Inputs ---
input int FastEMA = 9;
input int SlowEMA = 21;
input int ADX_Period = 14;
input double ADX_Threshold = 20.0;

// --- Buffers ---
double BuySignal[];
double SellSignal[];
double NoiseBuy[];
double NoiseSell[];

int OnInit()
  {
   SetIndexBuffer(0, BuySignal);      SetIndexStyle(0, DRAW_ARROW); SetIndexArrow(0, 233); // Up Arrow
   SetIndexBuffer(1, SellSignal);     SetIndexStyle(1, DRAW_ARROW); SetIndexArrow(1, 234); // Down Arrow
   SetIndexBuffer(2, NoiseBuy);       SetIndexStyle(2, DRAW_ARROW); SetIndexArrow(2, 251); // X Mark
   SetIndexBuffer(3, NoiseSell);      SetIndexStyle(3, DRAW_ARROW); SetIndexArrow(3, 251); // X Mark
   
   IndicatorShortName("CEO Signal vs Noise (" + IntegerToString(FastEMA) + "," + IntegerToString(SlowEMA) + ")");
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], 
                const double &open[], const double &high[], const double &low[], 
                const double &close[], const long &tick_volume[], const long &volume[], 
                const int &spread[])
  {
   int limit = rates_total - prev_calculated;
   // Ensure enough historical data on first load
   if(prev_calculated == 0) limit = rates_total - 3;
   
   // Loop backwards. i=1 prevents repainting by checking only closed bars
   for(int i = limit; i >= 1; i--) 
     {
      // 1. Get Indicator Values
      double fast1 = iMA(NULL, 0, FastEMA, 0, MODE_EMA, PRICE_CLOSE, i);
      double fast2 = iMA(NULL, 0, FastEMA, 0, MODE_EMA, PRICE_CLOSE, i+1);
      
      double slow1 = iMA(NULL, 0, SlowEMA, 0, MODE_EMA, PRICE_CLOSE, i);
      double slow2 = iMA(NULL, 0, SlowEMA, 0, MODE_EMA, PRICE_CLOSE, i+1);
      
      double adx   = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MAIN, i);

      // 2. Logic: Crossovers
      bool crossUp = (fast1 > slow1 && fast2 <= slow2);
      bool crossDn = (fast1 < slow1 && fast2 >= slow2);

      // Initialize buffers for current bar to empty
      BuySignal[i] = EMPTY_VALUE; SellSignal[i] = EMPTY_VALUE;
      NoiseBuy[i] = EMPTY_VALUE;  NoiseSell[i] = EMPTY_VALUE;

      // Dynamic spacing so arrows don't touch the candles directly
      double offset = (high[i] - low[i]) * 0.3; 

      // 3. Execution
      if(crossUp)
        {
         if(adx > ADX_Threshold) BuySignal[i] = low[i] - offset;
         else NoiseBuy[i] = low[i] - offset;
        }
      else if(crossDn)
        {
         if(adx > ADX_Threshold) SellSignal[i] = high[i] + offset;
         else NoiseSell[i] = high[i] + offset;
        }
     }
   return(rates_total);
  }

[FTtrader]

MetaTrader 5 (MQL5) Implementation

MQL5 requires indicator handles and array copying. The logic remains identical to MQL4.

Code: Select all

//+------------------------------------------------------------------+
//|                                        CEO_Signal_vs_Noise.mq5   |
//+------------------------------------------------------------------+
#property copyright "CEO Filter"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   4

#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrLimeGreen
#property indicator_label1  "Buy Signal"

#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrRed
#property indicator_label2  "Sell Signal"

#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrDarkGray
#property indicator_label3  "Noise Long"

#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrDarkGray
#property indicator_label4  "Noise Short"

// --- Inputs ---
input int FastEMA = 9;
input int SlowEMA = 21;
input int ADX_Period = 14;
input double ADX_Threshold = 20.0;

// --- Buffers and Arrays ---
double BuySignal[], SellSignal[], NoiseBuy[], NoiseSell[];
double FastEmaArr[], SlowEmaArr[], AdxArr[];
int handle_fast, handle_slow, handle_adx;

int OnInit()
  {
   // Map Buffers
   SetIndexBuffer(0, BuySignal, INDICATOR_DATA); PlotIndexSetInteger(0, PLOT_ARROW, 233);
   SetIndexBuffer(1, SellSignal, INDICATOR_DATA); PlotIndexSetInteger(1, PLOT_ARROW, 234);
   SetIndexBuffer(2, NoiseBuy, INDICATOR_DATA);  PlotIndexSetInteger(2, PLOT_ARROW, 251);
   SetIndexBuffer(3, NoiseSell, INDICATOR_DATA); PlotIndexSetInteger(3, PLOT_ARROW, 251);

   // Get Indicator Handles
   handle_fast = iMA(_Symbol, _Period, FastEMA, 0, MODE_EMA, PRICE_CLOSE);
   handle_slow = iMA(_Symbol, _Period, SlowEMA, 0, MODE_EMA, PRICE_CLOSE);
   handle_adx  = iADX(_Symbol, _Period, ADX_Period);

   if(handle_fast == INVALID_HANDLE || handle_slow == INVALID_HANDLE || handle_adx == INVALID_HANDLE)
     {
      Print("Error creating indicator handles.");
      return(INIT_FAILED);
     }

   // Set Arrays to evaluate backwards (latest bar = index 0)
   ArraySetAsSeries(BuySignal, true); ArraySetAsSeries(SellSignal, true);
   ArraySetAsSeries(NoiseBuy, true);  ArraySetAsSeries(NoiseSell, true);
   ArraySetAsSeries(FastEmaArr, true); ArraySetAsSeries(SlowEmaArr, true); ArraySetAsSeries(AdxArr, true);

   IndicatorSetString(INDICATOR_SHORTNAME, "CEO Signal vs Noise");
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], 
                const double &open[], const double &high[], const double &low[], 
                const double &close[], const long &tick_volume[], const long &volume[], 
                const int &spread[])
  {
   int limit = rates_total - prev_calculated;
   if(limit == 0) limit = 1;
   if(prev_calculated == 0) limit = rates_total - 3;
   
   ArraySetAsSeries(high, true); ArraySetAsSeries(low, true);

   // Copy Indicator Data to arrays
   if(CopyBuffer(handle_fast, 0, 0, limit + 2, FastEmaArr) <= 0) return 0;
   if(CopyBuffer(handle_slow, 0, 0, limit + 2, SlowEmaArr) <= 0) return 0;
   if(CopyBuffer(handle_adx, 0, 0, limit + 2, AdxArr) <= 0) return 0;

   // Start looping from completed bars
   for(int i = limit; i >= 1; i--)
     {
      bool crossUp = (FastEmaArr[i] > SlowEmaArr[i] && FastEmaArr[i+1] <= SlowEmaArr[i+1]);
      bool crossDn = (FastEmaArr[i] < SlowEmaArr[i] && FastEmaArr[i+1] >= SlowEmaArr[i+1]);

      BuySignal[i] = EMPTY_VALUE; SellSignal[i] = EMPTY_VALUE;
      NoiseBuy[i] = EMPTY_VALUE;  NoiseSell[i] = EMPTY_VALUE;

      double offset = (high[i] - low[i]) * 0.3; // Visual offset

      if(crossUp)
        {
         if(AdxArr[i] > ADX_Threshold) BuySignal[i] = low[i] - offset;
         else NoiseBuy[i] = low[i] - offset;
        }
      else if(crossDn)
        {
         if(AdxArr[i] > ADX_Threshold) SellSignal[i] = high[i] + offset;
         else NoiseSell[i] = high[i] + offset;
        }
     }
   return(rates_total);
  }

[FTtrader]

Installation Steps

1.) Open MetaTrader 4 or MetaTrader 5.

2.) Press F4 to open the MetaEditor.

3.) In the Navigator window, right-click on the Indicators folder -> New -> Custom Indicator.

4.) Name it CEO_Signal_vs_Noise, click next until finished.

5.) Delete the auto-generated code and paste the respective MT4 or MT5 code above.

6.) Click Compile (F7) at the top.

7.) Close MetaEditor, go to your MT4/MT5 platform, and drag the new indicator from the Navigator window onto your chart.

[FTtrader]

Here is the C# code for cTrader (which uses cAlgo).

In cTrader, instead of using indicator buffers, it is often cleaner to draw directly on the chart using icons and text so you can get exact placement. This script will draw Up/Down arrows for valid signals and a gray "X" for noise.

cTrader (C#) Implementation

Code: Select all

using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class CEOSignalVsNoise : Indicator
    {
        // --- Inputs: Setting the CEO's Parameters ---
        [Parameter("Fast EMA Length", Group = "Moving Averages", DefaultValue = 9, MinValue = 1)]
        public int FastPeriods { get; set; }

        [Parameter("Slow EMA Length", Group = "Moving Averages", DefaultValue = 21, MinValue = 1)]
        public int SlowPeriods { get; set; }

        [Parameter("ADX Length", Group = "Noise Filter", DefaultValue = 14, MinValue = 1)]
        public int AdxPeriods { get; set; }

        [Parameter("ADX Threshold", Group = "Noise Filter", DefaultValue = 20.0, MinValue = 0)]
        public double AdxThreshold { get; set; }

        // --- Internal Indicators ---
        private ExponentialMovingAverage _fastEma;
        private ExponentialMovingAverage _slowEma;
        private DirectionalMovementSystem _adx;

        protected override void Initialize()
        {
            // Initialize the built-in indicators
            _fastEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, FastPeriods);
            _slowEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, SlowPeriods);
            _adx = Indicators.DirectionalMovementSystem(AdxPeriods);
        }

        public override void Calculate(int index)
        {
            // Wait until we have enough data to calculate everything
            if (index < SlowPeriods || index < AdxPeriods || index < 1) 
                return;

            // 1. Spotting Potential Opportunities (Crossovers)
            bool crossedUp = _fastEma.Result[index] > _slowEma.Result[index] && _fastEma.Result[index - 1] <= _slowEma.Result[index - 1];
            bool crossedDown = _fastEma.Result[index] < _slowEma.Result[index] && _fastEma.Result[index - 1] >= _slowEma.Result[index - 1];

            // If nothing happened, skip to the next bar
            if (!crossedUp && !crossedDown)
                return;

            // 2. Measure the Noise
            double currentAdx = _adx.ADX[index];
            
            // Dynamic spacing so icons don't touch the candles directly
            double offset = (Bars.HighPrices[index] - Bars.LowPrices[index]) * 0.3;
            
            // Unique name for each drawing object based on the bar index
            string objectName = "CEO_Filter_" + index;

            // 3. Business Logic Execution
            if (crossedUp)
            {
                if (currentAdx > AdxThreshold)
                {
                    // Actual Signal
                    Chart.DrawIcon(objectName, ChartIconType.UpArrow, index, Bars.LowPrices[index] - offset, Color.LimeGreen);
                }
                else
                {
                    // Noise
                    Chart.DrawText(objectName, "X", index, Bars.LowPrices[index] - offset, Color.Gray);
                }
            }
            else if (crossedDown)
            {
                if (currentAdx > AdxThreshold)
                {
                    // Actual Signal
                    Chart.DrawIcon(objectName, ChartIconType.DownArrow, index, Bars.HighPrices[index] + offset, Color.Red);
                }
                else
                {
                    // Noise
                    Chart.DrawText(objectName, "X", index, Bars.HighPrices[index] + offset, Color.Gray);
                }
            }
        }
    }
}

[FTtrader]

Installation Steps for cTrader:

1.) Open cTrader and click on the Automate tab (the robot icon on the left menu).

2.) Look at the left panel, expand the Indicators list, right-click on it and select New Indicator.

3.) Name it CEOSignalVsNoise.

4.) Delete the default code that appears in the editor, and paste the code above.

5.) Click the Build button (the hammer icon at the top of the editor window) or press Ctrl+B.

6.) Switch back to your Trade view, open a chart, right-click -> Indicators -> Custom, and select your new CEOSignalVsNoise indicator to add it to the chart.