Pine Script: How to Implement Stop Loss and Take Profit Orders?

Welcome, fellow Pine Script developers and quantitative traders. Implementing robust risk management directly within your TradingView strategies is paramount. Stop loss (SL) and take profit (TP) orders are fundamental tools for controlling risk and locking in gains. This article dives into the technical details of implementing these order types effectively in Pine Script.

Understanding Stop Loss and Take Profit Orders

At their core, stop loss and take profit orders are instructions to your broker to close an open position when a specific price level is reached. A stop loss order aims to limit potential losses on a position by closing it automatically if the price moves unfavorably past a set point. Conversely, a take profit order is designed to secure profits by closing a position when the price reaches a predefined profitable level.

These orders are conditional entries into the market to exit an existing position. They are crucial components of any disciplined trading plan, helping to remove emotional biases from exit decisions and ensuring consistent application of your strategy’s risk/reward parameters.

Why Use Stop Loss and Take Profit in TradingView Pine Script?

Integrating SL and TP logic directly into your Pine Script strategy offers significant advantages for backtesting and automated trading. It allows you to:

• Quantify Risk and Reward: Precisely define and test the profitability of your strategy under varying risk/reward scenarios.
• Automate Execution: Ensure trades are exited according to your rules, even when you are not actively monitoring the market.
• Improve Backtesting Accuracy: Simulate realistic trading outcomes by accounting for exits based on price levels, not just time or arbitrary conditions.
• Develop Robust Strategies: Build more resilient systems that handle adverse price movements systematically.

Simply signaling entries without defining concrete exit criteria based on price significantly reduces the robustness and realism of your backtesting results. A strategy isn’t complete without clear exit rules.

Basic Syntax and Structure for Order Placement in Pine Script

Pine Script strategies primarily use the strategy() function for overall configuration and functions like strategy.entry(), strategy.exit(), and strategy.close() for managing positions. While strategy.entry() initiates a position and strategy.close() closes an entire position based on conditions, strategy.exit() is the most versatile function for implementing SL and TP.

strategy.exit() allows you to define exit conditions relative to an entry. It can be used to set a stop loss based on a fixed price, a number of ticks, or an ATR multiple, and similarly for take profit based on price or ticks. A single strategy.exit() call can manage both SL and TP for a specific entry or multiple entries.

strategy("My Strategy", overlay=true)

// Example entry condition
longCondition = close > ta.sma(close, 20)

if longCondition
    strategy.entry("LongEntry", strategy.long)

// Basic exit with SL and TP in ticks (for LongEntry)
// Assuming position is open
strategy.exit("ExitLong", from_entry="LongEntry", stop=strategy.position_avg_price - syminfo.mintick * 100, limit=strategy.position_avg_price + syminfo.mintick * 200)

// Note: 'stop' sets the SL price, 'limit' sets the TP price.
// Using 'loss' or 'profit' sets SL/TP in ticks or points from entry price.

Understanding how strategy.exit() links to specific entries (from_entry argument) or the entire open position is key to managing multiple positions or scaling in/out effectively.

Implementing Stop Loss Orders

Stop loss implementation is critical for capital preservation. Defining the stop level requires a logical basis.

Calculating Stop Loss Levels: ATR, Fixed Percentage, and Manual Input

Common methods for calculating stop loss levels include:

1. Fixed Percentage/Amount: Exiting when the price drops a certain percentage or fixed monetary amount from the entry price. Simple but doesn’t adapt to volatility.
2. ATR Multiple: Placing the stop a certain multiple of the Average True Range (ATR) away from the entry or a recent price extreme. This method is volatility-adaptive.
3. Technical Structure: Using support/resistance levels, swing highs/lows, or indicator values (e.g., below a moving average).
4. Manual Input: Allowing the user to specify a fixed price or distance via input variables.

For robust strategies, especially those trading different instruments or timeframes, volatility-based methods like ATR are often preferred.

// Example: Calculate ATR-based stop loss
atr_length = input.int(14, "ATR Length")
atr_multiple = input.float(2.0, "ATR Multiple")

atr_value = ta.atr(atr_length)

// For a long position entry price (strategy.position_avg_price)
long_stop_price = strategy.position_avg_price - atr_value * atr_multiple

