Momentum Trading Strategy: How to Build and Test in Python

Momentum is one of the most-studied anomalies in finance. Since Narasimhan Jegadeesh and Sheridan Titman documented it in 1993, the effect has persisted across asset classes, geographies, and decades. The intuition is simple: assets that have outperformed over the past 3 to 12 months tend to keep outperforming over the next few months, and recent losers tend to keep losing.

This tutorial takes momentum from intuition to working code. You will build a cross-sectional momentum strategy in Python, backtest it on liquid sector ETFs, and measure its risk-adjusted performance against a buy-and-hold benchmark. We then cover the harder questions most tutorials skip: when momentum fails, how to manage crash risk, and which mistakes destroy backtested results in live trading.

Prerequisites: Python 3.10 or later, pandas 2.1+, NumPy, matplotlib, and yfinance. You should be comfortable with returns, portfolios, and basic pandas operations.

What is Momentum Trading? A Quantitative Definition

Momentum trading is the practice of buying assets with strong recent performance and avoiding or shorting those with weak recent performance, with the expectation that the trend continues over a defined holding period.

The quantitative version replaces discretion with rules. A quant momentum strategy specifies three things precisely:

1. Formation period (lookback): the window over which past returns are measured, typically 3 to 12 months.
2. Holding period: how long positions are held before rebalancing, typically 1 to 3 months.
3. Selection rule: how assets are ranked and which are bought or sold.

This is the framework Jegadeesh and Titman used in their seminal paper, Returns to Buying Winners and Selling Losers, which documented that a long-winners, short-losers portfolio generated significant positive returns over 3-to-12-month holding periods on US equities from 1965 to 1989. The result has been replicated in international equity markets, futures, currencies, and commodities, making momentum one of the most robust factor premia in empirical finance.

A momentum strategy is not the same as trend-following or technical analysis based on chart patterns. Quant momentum is a systematic, rules-based factor exposure, evaluated statistically and rebalanced on a defined schedule. The signal is the past return itself, not a subjective pattern read from a chart.

Time-Series vs Cross-Sectional Momentum

Two flavors of momentum dominate the literature. They look similar on the surface but make different bets and behave differently in stress periods.

Cross-Sectional Momentum (Relative Strength)

Cross-sectional momentum ranks a universe of assets by their past returns and buys the top performers, often shorting the bottom performers. The bet is on relative performance: the winners continue to outperform the losers, regardless of overall market direction.

This is the original Jegadeesh-Titman construction. A typical setup: rank all S&P 500 stocks by their trailing 12-month return excluding the most recent month, buy the top decile, short the bottom decile, and rebalance monthly.

Strengths: market-neutral when implemented long-short. Captures pure relative performance.
Weaknesses: exposed to “momentum crashes” during sharp market reversals when prior losers spike (more on this later).

Time-Series Momentum (Absolute / Trend Following)

Time-series momentum looks at each asset on its own. If the asset’s past 12-month return is positive, go long. If negative, go short or move to cash. There is no ranking against other assets.

Moskowitz, Ooi, and Pedersen formalized this in 2012, showing that a 12-month time-series momentum signal worked across 58 liquid futures contracts spanning equity indices, currencies, commodities, and bonds. The strategy delivered substantial returns with low correlation to traditional asset pricing factors.

Strengths: moves to cash or short during persistent downturns, which helps in bear markets.
Weaknesses: whipsaw losses in choppy, sideways markets.

Dual Momentum

Gary Antonacci’s dual momentum framework combines both: assets must clear an absolute return hurdle (time-series filter) and outperform their peers (cross-sectional filter). It is a popular retail-friendly construction because it captures most of the upside while sidestepping prolonged drawdowns.

Residual and Risk-Managed Momentum

More advanced variants strip out market beta (residual momentum) or scale exposure by realized volatility (risk-managed momentum). We cover the volatility-targeting version in the risk management section.

Variant	Signal	Direction	Best Suited For
Cross-sectional	Relative rank	Long top, short bottom	Large equity universes
Time-series	Sign of past return	Long if positive, short/cash if negative	Diversified futures, ETFs
Dual momentum	Both filters	Long winners that beat cash	Retail TAA portfolios
Residual momentum	Beta-adjusted return	Long-short on residuals	Factor-clean exposure

The Math Behind Momentum Signals

A clean momentum signal requires three definitions: the formation window, the skip period, and the ranking metric.

Return-Based Momentum

The simplest signal is the past-period return:

M(t, L) = P(t) / P(t - L) - 1

Where P(t) is the price at time t and L is the lookback length in trading days or months.

The Skip-Month Convention (12-1)

A standard refinement is to exclude the most recent month from the lookback. The signal becomes the return from t-12 to t-1, written 12-1 momentum:

M(t) = P(t - 1) / P(t - 12) - 1

The skip month removes short-term reversal effects, which are well-documented in equity returns at the 1-month horizon. Skipping the most recent month prevents the signal from picking up noise from a single recent month and produces a cleaner medium-term momentum measure.

Risk-Adjusted Momentum

A stronger signal divides the past return by its realized volatility:

M_risk(t) = mean(r) / std(r)

This is functionally the in-sample Sharpe ratio (a measure of return per unit of risk) of the asset over the lookback window. It penalizes assets whose recent gains came with high volatility and rewards smoother trends. Empirically, risk-adjusted momentum often produces better Sharpe ratios than raw return momentum.

Holding Period and Rebalancing

Once ranked, positions are held for a fixed window (commonly 1 month for cross-sectional strategies on equities) before re-ranking. Longer holding periods reduce turnover and transaction costs, but they also dilute the signal. Most practitioner implementations rebalance monthly.

Building a Momentum Strategy in Python: Step-by-Step

The strategy below implements a long-only cross-sectional momentum on US sector ETFs. We rank ten sectors by 12-1 month momentum, hold the top three equal-weighted, and rebalance monthly. This is close to the QSTrader and AlphaArchitect academic implementations and is reproducible without paid data.

Step 1) Install and Import Libraries

python

# pip install yfinance pandas numpy matplotlib

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Versions tested: yfinance 0.2.40, pandas 2.1.4, numpy 1.26.4, matplotlib 3.8.2

We use yfinance for free price data, pandas for time-series operations, and matplotlib for charts. Set a deterministic random seed elsewhere if your code involves any randomization.

Step 2) Define the Universe and Download Data

python

# Ten US sector SPDR ETFs + benchmark
sectors = ['XLK', 'XLF', 'XLE', 'XLV', 'XLY',
           'XLP', 'XLI', 'XLB', 'XLU', 'XLRE']
benchmark = 'SPY'

start_date = '2010-01-01'
end_date   = '2024-12-31'

prices = yf.download(
    tickers=sectors + [benchmark],
    start=start_date,
    end=end_date,
    auto_adjust=True,
    progress=False
)['Close']

print(prices.tail())

auto_adjust=True returns prices adjusted for splits and dividends, which is essential for any honest backtest. Including XLRE (added in 2015) means early-period values are NaN, which is handled naturally by the ranking logic below.

Step 3) Compute Monthly Returns and the Momentum Signal

python

# Resample to month-end prices
monthly_prices = prices.resample('ME').last()

# Monthly returns
monthly_returns = monthly_prices.pct_change()

# 12-1 momentum: trailing 12-month return excluding the most recent month
lookback = 12
skip = 1

# Return from t-12 to t-1 = (price_{t-1} / price_{t-12}) - 1
momentum = (monthly_prices.shift(skip) / monthly_prices.shift(lookback)) - 1

print(momentum[sectors].tail())

The skip removes the most recent month from the formation window. At each month-end, every sector has a momentum score representing its trailing performance from 12 months ago to 1 month ago.

Step 4) Rank Sectors and Build Portfolio Weights

python

top_n = 3

# Rank sectors each month (1 = highest momentum)
ranks = momentum[sectors].rank(axis=1, ascending=False, method='first')

# Equal-weight the top N sectors, zero elsewhere
weights = (ranks <= top_n).astype(float) / top_n

# Replace rows with insufficient data with zeros (no position)
weights = weights.where(momentum[sectors].notna().sum(axis=1) >= top_n, 0)

print(weights.tail())

Ranking is applied row-wise, with sectors ordered from highest to lowest 12-1 return. The top three receive equal weight (1/3 each). Months where fewer than three valid scores exist (early data for XLRE) receive zero weights, leaving capital uninvested.

Step 5) Backtest the Strategy

python

# Shift weights forward by one month to avoid look-ahead bias.
# Weights computed at end of month t are applied to returns in month t+1.
strategy_returns = (weights.shift(1) * monthly_returns[sectors]).sum(axis=1)

# Drop initial NaN months
strategy_returns = strategy_returns.dropna()
bench_returns = monthly_returns[benchmark].loc[strategy_returns.index]

# Cumulative growth
strategy_cum = (1 + strategy_returns).cumprod()
bench_cum = (1 + bench_returns).cumprod()

The shift(1) is critical. Without it, the backtest uses the same month’s returns to both rank and trade, which produces look-ahead bias. This single line difference can inflate a backtest Sharpe ratio by 0.4 or more.

Step 6) Compute Performance Metrics

python

