Module 12: Backtesting & Live TradingMove from historical simulation to live trading with the same strategy codebase

1. Three Execution Environments

flowchart LR
                        subgraph bt["🔬 Backtest"]
                        hist["Historical Data"] --> sim1["Simulated Exchange"]
                        sim1 --> report["Performance Report"]
                        end
                        subgraph sb["🏖️ Sandbox"]
                        live_data["Real-time Data"] --> sim2["Simulated Exchange"]
                        sim2 --> monitor["Real-time Monitoring"]
                        end
                        subgraph lv["🚀 Live"]
                        live_data2["Real-time Data"] --> real["Real Exchange"]
                        real --> pnl["Real PnL"]
                        end

                        bt -->|"Validation Passed"| sb
                        sb -->|"Observation Period"| lv

2. Comprehensive Backtest Configuration Example

from nautilus_trader.backtest.engine import BacktestEngine
from nautilus_trader.backtest.config import (
    BacktestEngineConfig,
    BacktestVenueConfig,
    BacktestDataConfig,
)
from nautilus_trader.model.enums import AccountType, OmsType

# ===== 1. Configure the Engine =====
engine_config = BacktestEngineConfig(
    trader_id="QUANT-BT-001",
    logging=LoggingConfig(log_level="INFO"),
    risk_engine=RiskEngineConfig(
        max_order_submit_rate="100/00:00:01",
    ),
)

# ===== 2. Configure the Simulated Exchange =====
venue_config = BacktestVenueConfig(
    name="BINANCE",
    oms_type=OmsType.NETTING,        # Netting OMS
    account_type=AccountType.MARGIN,  # Margin account
    starting_balances=["100,000 USDT"],
    default_leverage=10,
    fill_model=FillModel(
        prob_fill_on_limit=0.2,       # Probability of limit order fill
        prob_fill_on_stop=0.95,       # Probability of stop order fill
        prob_slippage=0.5,            # Probability of slippage
    ),
)

# ===== 3. Configure the Data Source =====
data_config = BacktestDataConfig(
    catalog_path="./data/catalog",
    data_cls="QuoteTick",
    instrument_id="BTCUSDT.BINANCE",
    start_time="2023-01-01",
    end_time="2023-12-31",
)

# ===== 4. Configure the Strategy =====
strategy_config = MyStrategyConfig(
    instrument_id=InstrumentId.from_str("BTCUSDT.BINANCE"),
    bar_type=BarType.from_str("BTCUSDT.BINANCE-1-MINUTE-LAST"),
    fast_ema_period=10,
    slow_ema_period=20,
)

# ===== 5. Run the Backtest =====
engine = BacktestEngine(config=engine_config)
engine.add_venue(venue_config)
engine.add_data(data_config)
engine.add_strategy(MyStrategy(strategy_config))

engine.run()

# ===== 6. View Results =====
engine.trader.generate_order_fills_report()
engine.trader.generate_positions_report()
engine.trader.generate_account_report()

3. Data Catalog

NautilusTrader uses the Parquet format for highly efficient storage of backtest data:

from nautilus_trader.persistence.catalog import ParquetDataCatalog

catalog = ParquetDataCatalog("./data/catalog")

# Write quote tick data
catalog.write_data(quote_ticks)

# Retrieve data (by time range)
ticks = catalog.quote_ticks(
    instrument_ids=["BTCUSDT.BINANCE"],
    start="2023-01-01",
    end="2023-06-30",
)

3B. FillModel / FeeModel / LatencyModel — Ensuring Realistic Backtests

These three models are the key differentiators between “toy backtests” and “professional-grade simulations”:

"""Configuring a realistic backtest environment"""
from nautilus_trader.backtest.models import (
    FillModel, FeeModel, LatencyModel,
)

# Fill model: 1 tick slippage for market orders, 80% limit fill probability
fill_model = FillModel(
    prob_fill_on_limit=0.80,    # 80% probability of limit order fill
    prob_fill_on_stop=0.95,     # 95% probability of stop order fill
    prob_slippage=0.50,         # 50% probability of experiencing slippage
    random_seed=42,             # Fixed random seed for deterministic reproducibility
)

# Fee model: Maker 0.02%, Taker 0.04%
fee_model = FeeModel(
    maker_fee=0.0002,
    taker_fee=0.0004,
)

# Latency model: 50ms for order submission, 30ms for cancellation
latency_model = LatencyModel(
    submit_order_latency_ms=50,
    cancel_order_latency_ms=30,
)

# Inject models into venue configuration
venue_config = BacktestVenueConfig(
    name="BINANCE",
    oms_type=OmsType.NETTING,
    account_type=AccountType.MARGIN,
    starting_balances=["100,000 USDT"],
    fill_model=fill_model,
    fee_model=fee_model,
    latency_model=latency_model,  # Optional
)

3C. Tearsheet — Backtest Result Visualization

After running a backtest, generate a comprehensive interactive performance report with a single line of code:

from nautilus_trader.analysis import create_tearsheet

# Generate the full tearsheet report after the backtest completes
create_tearsheet(engine, output_path="tearsheet.html")
# → Open tearsheet.html to view interactive Plotly visualizations!

# You can also generate individual charts:
from nautilus_trader.analysis import (
    create_equity_curve,        # Equity curve
    create_drawdown_chart,      # Drawdown chart
    create_monthly_returns_heatmap,  # Monthly returns heatmap
    create_rolling_sharpe,      # Rolling Sharpe ratio
    create_returns_distribution,# Returns distribution
)

# Equity curve generation
fig = create_equity_curve(
    engine,
    output_path="equity.html",
    title="Alpha EMA Generation",
)

4. Live Deployment

# Live configuration — Only modify the adapters, keep the strategy code unchanged!
from nautilus_trader.live.node import TradingNode
from nautilus_trader.adapters.binance.config import (
    BinanceLiveDataClientConfig,
    BinanceLiveExecClientConfig,
)

node = TradingNode(config=TradingNodeConfig(
    trader_id="PROD-BTC-001",
    data_clients={
        "BINANCE": BinanceLiveDataClientConfig(
            api_key="quant-api-key",
            api_secret="quant-api-secret",
        ),
    },
    exec_clients={
        "BINANCE": BinanceLiveExecClientConfig(
            api_key="quant-api-key",
            api_secret="quant-api-secret",
        ),
    },
))

# Inject the identical strategy object!
node.trader.add_strategy(MyStrategy(strategy_config))
node.run()

Live Safety Mechanisms

NautilusTrader provides several critical safety mechanisms for live execution:

5. Common Backtest Pitfalls

6. Interactive Exercises

7. Module Summary