Maximum Drawdown Explained: Calculate and Audit It in Python

The psychological and mathematical reality of drawdownsCopy Anchor Link

In algorithmic trading research, cumulative returns often monopolize the spotlight. Strategy decks prominently showcase attractive compound annual growth rates (CAGR) and smooth multi-year charts. Yet in quantitative finance and fund management, return is merely the reward for enduring risk—and drawdown dictates survival.

No trading system climbs monotonically. Between periodic equity peaks lie unavoidable declines where realized losses, adverse market regimes, or volatility shocks deplete strategy capital. Understanding and auditing drawdowns is essential because losses compound asymmetrically against the trader.

The Asymmetric Mathematics of Capital RecoveryCopy Anchor Link

A fundamental law of arithmetic is that losses require disproportionately larger percentage gains to restore initial capital. If an equity pool suffers a fractional loss L \in (0, 1), the required recovery gain R_{\text{recovery}} to return to the previous peak is governed by:

R_{\text{recovery}} = \frac{L}{1 - L} = \frac{1}{1 - L} - 1

As loss depth increases, the required return curve turns parabolic:

A 50% drawdown requires a 100% gain just to return to the zero mark. If a strategy averages a net 15% annual return, recovering from a 50% drawdown takes nearly five consecutive years of uninterrupted compounding.

Leverage, Margin Calls, and Quant SurvivalCopy Anchor Link

When systematic strategies operate with leverage, drawdown dynamics become fatal. Leverage scales gains and losses linearly on notional exposure, but exponentially shortens the distance to margin depletion:

• At 2x leverage, a 25% drop in asset price produces a 50% equity haircut.
• At 4x leverage, that same 25% drop triggers a 100% loss—complete liquidation.

In institutional environments, the concept of operational ruin supersedes theoretical mathematical survival. A retail trader might be willing to hold through a 35% drawdown hoping for mean reversion. However, proprietary trading desks, hedge fund risk committees, and external allocators enforce strict liquidation stop-losses. Mandates are revoked, risk allocations are slashed, or accounts are forcibly closed long before the strategy's long-term theoretical edge has time to play out.

Furthermore, drawdown depletes a quant's psychological capital. Prolonged or severe underwater periods trigger model abandonment, emotional discretionary overrides, or ill-timed parameter tampering—frequently occurring precisely at the cyclical trough.

Mathematical definitions and formulasCopy Anchor Link

To audit portfolio drawdowns rigorously, we must formalize the equity trajectory mathematically. Let the portfolio equity curve be observed over discrete time intervals t \in [0, T], denoted as E_t, with initial capital E_0 > 0.

1. High-Water Mark (HWM_t)Copy Anchor Link

The High-Water Mark at time t represents the cumulative peak equity achieved by the portfolio from inception up to that point:

HWM_t = \max_{0 \le s \le t} E_s

By definition, the High-Water Mark series is monotonically non-decreasing (HWM_t \ge HWM_{t-1}). A new peak is registered whenever current equity exceeds the previous high:

E_t > HWM_{t-1} \implies HWM_t = E_t

2. Relative Percentage Drawdown (DD_t)Copy Anchor Link

The drawdown at time t measures the percentage decline of current equity from its historical High-Water Mark:

DD_t = \frac{E_t - HWM_t}{HWM_t}

Under this quantitative convention, DD_t \le 0. A value of 0.00 (0\%) signifies that the portfolio is resting directly on a new High-Water Mark. A value of -0.18 represents an active 18\% drawdown from the peak.

[!NOTE] Some financial engineering textbooks formulate drawdown as a positive loss percentage: DD_t = \frac{HWM_t - E_t}{HWM_t} \in [0, 1]. Both formulations represent the identical economic deficit; however, defining DD_t \le 0 matches standard underwater time-series charts plotted below the zero baseline.

3. Maximum Drawdown (MDD)Copy Anchor Link

Maximum Drawdown is the single deepest peak-to-trough percentage loss experienced over the entire observation horizon [0, T]:

MDD = \min_{0 \le t \le T} DD_t = \min_{0 \le t \le T} \left( \frac{E_t - HWM_t}{HWM_t} \right)

Or expressed as a positive loss magnitude:

|MDD| = \max_{0 \le t \le T} \left( \frac{HWM_t - E_t}{HWM_t} \right)

