Three White Soldiers

1. Introduction & Hook

The world of trading is filled with patterns, signals, and strategies. Among these, the Three White Soldiers pattern stands out as a beacon for bullish reversals. Traders across the globe, from Wall Street to independent retail investors, rely on this formation to identify strong upward momentum. But what makes the Three White Soldiers so powerful? How can you harness its potential using Pine Script, Python, Node.js, and even advanced AI techniques? This comprehensive guide will take you on a deep dive into the Three White Soldiers strategy, equipping you with the knowledge and tools to implement, test, and optimize it across multiple platforms and markets.

2. What is Three White Soldiers?

The Three White Soldiers is a bullish candlestick pattern that signals a potential reversal from a downtrend to an uptrend. It consists of three consecutive long-bodied bullish candles, each opening within or near the previous candle's real body and closing progressively higher. This pattern is widely regarded as a strong indicator of sustained buying pressure and is often used by traders to confirm the start of a new bullish trend.

• Candle 1: A bullish candle that closes higher than it opens, ideally after a downtrend.
• Candle 2: Another bullish candle that opens within the previous candle's body and closes higher.
• Candle 3: A third bullish candle, again opening within the previous body and closing at or near its high.

This pattern is most reliable when it appears after a pronounced downtrend or period of consolidation, indicating a strong shift in market sentiment from bearish to bullish.

3. Market Logic Behind the Strategy

The logic behind the Three White Soldiers pattern is rooted in market psychology. After a period of selling pressure, the appearance of three strong bullish candles suggests that buyers have taken control. Each candle represents a session where bulls have dominated, pushing prices higher and absorbing any remaining selling interest. The pattern's structure—each candle opening within the previous body and closing higher—demonstrates sustained buying and a lack of significant pullbacks, which is a hallmark of a robust trend reversal.

• First Candle: Signals the initial shift in momentum.
• Second Candle: Confirms the strength of buyers, as the close is higher and the open is within the previous body.
• Third Candle: Reinforces the trend, often attracting more buyers and triggering short covering.

Traders interpret this pattern as a sign to enter long positions, anticipating further upward movement. However, context is crucial—volume, preceding trend, and overall market conditions must be considered to avoid false signals.

4. Mathematical Foundation & Formula

While the Three White Soldiers is primarily a visual pattern, it can be defined mathematically for algorithmic detection. The key criteria are:

• Each of the three consecutive candles must be bullish (close > open).
• Each candle must open within the real body of the previous candle (open2 >= open1 and open2 <= close1, etc.).
• Each candle must close higher than the previous candle's close.
• The candles should not have long upper wicks (to avoid exhaustion signals).

// Pseudocode for Three White Soldiers detection
is_bullish1 = close[2] > open[2]
is_bullish2 = close[1] > open[1]
is_bullish3 = close > open
open2_in_body1 = open[1] >= open[2] and open[1] <= close[2]
open3_in_body2 = open >= open[1] and open <= close[1]
close2_higher = close[1] > close[2]
close3_higher = close > close[1]
three_white_soldiers = is_bullish1 and is_bullish2 and is_bullish3 and open2_in_body1 and open3_in_body2 and close2_higher and close3_higher

These rules can be adjusted for stricter or looser pattern recognition, depending on your trading style and risk tolerance.

5. Step-by-Step Calculation Example

Let’s walk through a practical example using sample price data:

• Candle 1: Open = 100, Close = 105
• Candle 2: Open = 104, Close = 110
• Candle 3: Open = 109, Close = 115

1. All three candles are bullish: 105 > 100, 110 > 104, 115 > 109
2. Candle 2 opens within Candle 1’s body: 104 is between 100 and 105
3. Candle 3 opens within Candle 2’s body: 109 is between 104 and 110
4. Candle 2 closes higher than Candle 1: 110 > 105
5. Candle 3 closes higher than Candle 2: 115 > 110

All conditions are met, so this sequence qualifies as a Three White Soldiers pattern.

6. Pine Script Implementation

Pine Script is the scripting language of TradingView, making it ideal for implementing and visualizing the Three White Soldiers strategy. Below is a well-commented Pine Script example:

