Use this article to understand how trailing stop-loss management works in the Builder.

This includes:

Also known as: trailing stop, trail stop loss, move stop loss after 10 pips, breakeven stop loss, lock in profit, fixed-pip trailing, Modify SL/TP, Check Profit/Loss, stop-loss management, trade management template.

A trailing stop-loss component does not open trades.

It manages trades that already exist.

The basic structure is:

The most important point:

Before modifying a stop loss, the EA must know which trade is in scope. That is why management templates usually use Select Trades before Modify SL/TP.

Main template for this article:

Trailing Stop / fixed-pip staged trailing template

Other related management templates from the video:

Lock in profits

Partial profit taking management

Candle high/low management

Trailing stop / moving-average style

Trailing stop management updates the stop loss of an existing trade after a condition is met.

Examples:

The exact rule depends on the blocks you use.

The Builder does not force one trailing-stop style. You decide what triggers the stop-loss update and where the new stop loss should be placed.

Runs the management logic once when a new candle forms.

This is useful when you only want to update the stop loss once per candle, for example at every candle close or new candle open.

Most trailing stop examples use Run per Candle because it keeps the management logic controlled and easier to debug.

Runs the logic on every market price update.

This can be useful for reset logic, for example when you want to detect quickly that no trade is open anymore and reset a variable.

Be careful with Run per Tick. It can trigger very frequently.

Compares two values.

In trailing-stop templates, Trade Rule is often used to check whether a variable is active or inactive.

Example:

OnOff = 0

This means the first trailing step is still allowed.

Example:

OnOff = 1

This means the first trailing step already happened and the next trailing step can now be checked.

Selects which trades the following management blocks should affect.

This is mandatory in most trade management logic.

You can filter by:

Example:

If your component should only manage sell trades, use Select Sell Trades.

If your component should only manage trades from one specific strategy, use a group number.

Do not skip this block. Without a clean selection step, you may manage the wrong trades or make the logic harder to control.

Checks whether the selected trade is in enough profit or loss.

Examples:

This block decides when the stop-loss management should activate.

Changes the stop loss and/or take profit of the selected trade.

In this article, we focus on stop loss only.

The stop loss can be adjusted in different ways, for example:

You can leave take profit unchanged if the template only manages the stop loss.

Updates a variable while the EA is running.

In the staged trailing example, a variable is used as an on/off switch.

Example:

This is useful when users want the EA to manage the stop loss multiple times in a controlled sequence.

This is the classic trailing stop style.

The logic:

Example:

If a trade is at least 1% in profit, the EA moves the stop loss to the EMA 20 value.

Then, on every new candle, the EA checks again. If the condition is still true, the stop loss is updated again based on the latest moving average value.

This is useful when you want the stop loss to follow market structure or trend movement instead of using a fixed pip distance.

Template link: https://app.profectus.ai/TC_kzYhC0hMmBBqQcwneXZp05r-SbSCO?utm_source=share

This is the new fixed-pip example.

The goal:

When a sell trade reaches 10 pips in profit, adjust the stop loss using a fixed-pip setting.

In the example template, the first stop-loss adjustment uses 50 pips.

The logic:

Template link: https://app.profectus.ai/K3hh-umI6VO76OybWWYVTDdv_VwAQXan?utm_source=share

The OnOff variable prevents the first stop-loss adjustment from being repeated forever.

By default:

OnOff = 0

This means the first step is still allowed.

Once the trade reaches 10 pips in profit and the stop loss is adjusted, the template changes the variable:

OnOff = 1

Now the first decision tree is blocked, and the second decision tree can take over.

This is how you turn specific parts of your trade management logic on and off while the EA is running.

The second stage starts after the first stage has already happened.

The goal:

When the selected sell trade reaches 20 pips in profit, tighten the stop loss further.

In the example template, the second stop-loss adjustment uses 20 pips.

The logic:

Template link: https://app.profectus.ai/K3hh-umI6VO76OybWWYVTDdv_VwAQXan?utm_source=share

This creates a simple two-step trailing model:

You can change the pip values and stop-loss settings to fit your own strategy logic.

The staged trailing logic uses a variable.

That variable also needs to be reset.

If the trade closes because of stop loss, take profit, or manual closure, the trade count goes back to zero.

The reset tree checks for this and sets the variable back to zero.

The logic:

This prepares the component for the next trade.

Without this reset, the EA may stay stuck at OnOff = 1, meaning the first trailing step would not activate correctly for the next trade.

Important:

Make sure Count Trades uses the same scope as the trades you manage.

If the trailing component manages only sell trades, the reset logic should also check the relevant sell trades. If your strategy uses group numbers or symbols, keep the filters consistent.

