Which is better: Trailing Stop or Step Stop?

I used both simultaneously in my own strategy, and I'm sharing my experience from my account statements below. Take this information as an idea, as this table may change depending on the strategy. Consider it as information regarding the trades I made using R-based Trailing Stop and Sequence-based Step Stop methods.



1. Classic Trailing Stop
This method makes the Stop Loss (SL) level follow the price continuously and fluidly as it moves in your favor.

1. Relevant Parameters:
   1. trSt (trail_start_R): The amount of profit required to start the trailing (in terms of R).
   2. trDi (trail_dist_R): The distance to maintain between the Price and the Stop Loss (in terms of R).

2. How It Works:
   1. Let's look at the R_bP1 rule: trSt=1.2, trDi=0.6.
   2. When your profit reaches 1.2R, the tracking begins.
   3. The SL is moved to 0.6R behind the current price.
   4. For every 1 point the price moves up, the SL is instantly moved up by 1 point.

3. Metaphor: It is like towing a car with a rope. As the car (price) moves forward, as long as the rope is taut, the load behind it (SL) moves at the same speed and without interruption. If the car moves back, the rope goes slack, and the load remains in place.

2. Step Stop
This method moves the Stop Loss not continuously, but in jumps (discrete steps) once the price completes specific intervals.

1. Relevant Parameters:
   1. st (use_step_trail): Whether this feature is active (true/false).
   2. stI (step_interval_sk): The profit interval required to advance to a new step (in Sekanas).
   3. stS (step_size_sk): How much the SL will be moved up when a step is taken (in Sekanas).

2. How It Works:
   1. Let's look at the R_0P2 rule: st=true, stI=5.0, stS=2.5.
   2. While the price rises, the SL remains stationary initially.
   3. When the profit increases by 5.0 Sekanas (Interval), the SL is moved up by 2.5 Sekanas (Size) in a single move.
   4. Even if the profit is 9.9 Sekanas, the SL does not budge. However, when it reaches 10.0 Sekanas (the 2nd Interval), the SL jumps up another 2.5 Sekanas.

3. Metaphor: It is like climbing stairs. To move your foot (SL) to the next step, you must first lift your body (price) a certain amount. Your foot does not change position during the small movements in between.
   
   The most rational approach might be to combine "Classic Trailing Stop and Step Stop" methods (Hybrid Model), which provides the most efficient protection at different phases of the trend.
   The logic behind this approach is as follows:
   Early Phase (between 1R and 2R): The trend is not yet mature. Pullbacks may occur. With Classic Trailing, you follow the price closely and in a "fluid" manner.
   Mature Phase (after 2R): The trend has strengthened (momentum has likely increased). Step Stop can be used to avoid stop-loss orders during small corrections and to lock in profits in blocks.
   I will now work on this topic.
   
   Attached Image (click to enlarge)

   
   
   
   

From your table it looks like Step Stop has slightly better consistency (higher factor), but Classic Trailing caught the bigger runs in some cases. That’s what caught my attention.

Do you think the difference is coming from market structure?
Like maybe Classic performs better in clean trend phases, while Step Stop handles volatility and pullbacks better?

I’m actually curious did you test switching between them after 2R or some momentum threshold? A hybrid model might smooth the equity curve even more.
Would love to hear how you’re thinking about optimizing this next.

Actually, I've tried many complex strategies. But I think it makes more sense to choose based on the strategy. I'm still in the development phase. I have many options ahead, such as using both strategies or applying range and flow strategies depending on market conditions. I'm also currently working on determining stops using Heikin Ashi.
It takes a lot of time to code, test, and develop everything on my own. Maybe this can inspire experienced developers here, and they might see things I miss and contribute to the development. I'll continue to share useful information as I discover it. Good luck with your work.