//@version=6
strategy("Three White Soldiers Strategy", overlay=true)

// Detect Three White Soldiers pattern
bull1 = close[2] > open[2]
bull2 = close[1] > open[1]
bull3 = close > open
open2_in_body1 = open[1] >= open[2] and open[1] <= close[2]
open3_in_body2 = open >= open[1] and open <= close[1]
close2_higher = close[1] > close[2]
close3_higher = close > close[1]
pattern = bull1 and bull2 and bull3 and open2_in_body1 and open3_in_body2 and close2_higher and close3_higher

// Plot signals
plotshape(pattern, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Three White Soldiers")

// Example entry
if pattern
    strategy.entry("Long", strategy.long)

This script highlights the pattern on the chart and enters a long position when detected. You can further customize it with alerts, filters, and risk management rules.

7. Parameters & Customization in Pine Script

Customization is key to adapting the Three White Soldiers strategy to different markets and timeframes. Here are some parameters you can tweak:

• Minimum candle body size: Filter out weak candles by requiring a minimum body-to-range ratio.
• Maximum upper wick length: Avoid exhaustion candles by limiting upper wick size.
• Volume filter: Only consider patterns with above-average volume.
• Lookback window: Adjust how far back you search for the pattern.

//@version=6
strategy("Customizable Three White Soldiers", overlay=true)
min_body = input.float(0.6, "Min Body Ratio", step=0.05)
max_upper_wick = input.float(0.3, "Max Upper Wick Ratio", step=0.05)
vol_filter = input.bool(true, "Use Volume Filter")

body1 = math.abs(close[2] - open[2])
range1 = high[2] - low[2]
upper_wick1 = high[2] - math.max(close[2], open[2])

body2 = math.abs(close[1] - open[1])
range2 = high[1] - low[1]
upper_wick2 = high[1] - math.max(close[1], open[1])

body3 = math.abs(close - open)
range3 = high - low
upper_wick3 = high - math.max(close, open)

body_ok = body1/range1 >= min_body and body2/range2 >= min_body and body3/range3 >= min_body
wick_ok = upper_wick1/range1 <= max_upper_wick and upper_wick2/range2 <= max_upper_wick and upper_wick3/range3 <= max_upper_wick
vol_ok = not vol_filter or (volume > ta.sma(volume, 20))

pattern = bull1 and bull2 and bull3 and open2_in_body1 and open3_in_body2 and close2_higher and close3_higher and body_ok and wick_ok and vol_ok

plotshape(pattern, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Three White Soldiers")

These parameters allow you to fine-tune the pattern detection to suit your trading preferences.

8. Python & FastAPI + NoSQL Implementation

For algorithmic traders and quants, implementing the Three White Soldiers strategy in Python enables backtesting, automation, and integration with modern data pipelines. Here’s how you can detect the pattern using Python and expose it via a FastAPI endpoint, storing results in a NoSql Database like MongoDB.

# three_white_soldiers.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List
from pymongo import MongoClient

app = FastAPI()
client = MongoClient("mongodb://localhost:27017/")
db = client["trading"]
collection = db["patterns"]

class Candle(BaseModel):
    open: float
    high: float
    low: float
    close: float
    volume: float

@app.post("/detect")
def detect_three_white_soldiers(candles: List[Candle]):
    if len(candles) < 3:
        raise HTTPException(status_code=400, detail="Need at least 3 candles")
    c1, c2, c3 = candles[-3:]
    bull1 = c1.close > c1.open
    bull2 = c2.close > c2.open
    bull3 = c3.close > c3.open
    open2_in_body1 = c2.open >= c1.open and c2.open <= c1.close
    open3_in_body2 = c3.open >= c2.open and c3.open <= c2.close
    close2_higher = c2.close > c1.close
    close3_higher = c3.close > c2.close
    pattern = all([bull1, bull2, bull3, open2_in_body1, open3_in_body2, close2_higher, close3_higher])
    result = {"pattern": pattern}
    collection.insert_one({"candles": [c1.dict(), c2.dict(), c3.dict()], "pattern": pattern})
    return result

This API can be integrated into trading bots, dashboards, or analytics pipelines. The use of MongoDB allows for scalable storage and retrieval of detected patterns.

9. Node.js / JavaScript Implementation

JavaScript is widely used for web-based trading dashboards and bots. Here’s a Node.js implementation for detecting the Three White Soldiers pattern:

// threeWhiteSoldiers.js
function isThreeWhiteSoldiers(candles) {
  if (candles.length < 3) return false;
  const [c1, c2, c3] = candles.slice(-3);
  const bull1 = c1.close > c1.open;
  const bull2 = c2.close > c2.open;
  const bull3 = c3.close > c3.open;
  const open2InBody1 = c2.open >= c1.open && c2.open <= c1.close;
  const open3InBody2 = c3.open >= c2.open && c3.open <= c2.close;
  const close2Higher = c2.close > c1.close;
  const close3Higher = c3.close > c2.close;
  return bull1 && bull2 && bull3 && open2InBody1 && open3InBody2 && close2Higher && close3Higher;
}

// Example usage
const candles = [
  { open: 100, close: 105 },
  { open: 104, close: 110 },
  { open: 109, close: 115 }
];
console.log(isThreeWhiteSoldiers(candles)); // true

This function can be integrated into trading bots, browser-based charting tools, or serverless functions for real-time pattern detection.

10. Backtesting & Performance Insights

Backtesting is essential for validating the effectiveness of any trading strategy. By simulating trades based on historical data, you can assess the Three White Soldiers pattern’s win rate, average return, drawdown, and risk-adjusted performance.

• Data Preparation: Use clean, high-quality OHLCV data.
• Pattern Detection: Apply the detection logic to historical candles.
• Trade Simulation: Enter long positions when the pattern appears, exit based on predefined rules (e.g., stop-loss, take-profit, trailing stop).
• Performance Metrics: Calculate metrics such as Sharpe ratio, maximum drawdown, and expectancy.

# Python pseudocode for backtesting
for i in range(2, len(candles)):
    if is_three_white_soldiers(candles[i-2:i+1]):
        entry_price = candles[i].close
        # Simulate exit, e.g., after 5 bars or at stop-loss
        ...

Backtesting results may vary across assets and timeframes. It’s crucial to optimize parameters and validate on out-of-sample data to avoid overfitting.

11. Risk Management Integration

Effective risk management is the cornerstone of successful trading. Integrating position sizing, stop-loss, and take-profit mechanisms with the Three White Soldiers strategy helps protect capital and lock in profits.

• Position Sizing: Calculate position size based on account equity and risk per trade.
• Stop-Loss: Place a stop-loss below the low of the first candle or a fixed percentage.
• Take-Profit: Set a target based on risk-reward ratio or trailing stop.

// Pine Script example with risk management
risk_per_trade = input.float(1, "Risk % per Trade", step=0.1)
account_size = 10000 // Example account size
risk_amount = account_size * risk_per_trade / 100
stop_loss = low[2] // Below first candle
entry = close
qty = risk_amount / (entry - stop_loss)
if pattern
    strategy.entry("Long", strategy.long, qty=qty)
    strategy.exit("TP/SL", from_entry="Long", stop=stop_loss, limit=entry + (entry - stop_loss) * 2)

This approach ensures that each trade risks only a small portion of your capital, preserving your account during losing streaks.

12. Combining with Other Indicators

The Three White Soldiers pattern can be enhanced by combining it with other technical indicators:

• Moving Averages: Confirm the trend direction.
• RSI: Avoid overbought conditions.
• Volume: Validate the strength of the pattern.
• Bollinger Bands: Identify volatility and potential breakouts.

// Pine Script: Combine with RSI
rsi = ta.rsi(close, 14)
pattern_with_rsi = pattern and rsi < 70
if pattern_with_rsi
    strategy.entry("Long", strategy.long)

Combining signals can reduce false positives and improve overall strategy performance.

13. Multi-Timeframe & Multi-Asset Usage

The versatility of the Three White Soldiers strategy allows it to be applied across various timeframes and asset classes:

• Timeframes: 1-minute, 15-minute, hourly, daily, weekly
• Assets: Equities, forex, cryptocurrencies, commodities, options

To implement multi-timeframe analysis in Pine Script:

// Pine Script: Multi-timeframe confirmation
higher_tf = input.timeframe("D", "Higher Timeframe")
higher_close = request.security(syminfo.tickerid, higher_tf, close)
higher_pattern = request.security(syminfo.tickerid, higher_tf, pattern)
if pattern and higher_pattern
    strategy.entry("Long", strategy.long)

This approach increases the reliability of signals by requiring confirmation across timeframes.

14. AI/ML Enhancements

Artificial Intelligence and Machine Learning can take the Three White Soldiers strategy to the next level:

• Feature Engineering: Use the pattern as a feature in predictive models.
• Parameter Optimization: Employ reinforcement learning (RL) agents to optimize detection thresholds and risk parameters.
• Pattern Clustering: Use unsupervised learning to discover variations and related bullish patterns.

# Python: RL agent optimizing parameters
import gym
class ThreeWhiteSoldiersEnv(gym.Env):
    ... # Define state, action, reward based on pattern detection and trade outcome
# Train RL agent to maximize returns by tuning parameters

Integrating AI can help adapt the strategy to changing market conditions and uncover hidden alpha.

15. Automation with Playwright/Jest

Automated testing ensures the reliability of your strategy scripts. playwright and Jest are powerful tools for end-to-end and unit testing:

• Playwright: Automate browser-based testing of trading dashboards.
• Jest: Unit test pattern detection logic in JavaScript/TypeScript.

// Jest unit test for pattern detection
const { isThreeWhiteSoldiers } = require('./threeWhiteSoldiers');
test('detects Three White Soldiers', () => {
  const candles = [
    { open: 100, close: 105 },
    { open: 104, close: 110 },
    { open: 109, close: 115 }
  ];
  expect(isThreeWhiteSoldiers(candles)).toBe(true);
});

Automated tests catch bugs early and ensure your strategy performs as expected in production environments.

16. Advanced Variations

Advanced traders often modify the Three White Soldiers pattern to suit specific markets or trading styles:

• Four or Five Soldiers: Require more consecutive bullish candles for stronger confirmation.
• Volume-weighted Soldiers: Only count candles with above-average volume.
• Hybrid Patterns: Combine with engulfing or hammer patterns for additional confirmation.
• Adaptive Thresholds: Dynamically adjust body and wick ratios based on volatility.

Experimenting with these variations can help you discover unique edges and tailor the strategy to your needs.

17. Common Pitfalls & Misconceptions

• Ignoring Context: The pattern is less reliable in sideways or overbought markets.
• Overfitting: Excessive parameter tuning can lead to poor out-of-sample performance.
• Neglecting Risk: Failing to use stop-losses can result in large losses during false signals.
• Confirmation Bias: Seeing the pattern where it doesn’t exist due to subjective interpretation.

Always validate the pattern with additional indicators and sound risk management.

18. Conclusion & Key Takeaways

The Three White Soldiers strategy is a time-tested tool for identifying bullish reversals. By understanding its market logic, mathematical foundation, and implementation across multiple platforms, you can harness its power in your trading arsenal. Remember to combine it with robust risk management, backtesting, and, where possible, AI-driven optimization. Adapt the strategy to your preferred assets and timeframes, and always remain vigilant for changing market conditions. With discipline and continuous learning, the Three White Soldiers can help you capture significant upside in trending markets.

Glossary of Key Terms

• Bullish Candle: A candlestick where the close is higher than the open.
• Real Body: The area between the open and close of a candle.
• Wick (Shadow): The thin lines above and below the body, representing high and low prices.
• Backtesting: Simulating trades on historical data to evaluate strategy performance.
• Risk Management: Techniques to control losses and protect capital.
• Multi-Timeframe Analysis: Using signals from different chart timeframes for confirmation.
• Reinforcement Learning: A type of machine learning where agents learn to make decisions by trial and error.

Comparison Table