Percentage Drawdown vs. Absolute Dollar DrawdownCopy Anchor Link

A critical mistake in backtest evaluation is conflating percentage drawdown with dollar drawdown. Absolute dollar drawdown at time t is defined as:

DD_t^{\$} = HWM_t - E_t, \quad MDD^{\$} = \max_{0 \le t \le T} (HWM_t - E_t)

While absolute dollar drawdown is intuitive, it can produce severe distortions when compounding returns over multi-year backtests:

Consider a strategy whose capital compounds from $$10,000to$1,000,000$ over ten years:

• In Year 2, an account dip from $$20,000to$12,000represents a **40%drawdown** ($8,000$ dollar drop).
• In Year 10, an account dip from $$1,000,000to$950,000represents merely a **5%drawdown** ($50,000$ dollar drop).

If you sort backtest drawdown episodes strictly by dollar magnitude, the $$50,000dip dominates the report, while the catastrophic40%$ capital impairment early in the track record is buried. For strategy viability and risk assessment, percentage drawdown is the foundational metric.

The time dimension: Peak-to-trough vs. Underwater durationCopy Anchor Link

Drawdown cannot be evaluated along a single axis. Focusing exclusively on percentage depth ignores the second, equally destructive dimension of portfolio risk: time.

A full drawdown episode traces three distinct temporal milestones:

Equity ($)
  ^
  |        Peak (t_peak)
  |          /\
  |         /  \
  |        /    \                      Recovery (t_recovery)
  |-------/------\---------------------------/--------------------> HWM
  |               \                         /
  |                \                       /
  |                 \        /\           /
  |                  \      /  \         /
  |                   \    /    \       /
  |                    \  /      \     /
  |                     \/        \   /
  |              Trough (t_trough) \_/
  +--------------------------------------------------------------> Time
          |<------ Time to ------>|<---- Recovery ---->|
          |        Trough         |     Duration       |
          |<------------- Underwater Duration -------->|

1. Peak Date (t_{\text{peak}}): The specific timestamp when the High-Water Mark was established prior to the drop.
2. Trough Date (t_{\text{trough}}): The timestamp when equity reached its deepest point during that specific drawdown cycle (E_{t_{\text{trough}}} = \min E_s for s \in [t_{\text{peak}}, t_{\text{recovery}}]).
3. Recovery Date (t_{\text{recovery}}): The first timestamp after the trough where equity regains the previous peak level (E_{t_{\text{recovery}}} \ge HWM_{t_{\text{peak}}}).

Decomposing Temporal PhasesCopy Anchor Link

From these milestones, we derive three essential duration metrics:

• Time to Trough (t_{\text{trough}} - t_{\text{peak}}): Measures the speed of capital impairment. A steep drop indicates flash crash sensitivity, stop-loss slippage, or high adverse gap risk. A prolonged descent indicates a slow, insidious bleed across changing market regimes.
• Recovery Duration (t_{\text{recovery}} - t_{\text{trough}}): The time required to climb out of the trough. This reflects the strategy's regeneration capacity.
• Total Underwater Duration (t_{\text{recovery}} - t_{\text{peak}}): The entire duration during which capital remained below previous highs. If equity has not yet recovered by the end of the backtest, the drawdown is classified as Active (or Unrecovered).

Why an 18-Month Underwater Grind Kills StrategiesCopy Anchor Link

A strategy that suffers a sharp 15\% drawdown and recovers in three weeks is straightforward to manage. Conversely, a strategy that suffers a modest 12\% drawdown but remains underwater for 18 months routinely leads to operational termination.

Why does underwater duration inflict such severe damage?

1. Opportunity Cost of Capital: When capital is trapped underwater for 18 months, the investor forfeits the risk-free rate (e.g., 4\text{--}5\% Treasury yields) as well as broad equity benchmark returns.
2. Alpha Decay vs. Regime Shift Ambiguity: During a year-and-a-half underwater slog, quantitative researchers face severe statistical uncertainty. Is the strategy simply enduring an extended negative variance cluster, or has its predictive edge evaporated due to market structural shifts?
3. Allocator Redemptions: Institutional asset managers operate under quarterly benchmarks. An 18-month drawdown will trigger client redemptions regardless of how pristine the ten-year Sharpe ratio looks in theory.

Step-by-step vectorized Python calculationCopy Anchor Link