def performance_metrics(returns, periods_per_year=12):
    """Annualized return, volatility, Sharpe, and max drawdown."""
    total_return = (1 + returns).prod() - 1
    n_years = len(returns) / periods_per_year
    ann_return = (1 + total_return) ** (1 / n_years) - 1
    ann_vol = returns.std() * np.sqrt(periods_per_year)
    sharpe = ann_return / ann_vol if ann_vol > 0 else np.nan

    cum = (1 + returns).cumprod()
    rolling_max = cum.cummax()
    drawdown = cum / rolling_max - 1
    max_dd = drawdown.min()

    return {
        'Ann. Return': f'{ann_return:.2%}',
        'Ann. Vol': f'{ann_vol:.2%}',
        'Sharpe': f'{sharpe:.2f}',
        'Max Drawdown': f'{max_dd:.2%}'
    }

print('Strategy:', performance_metrics(strategy_returns))
print('SPY:     ', performance_metrics(bench_returns))

The Sharpe ratio assumes a risk-free rate of zero for simplicity. In production, subtract the relevant T-bill yield from returns before computing the ratio. Time complexity is O(n) where n is the number of months.

Step 7) Plot Cumulative Returns and Drawdowns

python

fig, axes = plt.subplots(2, 1, figsize=(11, 7), sharex=True)

axes[0].plot(strategy_cum.index, strategy_cum.values,
             label='Sector Momentum (Top 3)', linewidth=1.5)
axes[0].plot(bench_cum.index, bench_cum.values,
             label='SPY Buy and Hold', linewidth=1.5, alpha=0.8)
axes[0].set_ylabel('Growth of $1')
axes[0].set_title('Cross-Sectional Sector Momentum vs SPY (2010-2024)')
axes[0].legend(loc='upper left')
axes[0].grid(alpha=0.3)

dd = strategy_cum / strategy_cum.cummax() - 1
axes[1].fill_between(dd.index, dd.values, 0, alpha=0.4, color='crimson')
axes[1].set_ylabel('Drawdown')
axes[1].set_xlabel('Date')
axes[1].grid(alpha=0.3)

plt.tight_layout()
plt.show()

The drawdown panel matters as much as the equity curve. A strategy with a higher CAGR but deeper drawdowns is often inferior to a smoother one for any leveraged or risk-budgeted application.

Results and Interpretation

Running the code on US sector ETFs from January 2010 to December 2024 produces a momentum strategy that is broadly competitive with SPY but does not dominate it. Across multiple test runs, the top-3 sector momentum strategy delivered an annualized return in the high single digits with volatility roughly in line with the broad market and a maximum drawdown comparable to SPY’s COVID and 2022 drawdowns.

A representative output looks like this:

Metric	Sector Momentum (Top 3)	SPY Buy and Hold
Annualized Return	~10.5%	~12.8%
Annualized Volatility	~16.2%	~15.4%
Sharpe Ratio (rf = 0)	~0.65	~0.83
Max Drawdown	~-26%	~-24%
Monthly Turnover	~40%	0%

Exact figures vary with data revisions and the rebalance date chosen. Results assume zero transaction costs.

What this tells you:

• Momentum at the sector level is real but modest. It does not produce the headline returns sometimes quoted for stock-level momentum, because there are only ten sectors to rank.
• The strategy’s edge sits in risk-adjusted terms more than absolute return. In some sub-periods the Sharpe ratio exceeds the benchmark, in others it lags.
• A 15-year window straddles two regimes: the long bull market from 2010 to 2021 (where buy-and-hold was hard to beat) and the 2022 drawdown (where momentum’s reactivity helped).

Honest limitations:

• No transaction costs included. Realistic round-trip costs for ETF trading add roughly 5 to 10 basis points per rebalance, which compounds over 180 monthly rebalances.
• No slippage modeled. The backtest assumes execution at the month-end close.
• Survivorship is fine here (sector ETFs do not disappear), but the same code applied to individual stocks must use a survivorship-bias-free universe.

A strategy result should never be presented without these caveats. The point of the backtest is to validate the mechanism, not to forecast live profits. For deeper backtesting methodology, see our guide on common backtest pitfalls.

Risk Management: When Momentum Breaks

Momentum has paid investors for decades, but it crashes hard. Kent Daniel and Tobias Moskowitz documented in their 2016 paper Momentum Crashes that the long-short US equity momentum strategy lost roughly 88 percent from July to August 1932 and roughly 46 percent from March to April 2009. These were not random events. Both occurred in “panic” states: after deep market declines, when realized volatility was high, and right as the market rebounded violently.

The mechanism is intuitive once you see it. After a crash, the prior losers are typically the most beaten-down, high-beta stocks. When the market reverses, those stocks rally hardest. A momentum strategy is short exactly those names, so the short book explodes while the long book lags. This is the asymmetry that creates the crash.

Volatility Targeting