void SetRule(ENUM_SOURCE_RULE r, string n, double tp, double beTr, double beOff, double trSt, double trDi, bool st, double stI, double stS) {
int i=(int)r; if(i<MAX_RULES) {
g_MasterLib[i].ruleName=n; g_MasterLib[i].tp_R=tp; g_MasterLib[i].be_trigger_R=beTr; g_MasterLib[i].be_offset_R=beOff;
g_MasterLib[i].trail_start_R=trSt; g_MasterLib[i].trail_dist_R=trDi; g_MasterLib[i].use_step_trail=st;
g_MasterLib[i].step_interval_sk=stI; g_MasterLib[i].step_size_sk=stS;
}
}
void InitMasterRules() {
ZeroMemory(g_MasterLib);
SetRule(R_0P1, "SAF_MOD", 0.0, 0.0, 0.0, 0.0, 0.0, false, 0, 0);
SetRule(R_0P2, "0P2", 0.0, 0.5, 0.1, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_0P3, "0P3", 0.0, 0.6, 0.1, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_0P4, "0P4", 4.0, 0.8, 0.2, 0.0, 0.0, true, 2.0, 1.0);
SetRule(R_0P4a, "0P4a", 4.0, 0.8, 0.2, 0.0, 0.0, true, 8.0, 4.0);
SetRule(R_bP1, "bP1", 3.0, 0.7, 0.1, 1.2, 0.6, false, 0, 0);
SetRule(R_bP2, "bP2", 5.0, 0.8, 0.2, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_bP3, "bP3", 8.0, 1.2, 0.2, 0.0, 0.0, true, 9.0, 7.5);
SetRule(R_bP3a, "bP3a", 8.0, 0.9, 0.2, 0.0, 0.0, true, 7.0, 3.5);
SetRule(R_bP4, "bP4", 0.0, 1.0, 0.2, 2.0, 1.0, true, 10.0, 5.0);
SetRule(R_bP4a, "bP4a", 10.0, 1.0, 0.25, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_sk1P4, "sk1P4", 0.0, 0.6, 0.1, 1.2, 0.22, false, 0, 0);
SetRule(R_sk1P4a, "sk1P4a", 0.0, 0.6, 0.1, 1.5, 0.35, false, 0, 0);
SetRule(R_sk3P3, "sk3P3", 0.0, 0.65, 0.1, 0.0, 0.0, true, 7.0, 3.5);
SetRule(R_sk3P4, "sk3P4", 0.0, 0.7, 0.1, 0.0, 0.0, true, 3.0, 1.5);
SetRule(R_gP4, "gP4", 0.0, 0.6, 0.1, 0.0, 0.0, true, 10.0, 2.0);
SetRule(R_sP4, "sP4", 6.0, 1.0, 0.2, 0.0, 0.0, true, 8.0, 6.0);
SetRule(R_uP2, "uP2", 0.0, 0.6, 0.1, 0.0, 0.0, true, 6.5, 3.25);
SetRule(R_uP3, "uP3", 6.0, 0.8, 0.1, 0.0, 0.0, true, 7.5, 4.75);
SetRule(R_uP4, "uP4", 0.0, 1.0, 0.1, 0.0, 0.0, true, 8.5, 5.25);
SetRule(R_idP3, "idP3", 4.5, 0.7, 0.1, 2.0, 1.0, false, 0, 0);
SetRule(R_idP4, "idP4", 3.5, 0.5, 0.1, 0.0, 0.0, true, 2.5, 1.25);
SetRule(R_sk2P2, "sk2P2", 8.0, 0.5, 0.1, 0.0, 0.0, true, 8.0, 4.0);
SetRule(R_sk2P2a, "sk2P2a", 0.0, 0.5, 0.1, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_sk2P3, "sk2P3", 0.0, 0.5, 0.1, 1.0, 0.3, true, 0, 0);
SetRule(R_sk2P3a, "sk2P3a", 0.0, 0.6, 0.1, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_sk2P4, "sk2P4", 12.0, 0.6, 0.1, 2.2, 0.8, false, 0, 0);
SetRule(R_fP1, "fP1", 1.5, 0.4, 0.1, 0.0, 0.0, true, 4.0, 2.0);
SetRule(R_fP2, "fP2", 2.5, 0.5, 0.1, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_fP3, "fP3", 0.0, 0.5, 0.1, 0.0, 0.0, true, 6.0, 2.0);
SetRule(R_gP1, "gP1", 0.0, 0.4, 0.0, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_gP2, "gP2", 0.0, 0.5, 0.0, 0.0, 0.0, true, 7.0, 3.5);
SetRule(R_gP3, "gP3", 4.0, 0.6, 0.1, 0.0, 0.0, true, 3.0, 1.5);
SetRule(R_sP1, "sP1", 2.0, 0.6, 0.1, 1.0, 0.5, false, 0, 0);
SetRule(R_sP2, "sP2", 0.0, 0.7, 0.1, 0.0, 0.0, true, 6.5, 3.0);
SetRule(R_sP3, "sP3", 3.5, 0.8, 0.2, 1.5, 0.8, false, 0, 0);
SetRule(R_uP1, "uP1", 0.0, 0.5, 0.1, 0.0, 0.0, true, 5.5, 2.75);
SetRule(R_idP1, "idP1", 2.0, 0.5, 0.1, 0.0, 0.0, true, 5.0, 2.5);
SetRule(R_idP2, "idP2", 3.0, 0.6, 0.1, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_sk1P1, "sk1P1", 0.0, 0.3, 0.05, 0.0, 0.0, true, 2.0, 1.0);
SetRule(R_sk1P1a, "sk1P1a", 0.0, 0.4, 0.05, 0.0, 0.0, true, 4.5, 2.0);
SetRule(R_sk1P2, "sk1P2", 0.0, 0.5, 0.05, 0.0, 0.0, true, 5.5, 2.5);
SetRule(R_sk1P3, "sk1P3", 2.5, 0.6, 0.1, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_sk2P1, "sk2P1", 5.0, 0.5, 0.1, 0.0, 0.0, true, 6.0, 3.0);
SetRule(R_sk3P1, "sk3P1", 0.0, 0.45, 0.1, 0.0, 0.0, true, 5.0, 2.5);
SetRule(ST1, "ST1_Opt_Scalper", 0.0, 0.5, 0.1, 1.0, 0.3, true, 0, 0);
SetRule(ST2, "ST2_Opt_Balanced", 0.0, 0.6, 0.1, 1.5, 0.5, true, 0, 0);
SetRule(ST3, "ST3_Opt_TrendRun", 0.0, 0.7, 0.1, 2.0, 0.8, true, 0, 0);
SetRule(ST4, "ST4_Opt_BigSwing", 15.0, 0.8, 0.2, 0.0, 0.0, true, 3.0, 1.5);
SetRule(ST11, "ST11_Opt_SmartScalp", 0.0, 0.4, 0.05, 0.8, 0.3, false, 0, 0);
SetRule(ST12, "ST12_Opt_TrendRider", 0.0, 0.5, 0.1, 1.5, 0.5, true, 0, 0);
SetRule(ST13, "ST13_Opt_DynTrail", 0.0, 0.6, 0.1, 2.0, 0.8, false, 0, 0);
SetRule(ST14, "ST14_Opt_SecuredRun", 0.0, 0.7, 0.2, 2.5, 1.0, true, 2.5, 1.5);
}