// For a short position entry price
short_stop_price = strategy.position_avg_price + atr_value * atr_multiple

These calculated prices can then be used in strategy.exit().

Coding Stop Loss Logic in Pine Script: strategy.exit Function

The primary way to set a stop loss using strategy.exit() is by using the stop argument for a specific price level or the loss argument for a distance in ticks/points from the entry price.

// Example: Setting a stop loss at a calculated price for a long entry
entry_name = "LongEntry"
// ... calculation of long_stop_price ...

if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("SL_" + entry_name, from_entry=entry_name, stop=long_stop_price)

// Example: Setting a stop loss 100 ticks below entry price for a long entry
entry_name_ticks = "LongEntryTicks"
if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("SL_" + entry_name_ticks, from_entry=entry_name_ticks, loss=100)

Using strategy.datawindow_lookahead is a common practice within the strategy loop to prevent lookahead bias when calculations depend on current bar data that might change intraday. The from_entry argument is crucial when you might have multiple entries or scaled positions.

Adjusting Stop Loss Dynamically: Trailing Stop Loss Implementation

A trailing stop loss moves the stop level as the price moves favorably, locking in more profit while still providing protection. Implementing this in Pine Script involves updating the stop price on each bar based on the current price or a relevant indicator.

This requires keeping track of the current trailing stop level, typically using var variables to maintain state across bars.

// Example: Simple trailing stop loss for a long position
var float trailingStop = na

// Define distance from current price for trailing stop (e.g., ATR based)
trail_distance = ta.atr(14) * 3.0

if strategy.position_size > 0
    // Calculate potential new stop level: current price minus distance
    newStopLevel = close - trail_distance

    // If this is the first bar in the position or the new stop is higher than the current stop
    if na(trailingStop) or newStopLevel > trailingStop
        trailingStop := newStopLevel

    // Ensure the trailing stop is not above the current price (unless already hit)
    // and update the exit order
    strategy.exit("TrailExit", stop=trailingStop)
else
    // Reset trailing stop when position is closed
    trailingStop := na

The strategy.exit() function will automatically update an existing exit order if called again with the same id (or from_entry if no id is specified). The var keyword is essential here because trailingStop needs to remember its value from the previous bar.

Implementing Take Profit Orders

Take profit orders are used to capture gains and prevent profitable trades from turning into losers if the market reverses.

Setting Take Profit Levels: Risk-Reward Ratio and Technical Analysis

Methods for setting take profit levels include:

1. Fixed Target: A fixed price level or distance from the entry.
2. Risk-Reward Ratio: A multiple of the initial stop loss distance (e.g., 2:1 R:R means TP is twice the distance of the SL).
3. Technical Structure: Using resistance levels, pivot points, or indicator targets.
4. Time-Based: Exiting after a certain number of bars (though this is often done with strategy.close or conditional logic, not strategy.exit‘s limit argument).

Using a consistent risk-reward ratio is a fundamental aspect of many profitable strategies, providing a systematic way to define profit targets relative to the defined risk.

// Example: Calculate Take Profit based on Risk-Reward Ratio
risk_reward_ratio = input.float(2.0, "Risk-Reward Ratio")

// Assuming initial stop loss distance calculation is available
// For a long position, stop_distance = strategy.position_avg_price - long_stop_price
// For a short position, stop_distance = short_stop_price - strategy.position_avg_price

// Let's assume a calculated initial `stop_distance` from the entry price

// For a long position:
long_take_profit_price = strategy.position_avg_price + stop_distance * risk_reward_ratio

// For a short position:
short_take_profit_price = strategy.position_avg_price - stop_distance * risk_reward_ratio

These calculated prices serve as the limit argument for strategy.exit().

Coding Take Profit Logic in Pine Script: strategy.exit Function

Similar to stop loss, strategy.exit() handles take profit using the limit argument for a specific price or the profit argument for a distance in ticks/points from the entry price.

// Example: Setting a take profit at a calculated price for a long entry
entry_name = "LongEntry"
// ... calculation of long_take_profit_price ...

if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("TP_" + entry_name, from_entry=entry_name, limit=long_take_profit_price)