To audit drawdowns efficiently on high-frequency or multi-year bar series, calculation logic should avoid iterative Python loops and leverage vectorized pandas and NumPy routines.

The following script implements a standalone, type-annotated diagnostic function analyze_drawdowns(). It computes headline MDD, tracks high-water marks, identifies peak/trough/recovery dates, measures underwater durations, calculates the Ulcer Index and Calmar Ratio, and extracts the top five worst drawdown episodes.

"""Vectorized Drawdown and Underwater Duration Diagnostics.

Calculates High-Water Mark, Maximum Drawdown (percentage and dollars),
temporal recovery milestones, Ulcer Index, and episode rankings using
pandas and NumPy.
"""

from __future__ import annotations

from dataclasses import dataclass
import numpy as np
import pandas as pd


@dataclass(frozen=True)
class DrawdownMetrics:
    """Core drawdown statistics and temporal diagnostics for an equity curve."""

    max_drawdown_pct: float
    max_drawdown_dollars: float
    peak_date: pd.Timestamp
    trough_date: pd.Timestamp
    recovery_date: pd.Timestamp | None
    time_to_trough_days: int
    recovery_duration_days: int | None
    underwater_duration_days: int
    longest_underwater_days: int
    ulcer_index: float
    cagr: float
    calmar_ratio: float
    top_drawdowns: pd.DataFrame


def analyze_drawdowns(equity: pd.Series) -> DrawdownMetrics:
    """Compute comprehensive drawdown metrics and underwater episodes.

    Parameters
    ----------
    equity : pd.Series
        Time-series of portfolio equity indexed by a pandas DatetimeIndex.

    Returns
    -------
    DrawdownMetrics
        Structured dataclass containing drawdown depth, durations, and top episodes.
    """
    if not isinstance(equity.index, pd.DatetimeIndex):
        raise TypeError("Equity series must have a pandas DatetimeIndex.")
    if len(equity) < 2:
        raise ValueError("Equity series must contain at least 2 data points.")

    # 1. Vectorized High-Water Mark and Drawdown Series
    hwm = equity.cummax()
    dd_pct = (equity - hwm) / hwm
    dd_dollars = hwm - equity

    # 2. Headline Maximum Drawdown
    max_dd_pct = float(dd_pct.min())
    max_dd_dollars = float(dd_dollars.max())
    trough_date = dd_pct.idxmin()
    peak_date = equity.loc[:trough_date].idxmax()

    # Recovery date for the maximum drawdown trough
    post_trough = equity.loc[trough_date:]
    recovery_slice = post_trough[post_trough >= equity.loc[peak_date]]
    recovery_date = recovery_slice.index[0] if not recovery_slice.empty else None

    time_to_trough = (trough_date - peak_date).days
    if recovery_date is not None:
        recovery_duration = (recovery_date - trough_date).days
        underwater_duration = (recovery_date - peak_date).days
    else:
        recovery_duration = None
        underwater_duration = (equity.index[-1] - peak_date).days

    # 3. Ulcer Index: quadratic penalization of drawdown depth and duration
    # UI = sqrt( 1/N * sum((100 * dd_pct)^2) )
    ulcer_index = float(np.sqrt(np.mean((dd_pct * 100.0) ** 2)))

    # 4. CAGR and Calmar Ratio
    total_days = (equity.index[-1] - equity.index[0]).days
    years = total_days / 365.25 if total_days > 0 else 1.0
    total_return = (equity.iloc[-1] / equity.iloc[0]) - 1.0
    cagr = float((1.0 + total_return) ** (1.0 / years) - 1.0)
    calmar_ratio = float(cagr / abs(max_dd_pct)) if max_dd_pct < 0 else 0.0

    # 5. Extract contiguous underwater episodes
    is_underwater = equity < hwm
    periods = (~is_underwater).cumsum()[is_underwater]

    episodes: list[dict] = []
    if not periods.empty:
        for _, group in is_underwater.groupby(periods):
            sub_equity = equity.loc[group.index]
            start_pos = equity.index.get_loc(group.index[0])
            ep_peak_loc = max(0, start_pos - 1)
            ep_peak_date = equity.index[ep_peak_loc]
            ep_peak_val = equity.iloc[ep_peak_loc]

            ep_trough_date = sub_equity.idxmin()
            ep_trough_val = sub_equity.loc[ep_trough_date]

            ep_dd_pct = (ep_trough_val - ep_peak_val) / ep_peak_val
            ep_dd_dollar = ep_peak_val - ep_trough_val

            end_pos = equity.index.get_loc(group.index[-1])
            if end_pos + 1 < len(equity):
                ep_rec_date = equity.index[end_pos + 1]
                ep_status = "Recovered"
                ep_duration = (ep_rec_date - ep_peak_date).days
            else:
                ep_rec_date = None
                ep_status = "Active"
                ep_duration = (equity.index[-1] - ep_peak_date).days

            episodes.append({
                "Peak Date": ep_peak_date.strftime("%Y-%m-%d"),
                "Trough Date": ep_trough_date.strftime("%Y-%m-%d"),
                "Recovery Date": (
                    ep_rec_date.strftime("%Y-%m-%d") if ep_rec_date else "Unrecovered"
                ),
                "Drawdown (%)": round(ep_dd_pct * 100.0, 2),
                "Drawdown ($)": round(ep_dd_dollar, 2),
                "Duration (Days)": ep_duration,
                "Status": ep_status,
            })

    episodes_df = pd.DataFrame(episodes)
    if not episodes_df.empty:
        longest_underwater = int(episodes_df["Duration (Days)"].max())
        top_drawdowns = episodes_df.sort_values(by="Drawdown (%)", ascending=True).head(5)
    else:
        longest_underwater = 0
        top_drawdowns = pd.DataFrame()

    return DrawdownMetrics(
        max_drawdown_pct=max_dd_pct,
        max_drawdown_dollars=max_dd_dollars,
        peak_date=peak_date,
        trough_date=trough_date,
        recovery_date=recovery_date,
        time_to_trough_days=time_to_trough,
        recovery_duration_days=recovery_duration,
        underwater_duration_days=underwater_duration,
        longest_underwater_days=longest_underwater,
        ulcer_index=ulcer_index,
        cagr=cagr,
        calmar_ratio=calmar_ratio,
        top_drawdowns=top_drawdowns,
    )