Many experienced traders find that a hybrid model is the most effective solution. The idea is to use different types of stops depending on the phase of the trade -4:

1. Early Phase (e.g., between 1R and 2R profit): Use a Classic Trailing Stop. In the beginning, the trend is not yet mature and pullbacks can occur. Trailing the price closely helps protect the initial profit.
2. Mature Phase (e.g., after 2R profit): Switch to a Step Stop. Once the trend has strengthened, you want to avoid being stopped out by small corrections. The step stop allows for these normal pullbacks while still moving your stop up in chunks to lock in profits.

How to Make Your Choice
To decide which stop is "better" for you, consider these factors in the context of your trading:

1. Your Trading Style: Are you a scalper or day trader who needs tight control? A classic trailing stop might be too sensitive. Are you a swing or position trader looking to capture big trends? A classic trailing stop could be your best friend.
2. Market Volatility: In a highly volatile market, a classic trailing stop is more likely to trigger prematurely due to sharp but temporary price spikes -2-9. A step stop can help you avoid this.
3. Your Risk Tolerance: Do you prefer the security of locking in profits tick-by-tick, or are you willing to give back some profit for a chance at a much larger move? A classic trailing stop secures profit continuously, while a step stop might give back a few pips between steps.

I hope this comparison helps you decide which tool is right for your trading toolbox.
To give you a more specific recommendation, could you tell me a bit about the types of strategies you typically trade (e.g., trend-following, range-bound) and the markets you're active in? This context can help in fine-tuning the approach.