// Example: Setting a take profit 200 ticks above entry price for a long entry
entry_name_ticks = "LongEntryTicks"
if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("TP_" + entry_name_ticks, from_entry=entry_name_ticks, profit=200)

It’s important to use the correct argument (limit for price, profit for ticks/points) and ensure the from_entry argument matches the entry order name if you have multiple entries.

Combining Stop Loss and Take Profit for Balanced Risk Management

Usually, you’ll set both a stop loss and a take profit for the same position simultaneously. strategy.exit() allows you to specify both stop (or loss) and limit (or profit) in a single call.

// Example: Combined SL and TP for a long entry
entry_name = "Trade1"
// ... calculate long_stop_price and long_take_profit_price ...

if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("Exit_" + entry_name, from_entry=entry_name,
                 stop=long_stop_price, limit=long_take_profit_price)

This single call creates an OCO (One-Cancels-Other) order set for the specified entry. If either the stop loss or take profit price is hit, the entire position associated with that entry is closed, and the other order is cancelled. This is the standard and most efficient way to manage basic SL/TP pairs.

Advanced Techniques and Considerations

Beyond the basics, implementing sophisticated risk management requires addressing dynamic conditions and backtesting nuances.

Using Conditional Statements for Dynamic Order Management

While strategy.exit() is powerful, you might need more dynamic control. For instance, adjusting TP based on market phase or changing SL based on new information. This is done by calling strategy.exit() again with the same id (or from_entry) but updated stop or limit values, often inside if or switch statements.

// Example: Adjust TP based on time of day
var float current_tp = na

// Calculate base TP
base_tp = strategy.position_avg_price + calculated_tp_distance

// Dynamic adjustment
if hour(ta.timenow) >= 9 and hour(ta.timenow) < 12
    // Use base TP during active hours
    current_tp := base_tp
else
    // Use a tighter TP outside active hours
    current_tp := strategy.position_avg_price + calculated_tp_distance * 0.5 // Tighter target

// Call strategy.exit with the dynamic TP
if strategy.position_size > 0 and strategy.datawindow_lookahead
    strategy.exit("DynamicExit", limit=current_tp, stop=calculated_stop_price)

This pattern of calculating parameters dynamically per bar and passing them to strategy.exit() allows for sophisticated risk management logic.

Backtesting Stop Loss and Take Profit Strategies in TradingView

Pine Script’s backtesting engine is generally robust, but understanding how SL/TP orders interact with bar data is crucial. By default, strategy.exit() orders are processed on the current bar based on price action within that bar (Open, High, Low, Close). The calc_on_every_tick=true and calc_on_order_fills=true settings in strategy() can improve accuracy by calculating on more granular price updates, but they also increase calculation time.

• Intrabar Resolution: TradingView simulates intrabar price movement to determine if an SL/TP would have been hit. The order of hits within a bar depends on the bar type (historical vs. real-time) and data feed. For historical data, it typically assumes price moves from Open to High/Low/Close in a standard pattern.
• Plotting Levels: Always plot your calculated SL and TP levels on the chart using plot() to visually verify they are where you expect them to be.
• Backtest Properties: Carefully review the “Properties” tab in the Strategy Tester to see how commission, slippage, and pyramiding settings affect results, as these significantly impact net profit.

Be mindful that historical backtests are simulations. Live execution can differ due to real-time slippage and execution speed, especially with market orders triggered by SL/TP price levels.

Handling Slippage and Order Execution Considerations

Slippage occurs when the actual execution price of an order differs from the requested price. This is particularly relevant for stop loss orders, which are often triggered as market orders. If the price gaps past your stop level, you will be filled at the next available price, which could be significantly worse than your intended stop.

Pine Script backtesting attempts to simulate slippage (slippage argument in strategy()), but real-world slippage varies greatly depending on liquidity, market volatility, and broker execution quality.

• Limit Orders: Take profit orders placed with limit are limit orders. They will only fill at the specified price or better (lower for buy, higher for sell). If the price gaps over your TP, the order might not fill until the price comes back down.
• Stop Market Orders: Stop loss orders placed with stop act as stop market orders. When the stop price is reached, a market order is triggered, which fills at the best available price. This guarantees execution but not the price.