The updated fixed-pip template uses three decision trees because each tree has a separate job.

This tree waits for 10 pips in profit.

Then it adjusts the stop loss and switches OnOff from 0 to 1.

This tree only becomes active after OnOff = 1.

Then it waits for 20 pips in profit and adjusts the stop loss again.

This tree checks whether the trade is closed.

If no relevant trade is open anymore, it resets OnOff back to 0.

This makes the component reusable for the next trade.

Breakeven trailing is a simpler version of stop-loss management.

The idea:

When a trade reaches a defined profit threshold, move the stop loss to the entry price.

Example:

If a trade reaches 1% profit, move stop loss to breakeven.

The logic:

This can help prevent a winning trade from turning into a full losing trade.

Important:

Breakeven does not guarantee zero loss in every real trading situation. Spread, slippage, execution quality, and broker conditions can still affect the final result.

Template link: https://app.profectus.ai/oWKU97H9O7aBZc30KDaltjF7YfdVO5BY?utm_source=share

Lock-in profit management goes one step further than breakeven.

Instead of moving stop loss to the entry price, the EA moves the stop loss beyond the entry price to secure a profit if price reverses.

Example:

If a trade reaches 2% profit, move the stop loss to lock in 1% profit.

The logic:

For buy trades, the stop loss is moved above the entry price.

For sell trades, the stop loss is moved below the entry price.

Template link: https://app.profectus.ai/FQq2RGNIecRmf_VW9SpN1s2DkkTjuSUY?utm_source=share

Candle high/low trailing uses candle structure instead of fixed pips or an indicator.

Example:

For a buy trade, the EA may move the stop loss to a previous candle low.

For a sell trade, the EA may move the stop loss to a previous candle high.

The logic:

This can make sense when you want the stop loss to follow recent market structure.

Template link: https://app.profectus.ai/pURKnOdlxVsCP1VOVRSdXuhQdqww8iW7?utm_source=share

Partial profit taking and trailing stops are different management styles.

Partial profit taking closes part of the trade.

Trailing stop management keeps the trade open but changes the stop loss.

Example:

Partial profit taking:

Trailing stop:

You can combine both, but test carefully. Too many management rules can conflict or make the results harder to understand.

Modify SL/TP needs to know which trade to manage.

Use Select Trades before management actions.

If you only want to manage sell trades, select sell trades.

If you only want to manage one strategy, use group numbers.

Buy and sell trades need different stop-loss logic.

For buys, stop losses usually move upward as price moves in profit.

For sells, stop losses usually move downward as price moves in profit.

Make sure your template matches the trade direction your strategy actually uses.

Check Profit/Loss can be used in different ways.

A rule like “1% profit” is not the same as “10 pips in profit.”

Be clear about what you want:

If you use an on/off variable, reset it when the trade is closed.

Otherwise, the next trade may start with the wrong variable state.

In the staged trailing example, OnOff should go back to 0 once no matching trade is open anymore.

A single global OnOff variable is simple, but it is best suited for systems that manage one trade at a time.

If your EA can manage multiple trades at the same time, one shared variable may not be enough.

In that case, use stricter trade filters, group numbers, or a simpler management structure.

If the stop loss is moved too close to price too quickly, the trade may close before the setup has enough room to develop.

This is not a Builder issue. It is a strategy design issue.

Test different thresholds and stop-loss distances in MT5 before deciding which version to use.

If you combine breakeven, fixed-pip trailing, moving average trailing, partial profit taking, and lock-in profit, your logic can become messy fast.

Start with one management component.

Test it.

Then add the next layer only if you understand exactly what it changes.

Use MT5 Visual Mode to check the management behavior candle by candle.

Look for:

If something looks wrong, do not change everything at once.

Change one block setting, export again, and retest.

Use fixed pips when you want simple, measurable stop-loss movement.

Use breakeven when you want to reduce downside after a trade reaches a profit threshold.

Use lock-in profit when you want to secure part of the open profit after price has moved far enough.

Use moving average trailing when you want the stop loss to follow trend movement.

Use candle high/low trailing when you want the stop loss to follow recent price structure.

There is no universal best version.

The right version depends on your entry logic, timeframe, symbol, volatility, and risk model.

You can adjust:

Best practice:

Start simple.

Build one management component first. Confirm it works in Visual Mode. Then add more advanced layers.

Trailing stop management is built from a simple block pattern:

Run logic → Select Trades → Check Profit/Loss → Modify SL/TP

For simple trailing, this is enough.

For multi-step trailing, use variables.

In the staged fixed-pip example, the OnOff variable controls which part of the management logic is active:

This gives you a clean way to build stop-loss management that changes as the trade develops.

Templates are for educational purposes only. Always backtest and validate your logic before using it in live trading.