if __name__ == "__main__":
    # Generate reproducible synthetic 3-year equity series (2023-2025)
    np.random.seed(42)
    dates = pd.date_range("2023-01-01", "2025-12-31", freq="B")
    daily_returns = np.random.normal(0.0009, 0.0095, size=len(dates))

    # Introduce realistic macro corrections
    daily_returns[140:175] -= 0.0060  # Mid-2023 correction
    daily_returns[360:390] -= 0.0050  # Mid-2024 correction

    equity_series = pd.Series(
        100_000.0 * np.cumprod(1.0 + daily_returns),
        index=dates,
        name="PortfolioEquity",
    )

    results = analyze_drawdowns(equity_series)

    print("=" * 62)
    print("PORTFOLIO DRAWDOWN DIAGNOSTIC REPORT")
    print("=" * 62)
    print(f"Initial Capital:         $100,000.00")
    print(f"Final Equity:            ${equity_series.iloc[-1]:,.2f}")
    print(f"CAGR:                    {results.cagr:.2%}")
    print(f"Max Drawdown (%):        {results.max_drawdown_pct:.2%}")
    print(f"Max Drawdown ($):        ${results.max_drawdown_dollars:,.2f}")
    print(f"Peak Date:               {results.peak_date.strftime('%Y-%m-%d')}")
    print(f"Trough Date:             {results.trough_date.strftime('%Y-%m-%d')}")
    print(
        f"Recovery Date:           "
        f"{results.recovery_date.strftime('%Y-%m-%d') if results.recovery_date else 'Active'}"
    )
    print(f"Time to Trough:          {results.time_to_trough_days} days")
    print(f"Recovery Duration:       {results.recovery_duration_days} days")
    print(f"Total Underwater Window: {results.underwater_duration_days} days")
    print(f"Longest Underwater Span: {results.longest_underwater_days} days")
    print(f"Ulcer Index:             {results.ulcer_index:.2f}")
    print(f"Calmar Ratio:            {results.calmar_ratio:.2f}")
    print("=" * 62)
    print("TOP 5 WORST DRAWDOWN EPISODES:")
    print(results.top_drawdowns.to_string(index=False))
    print("=" * 62)

Execution OutputCopy Anchor Link

Running this vectorized script produces the following diagnostic output:

==============================================================
PORTFOLIO DRAWDOWN DIAGNOSTIC REPORT
==============================================================
Initial Capital:         $100,000.00
Final Equity:            $125,829.57
CAGR:                    7.77%
Max Drawdown (%):        -17.62%
Max Drawdown ($):        $18,544.42
Peak Date:               2023-01-13
Trough Date:             2023-09-01
Recovery Date:           2024-03-12
Time to Trough:          231 days
Recovery Duration:       193 days
Total Underwater Window: 424 days
Longest Underwater Span: 424 days
Ulcer Index:             6.94
Calmar Ratio:            0.44
==============================================================
TOP 5 WORST DRAWDOWN EPISODES:
 Peak Date Trough Date Recovery Date  Drawdown (%)  Drawdown ($)  Duration (Days)    Status
2023-01-13  2023-09-01    2024-03-12        -17.62      18544.42              424 Recovered
2024-08-22  2025-02-03    2025-05-21        -13.11      15322.78              272 Recovered
2024-04-08  2024-07-03    2024-08-19        -10.09      11585.85              133 Recovered
2025-10-31  2025-11-19    2025-12-10         -7.83       9641.70               40 Recovered
2025-05-23  2025-06-26    2025-10-30         -6.76       8227.98              160 Recovered
==============================================================

Notice how this breakdown provides immediate operational insight: the worst drawdown was -17.62\%, taking 231 days to bottom and a further 193 days to break even, locking capital underwater for a staggering 424 days.

Reconciling drawdowns with backtesting outputsCopy Anchor Link

Extracting drawdown metrics from a static array is mathematically straightforward. However, how that underlying equity series was generated inside your backtesting engine is where backtests frequently diverge from live trading realities.

Daily Close vs. Intrabar Mark-to-Market EquityCopy Anchor Link

Many naive backtesting frameworks calculate equity curves strictly using daily close prices:

E_{\text{close}, t} = \text{Cash}_t + \text{Shares}_t \times \text{Close}_t

While computationally lightweight, close-only accounting introduces severe survival bias. Consider an open position held during a session characterized by extreme market turbulence:

• Market opens at $$100.00$.
• Intraday panic drives the asset to a low of $$75.00(-25%$).
• Late-session short-covering rebounds the price back to $$98.00at close (-2%$).

Under close-only accounting, the recorded drawdown is a mild -2\%. In live trading, however:

1. An intraday stop-loss or trailing stop would have triggered at -5\% or -10\%.
2. If operating on leverage, a margin call or broker liquidation would have closed the position at or near the intraday low of $$75.00$.

By ignoring intrabar excursions (Low_t for longs, High_t for shorts), daily close backtesters present an artificially smooth equity curve and a dangerously suppressed maximum drawdown figure.

Bar-by-Bar Execution and Equity Tracking in OpenBacktestingCopy Anchor Link

To prevent this discrepancy, OpenBacktesting (version 0.2.1) executes single-asset simulations on a strict historical OHLCV bar-by-bar architecture:

• Intrabar Order Triggering: Orders are evaluated sequentially against bar extremes. If a stop-loss is placed at $$90.00, the engine detects whenLow_t \le $90.00$ and triggers execution, rather than waiting for bar close.
• Execution Order Types: Full modeling of realistic order mechanics—including market, limit, stop, stop-limit, trailing stop, and OCO (one-cancels-other) order pairs.
• Friction Modeling: OpenBacktesting integrates user-configured commission structures and slippage models. Zero-commission backtests underestimate transaction drag, turning what should be an extended underwater drawdown into an artificial series of new highs.
• Mark-to-Market Diagnostics: At every bar t, total portfolio valuation accounts for active position values and available cash. Trade histories (trades_df) and trial parameters are persisted immutably in SQLite databases.

Quants can review these drawdown phases visually in the local browser-based OpenBacktesting Studio, identifying whether drawdowns were triggered by clustered slippage losses, stop-loss cascades, or extended low-volatility chop.

Beyond MDD: Calmar Ratio and Ulcer IndexCopy Anchor Link

While Maximum Drawdown is standard in institutional reporting, relying on it as a solitary risk metric introduces severe extreme-value bias.

MDD represents merely one historical data point—the single worst trough in the dataset. Consider two hypothetical trading strategies with identical -20\% MDDs over five years:

• Strategy A: Climbs steadily for 4.5 years, suffers a single sharp -20\% correction during a liquidity shock, recovers within four weeks, and continues printing new highs.
• Strategy B: Drops into -15\% to -20\% drawdowns every eight months, spending 75\% of its operational life underwater.

Maximum Drawdown treats both strategies as having equivalent risk. To separate Strategy A from Strategy B, quants employ ratios that incorporate return velocity and underwater persistence.

1. Calmar RatioCopy Anchor Link

Originally developed by Terry W. Young (1991), the Calmar Ratio measures annualized return relative to peak downside risk:

\text{Calmar Ratio} = \frac{\text{CAGR}}{|MDD|}

Where:

• \text{CAGR} is the Compound Annual Growth Rate.
• |MDD| is the absolute value of the Maximum Drawdown over the evaluated period (typically 36 months).

Calmar Interpretation Benchmarks:
  < 0.50 : Poor downside efficiency; drawdown exceeds return capacity.
  0.50 - 1.00 : Acceptable for broad market trend-following strategies.
  1.00 - 2.00 : Strong risk-adjusted performance.
  > 2.00 : Exceptional (audit carefully for overfitting or lookahead bias).

2. Ulcer Index (UI)Copy Anchor Link

Developed by Peter G. Martin in 1987, the Ulcer Index addresses the fundamental flaw of MDD by measuring both the depth and the duration of all drawdowns across the entire backtest horizon.

The Ulcer Index computes the quadratic mean (root-mean-square) of percentage drawdowns:

UI = \sqrt{\frac{1}{N} \sum_{t=1}^N \left( 100 \times \frac{E_t - HWM_t}{HWM_t} \right)^2}

Why the Ulcer Index is mathematically superior for assessing psychological stress:

1. Penalizes Duration: Every bar the portfolio spends underwater adds to the summation \sum DD_t^2. A strategy that remains underwater for 200 bars generates a vastly higher UI than one recovering in 10 bars.
2. Quadratic Weighting: Squaring the drawdown percentage (DD_t^2) disproportionately penalizes deep drops. A -20\% drawdown contributes four times more penalty per bar than a -10\% drawdown.
3. Continuous Metric: Unlike MDD, which ignores what occurs before or after the single worst trough, UI evaluates the complete historical trajectory.

3. Martin Ratio (Ulcer Performance Index)Copy Anchor Link

The Martin Ratio (also called the Ulcer Performance Index, or UPI) calculates excess return per unit of drawdown stress:

UPI = \frac{\text{CAGR} - R_f}{UI}

Where R_f is the annualized risk-free rate.

Comparison of Risk-Adjusted MetricsCopy Anchor Link

Summary checklist for drawdown auditingCopy Anchor Link

Before deploying capital or finalizing strategy parameters, run through this comprehensive quantitative audit checklist:

• Verify Equity Resolution: Confirm your backtest tracks mark-to-market equity bar-by-bar, accounting for intrabar highs and lows rather than solely daily closes.
• Audit Dual Drawdown Metrics: Calculate both percentage drawdown (for compounding validity) and absolute dollar drawdown (for margin buffers and lot-size constraints).
• Quantify Recovery Windows: Measure the time to trough, recovery duration, and total underwater window. Confirm your capital can withstand the longest historical underwater span.
• Inspect Top Drawdown Episodes: Review the top five worst drawdown periods. Do they cluster around known macroeconomic regime shifts (e.g., rate hikes, liquidity crises, volatility shocks)?
• Enforce Execution Friction: Ensure your simulation includes realistic commissions and slippage models (as enforced in OpenBacktesting). Frictionless backtests artificially inflate recovery speed.
• Calculate the Ulcer Index: Evaluate the Ulcer Index and Martin Ratio alongside the headline Calmar ratio to measure persistent underwater stress.
• Stress-Test Sequence Risk: Historical drawdowns represent only one realized path. Run Monte Carlo trade-log permutations to evaluate potential drawdown expansion under adverse trade sequences (see our detailed guide on Monte Carlo Backtesting in Python).
• Audit Strategy Pipeline: Re-verify that data feeds and indicators are free of lookahead bias and execution leaks following the complete pipeline outlined in How to Backtest a Trading Strategy.

For technical reference on deterministic bar-by-bar backtesting, order execution modeling, and portfolio export schemas, visit the official OpenBacktesting Documentation.