Consider the impact of potential slippage on your risk calculations. A backtested 1% stop loss might become a 1.5% or 2% loss in volatile real-world conditions.

Optimizing Stop Loss and Take Profit Levels for Different Market Conditions

Fixed SL/TP parameters often perform poorly across varying market conditions (trending, range-bound, volatile, calm). Optimization is key.

Instead of static values, consider making SL/TP parameters dynamic:

• Volatility Adaptive: Use indicators like ATR, Standard Deviation, or Volatility Index (VIX data if available for the asset) to adjust SL/TP distances. Wider stops/targets in high volatility, tighter in low volatility.
• Market Structure Adaptive: Adjust levels based on detected patterns (e.g., wider targets during strong trends, tighter stops in choppy ranges).
• Time Adaptive: Vary parameters based on time of day (e.g., wider during session overlaps) or day of week.
• Optimization Study: Use Pine Script’s built-in optimization features in the Strategy Tester to find optimal ranges for your input parameters, rather than fixed values. Be wary of over-optimization on historical data; test on out-of-sample data if possible.

Implementing these dynamic adjustments requires careful calculation and updating of the stop and limit arguments passed to strategy.exit() on each bar.

Practical Examples and Code Snippets

Let’s look at some practical code examples demonstrating the concepts discussed.

Example 1: Simple Stop Loss and Take Profit Strategy

This example implements a basic moving average crossover strategy with fixed percentage-based SL and TP.

//@version=5
strategy("MA Crossover with Fixed SL/TP", overlay=true,
     initial_capital=100000,
     pyramiding=0, // No pyramiding
     commission=0.0, // Example: No commission
     slippage=0) // Example: No slippage in backtest

// Inputs
short_ma_length = input.int(10, "Short MA Length")
long_ma_length = input.int(30, "Long MA Length")
stop_loss_pct = input.float(1.0, "Stop Loss %", minval=0.1) / 100
take_profit_pct = input.float(2.0, "Take Profit %", minval=0.1) / 100

// Calculate Moving Averages
short_ma = ta.sma(close, short_ma_length)
long_ma = ta.sma(close, long_ma_length)

// Entry Conditions
long_entry_condition = ta.crossover(short_ma, long_ma)
short_entry_condition = ta.crossunder(short_ma, long_ma)

// Strategy Entry
if long_entry_condition
    strategy.entry("Long", strategy.long)

if short_entry_condition
    strategy.entry("Short", strategy.short)

// Calculate SL/TP Prices
// Need to calculate based on entry price when a position is open
// We can use var to store entry price or use strategy.position_avg_price

// Use strategy.position_avg_price for simplicity here
var float entryPrice = na
if strategy.position_size != strategy.position_size[1]
    entryPrice := strategy.position_avg_price

// Calculate SL and TP prices only when a position is active
var float long_stop_price = na
var float long_tp_price = na
var float short_stop_price = na
var float short_tp_price = na

if strategy.position_size > 0
    // Long position calculations
    long_stop_price := entryPrice * (1 - stop_loss_pct)
    long_tp_price := entryPrice * (1 + take_profit_pct)
    // Ensure TP is above SL
    long_tp_price := math.max(long_tp_price, long_stop_price * 1.001)

    // Submit exit order for Long entry
    if strategy.datawindow_lookahead
        strategy.exit("ExitLong", from_entry="Long",
                     stop=long_stop_price, limit=long_tp_price)

else if strategy.position_size < 0
    // Short position calculations
    short_stop_price := entryPrice * (1 + stop_loss_pct)
    short_tp_price := entryPrice * (1 - take_profit_pct)
    // Ensure TP is below SL
    short_tp_price := math.min(short_tp_price, short_stop_price * 0.999)

    // Submit exit order for Short entry
    if strategy.datawindow_lookahead
        strategy.exit("ExitShort", from_entry="Short",
                     stop=short_stop_price, limit=short_tp_price)
else
    // Reset prices when flat
    entryPrice := na
    long_stop_price := na
    long_tp_price := na
    short_stop_price := na
    short_tp_price := na

// Plotting MA's (optional but good practice)
plot(short_ma, color=color.blue, title="Short MA")
plot(long_ma, color=color.red, title="Long MA")