Pedro Barroso and Pedro Santa-Clara showed in 2015 that scaling exposure inversely to realized momentum volatility (a target of around 12 percent annualized) eliminates most crashes and nearly doubles the Sharpe ratio of the unmanaged strategy. The implementation is straightforward:

python

# Add to the backtest pipeline
target_vol = 0.12  # 12% annualized
realized_vol = strategy_returns.rolling(6).std() * np.sqrt(12)
vol_scalar = (target_vol / realized_vol).clip(upper=2.0)  # cap leverage at 2x
managed_returns = strategy_returns * vol_scalar.shift(1)

Volatility forecasts are noisy, so practitioners cap the scalar to prevent extreme leverage. The shift(1) again prevents look-ahead.

Dynamic Risk Management

Daniel and Moskowitz extended this with a dynamic strategy that scales exposure based on forecasts of both momentum’s mean and variance, conditional on the market state. They reported that this approach approximately doubles the alpha and Sharpe ratio of a static momentum strategy. The intuition: cut exposure aggressively in panic states, increase it in calm markets.

Position-Level Risk Controls

Beyond portfolio-level scaling, basic risk controls still matter:

• Stop-losses on individual sleeves to cap single-name damage.
• Sector or country caps to prevent unintended concentration.
• Liquidity filters that exclude assets where the rebalance trade exceeds 5 to 10 percent of average daily volume.

For a deeper treatment of risk metrics like Sharpe, Sortino, and Calmar, see our risk management guide.

Common Pitfalls in Momentum Backtests

Most published momentum backtests look better than the live strategies they spawn. The gap usually comes from one of these errors:

Look-ahead bias. Computing the signal and the trade in the same period. The shift(1) in Step 5 above is the fix. A look-ahead bias of even one day can inflate a backtested Sharpe ratio by 0.3 to 0.5.

Survivorship bias. Backtesting on the current S&P 500 constituents instead of the historical membership. Stocks that delisted, went bankrupt, or were acquired are silently removed. A momentum strategy on this universe systematically holds future survivors, which biases results upward by 1 to 3 percentage points annually.

Transaction cost neglect. Monthly rebalancing of a 50-stock portfolio implies roughly 100 to 200 percent annual turnover. At 10 basis points per side, that is 20 to 40 basis points of annual return drag. On individual stocks with wider spreads, the drag can exceed 1 percent annually.

Overfitting the lookback. Testing 6, 9, 12, and 15-month lookbacks and reporting the best one. The standard 12-1 month convention exists precisely because it was the original Jegadeesh-Titman finding and has held out of sample for three decades. Custom lookbacks tuned on the same data they are tested on are almost always overfit.

Capacity constraints. A backtested strategy that buys micro-caps cannot scale beyond a few million dollars without moving prices. Most academic momentum results use the top 80 percent of stocks by market cap precisely to avoid this issue. Test capacity by simulating with a realistic order size relative to historical volume.

Regime cherry-picking. A momentum strategy backtested only on 2010 to 2020 looks better than one tested across 2008, 2020, and 2022. Always include at least one bear market and one momentum-crash period in the test window.

Expert Advice

When productionizing a momentum strategy, I keep the lookback boring. The 12-1 month standard from Jegadeesh and Titman has held for thirty years across markets. Every “improved” lookback I have tested looked great in-sample and decayed out-of-sample. The edge is in disciplined execution and risk management, not exotic signals.

Final Verdict

Quantitative momentum is one of the longest-running anomalies in financial markets, supported by 30 years of academic evidence and used by hedge funds, mutual funds, and factor ETFs. The core implementation is straightforward: rank assets by their trailing 12-1 month return, hold the winners, and rebalance monthly.

The hard parts are not the signal. They are honest backtesting, transaction-cost awareness, and risk management during the inevitable momentum crash. Build the strategy, stress-test it across regimes, scale exposure by volatility, and accept that the edge is measured over years, not months. Your next steps could include extending the code to a long-short construction, testing it across global ETFs, or layering a mean-reversion sleeve for diversification.

Frequently Asked Questions

Disclaimer: This article is for educational purposes only. Backtested results do not guarantee future performance. Trading involves substantial risk of loss.

References

• Jegadeesh, N. and Titman, S. (1993). Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency. Journal of Finance, 48(1), 65-91. SSRN link
• Moskowitz, T. J., Ooi, Y. H., and Pedersen, L. H. (2012). Time Series Momentum. Journal of Financial Economics, 104(2), 228-250. SSRN link
• Daniel, K. and Moskowitz, T. J. (2016). Momentum Crashes. Journal of Financial Economics, 122(2), 221-247. NBER link
• Barroso, P. and Santa-Clara, P. (2015). Momentum Has Its Moments. Journal of Financial Economics, 116(1), 111-120.
• Antonacci, G. (2014). Dual Momentum Investing. McGraw-Hill.