// Plot SL/TP levels (optional)
plot(strategy.position_size > 0 ? long_stop_price : na, title="Long SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size > 0 ? long_tp_price : na, title="Long TP", color=color.green, style=plot.style_linebr)
plot(strategy.position_size < 0 ? short_stop_price : na, title="Short SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size < 0 ? short_tp_price : na, title="Short TP", color=color.green, style=plot.style_linebr)

This script calculates the SL/TP prices based on the entry price and the specified percentages whenever a position is active. strategy.exit is then called with these prices. The var keyword is used to store the entry price and calculated SL/TP prices across bars, ensuring they are available for the strategy.exit call on subsequent bars.

Example 2: Trailing Stop Loss with Fixed Take Profit

Combining a trailing stop with a fixed take profit provides dynamic downside protection while still aiming for a specific upside target.

//@version=5
strategy("Trail SL and Fixed TP", overlay=true)

// Inputs
entry_length = input.int(20, "Entry MA Length")
atr_length = input.int(14, "ATR Length for Trail")
trail_atr_multiple = input.float(3.0, "Trail ATR Multiple")
take_profit_atr_multiple = input.float(6.0, "TP ATR Multiple")

// Calculate Indicator
entry_ma = ta.sma(close, entry_length)
atr_value = ta.atr(atr_length)

// Entry Condition (Simple MA cross)
long_condition = ta.crossover(close, entry_ma)
short_condition = ta.crossunder(close, entry_ma)

// State variables for trailing stop and entry price
var float longTrailStop = na
var float shortTrailStop = na
var float lastEntryPrice = na

// Entry Logic
if long_condition
    strategy.entry("EnterLong", strategy.long)
    // Initialize trailing stop on entry
    lastEntryPrice := strategy.position_avg_price
    longTrailStop := strategy.position_avg_price - atr_value * trail_atr_multiple

if short_condition
    strategy.entry("EnterShort", strategy.short)
    // Initialize trailing stop on entry
    lastEntryPrice := strategy.position_avg_price
    shortTrailStop := strategy.position_avg_price + atr_value * trail_atr_multiple

// Update Trailing Stop and Calculate Fixed TP while position is open
if strategy.position_size > 0 // Long position
    // Update trailing stop: move it up if price allows
    newStop = close - atr_value * trail_atr_multiple
    longTrailStop := math.max(longTrailStop, newStop)

    // Calculate fixed TP based on initial risk (assuming risk is initial stop distance)
    initial_stop_distance = lastEntryPrice - (lastEntryPrice - atr_value * trail_atr_multiple)
    longTakeProfit = lastEntryPrice + initial_stop_distance * (take_profit_atr_multiple / trail_atr_multiple)

    // Exit order for long
    if strategy.datawindow_lookahead
        strategy.exit("ExitLong", from_entry="EnterLong", stop=longTrailStop, limit=longTakeProfit)

else if strategy.position_size < 0 // Short position
    // Update trailing stop: move it down if price allows
    newStop = close + atr_value * trail_atr_multiple
    shortTrailStop := math.min(shortTrailStop, newStop)

    // Calculate fixed TP based on initial risk
    initial_stop_distance = (lastEntryPrice + atr_value * trail_atr_multiple) - lastEntryPrice
    shortTakeProfit = lastEntryPrice - initial_stop_distance * (take_profit_atr_multiple / trail_atr_multiple)

    // Exit order for short
    if strategy.datawindow_lookahead
        strategy.exit("ExitShort", from_entry="EnterShort", stop=shortTrailStop, limit=shortTakeProfit)

else // Flat position
    longTrailStop := na
    shortTrailStop := na
    lastEntryPrice := na

// Plotting (optional)
plot(entry_ma, color=color.blue)
plot(strategy.position_size > 0 ? longTrailStop : na, title="Long Trail SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size > 0 ? longTakeProfit : na, title="Long TP", color=color.green, style=plot.style_linebr)
plot(strategy.position_size < 0 ? shortTrailStop : na, title="Short Trail SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size < 0 ? shortTakeProfit : na, title="Short TP", color=color.green, style=plot.style_linebr)

This script uses var variables to store the trailing stop level and updates it on every bar while a position is open. The math.max and math.min functions ensure the stop only moves in the favorable direction. The take profit is calculated once based on the initial entry risk.

Example 3: Dynamic Stop Loss and Take Profit Based on Volatility

This example shows how to make both SL and TP distances fully dynamic based on ATR, representing a volatility-adaptive approach.

//@version=5
strategy("Volatility Adaptive SL/TP", overlay=true)

// Inputs
entry_ma_length = input.int(20, "Entry MA Length")
vol_length = input.int(14, "Volatility (ATR) Length")
stop_loss_atr_mult = input.float(2.5, "SL ATR Multiple")
take_profit_atr_mult = input.float(5.0, "TP ATR Multiple")

// Calculate Indicators
entry_ma = ta.sma(close, entry_ma_length)
volatility = ta.atr(vol_length)

// Entry Conditions
long_entry_condition = ta.crossover(close, entry_ma)
short_entry_condition = ta.crossunder(close, entry_ma)

// Entry Logic
if long_entry_condition
    strategy.entry("EnterLong", strategy.long)

if short_entry_condition
    strategy.entry("EnterShort", strategy.short)

// Calculate Dynamic SL/TP prices per bar
// These calculations are relative to the current average position price
// and the current volatility value.

var float currentLongStop = na
var float currentLongTP = na
var float currentShortStop = na
var float currentShortTP = na

if strategy.position_size > 0
    // Long Position: SL below current price, TP above current price
    // Note: Using strategy.position_avg_price is often preferred 
    // when scaling or for more stability, but here using close for dynamic example
    long_stop_distance = volatility * stop_loss_atr_mult
    long_tp_distance = volatility * take_profit_atr_mult

    currentLongStop := strategy.position_avg_price - long_stop_distance
    currentLongTP := strategy.position_avg_price + long_tp_distance

    // Ensure TP > SL
    currentLongTP := math.max(currentLongTP, currentLongStop * 1.001)

    // Submit or update exit order
    if strategy.datawindow_lookahead
        strategy.exit("ExitLongDynamic", from_entry="EnterLong",
                     stop=currentLongStop, limit=currentLongTP)

else if strategy.position_size < 0
    // Short Position: SL above current price, TP below current price
    short_stop_distance = volatility * stop_loss_atr_mult
    short_tp_distance = volatility * take_profit_atr_mult

    currentShortStop := strategy.position_avg_price + short_stop_distance
    currentShortTP := strategy.position_avg_price - short_tp_distance

    // Ensure TP < SL
    currentShortTP := math.min(currentShortTP, currentShortStop * 0.999)

    // Submit or update exit order
    if strategy.datawindow_lookahead
        strategy.exit("ExitShortDynamic", from_entry="EnterShort",
                     stop=currentShortStop, limit=currentShortTP)
else
    // Reset prices when flat
    currentLongStop := na
    currentLongTP := na
    currentShortStop := na
    currentShortTP := na

// Plotting (optional)
plot(entry_ma, color=color.blue)
plot(strategy.position_size > 0 ? currentLongStop : na, title="Long Dynamic SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size > 0 ? currentLongTP : na, title="Long Dynamic TP", color=color.green, style=plot.style_linebr)
plot(strategy.position_size < 0 ? currentShortStop : na, title="Short Dynamic SL", color=color.red, style=plot.style_linebr)
plot(strategy.position_size < 0 ? currentShortTP : na, title="Short Dynamic TP", color=color.green, style=plot.style_linebr)

In this example, currentLongStop, currentLongTP, etc., are recalculated on every bar based on the latest volatility value and the current strategy.position_avg_price. Calling strategy.exit with these updated values effectively makes the SL/TP levels adapt dynamically. Notice the use of var to maintain the values across bars, although in this specific pattern, they are fully recalculated each bar the position is open. The var is still necessary to declare them outside the main if/else block that checks strategy.position_size.

Implementing stop loss and take profit orders correctly in Pine Script is a cornerstone of building reliable and testable trading strategies. Mastering strategy.exit() and understanding how to calculate and manage your exit prices, both statically and dynamically, is essential for controlling risk and defining your strategy’s profit potential.