DEV Community: Kakembo Muhammed

How to Build a Simple Momentum Stock Trading Workflow With Data

Kakembo Muhammed — Tue, 07 Jul 2026 22:44:19 +0000

Momentum is the rare market anomaly with both a 30-year academic paper trail and a structure simple enough to implement in an afternoon of Python. Stocks that outperformed over the past 3 to 12 months tend to keep outperforming, to the tune of roughly 1% per month in the classic studies. The catch is that retail traders mostly lose money on it anyway, because they trade the vibe instead of the data.

This post builds the data version: a momentum screen, an entry rule, position sizing, and a quick validation pass, all in pandas. No trading experience assumed, no financial advice given. We are engineering a workflow and checking whether it holds up.

The Architecture

Four components, cleanly separated:

Universe → Screen → Entry logic → Risk sizing → Validation

Keeping them separate matters for the same reason it matters in any pipeline: you want to test and swap each stage independently. Most retail "strategies" fail because all four stages live inside one emotional decision made at 3:47 PM.

Step 1: Screening for Momentum

The screen encodes what decades of research say a momentum leader looks like: near its 52-week high, outperforming the index, in a structural uptrend, and liquid enough to trade.

import yfinance as yf
import pandas as pd
import numpy as np

TICKERS = ["AAPL", "MSFT", "NVDA", "AMZN", "META", "GOOGL", "AVGO",
           "TSLA", "LLY", "JPM", "V", "COST", "NFLX", "AMD", "CRM"]

def get_data(tickers, period="2y"):
    df = yf.download(tickers + ["SPY"], period=period, auto_adjust=True)
    return df["Close"]

def momentum_screen(close: pd.DataFrame) -> pd.DataFrame:
    spy = close["SPY"]
    rows = []
    for t in close.columns.drop("SPY"):
        s = close[t].dropna()
        if len(s) < 260:
            continue
        pct_off_high = s.iloc[-1] / s.rolling(252).max().iloc[-1] - 1
        rs_3m = (s.iloc[-1] / s.iloc[-63]) / (spy.iloc[-1] / spy.iloc[-63])
        rs_6m = (s.iloc[-1] / s.iloc[-126]) / (spy.iloc[-1] / spy.iloc[-126])
        sma50 = s.rolling(50).mean().iloc[-1]
        sma200 = s.rolling(200).mean().iloc[-1]
        rows.append({
            "ticker": t,
            "pct_off_52w_high": round(pct_off_high, 3),
            "rs_3m": round(rs_3m, 3),
            "rs_6m": round(rs_6m, 3),
            "trend_ok": sma50 > sma200,
        })
    df = pd.DataFrame(rows)
    passed = df[
        (df.pct_off_52w_high > -0.10)   # within 10% of 52w high
        & (df.rs_3m > 1.0)              # beating SPY, 3 months
        & (df.rs_6m > 1.0)              # beating SPY, 6 months
        & (df.trend_ok)                 # 50 SMA above 200 SMA
    ]
    return passed.sort_values("rs_6m", ascending=False)

close = get_data(TICKERS)
watchlist = momentum_screen(close)
print(watchlist)

Run this on the full S&P 500 or Russell 1000 and a 5,000-name universe collapses to a ranked watchlist. The relative strength ratio (rs_3m > 1.0 means the stock beat SPY over 63 trading days) is the workhorse column. Everything else is a sanity filter.

One data honesty note: auto_adjust=True matters. Unadjusted prices show fake crashes at every stock split, and your screen will happily "detect" them.

Step 2: The Entry Rule (Pullback, Not Chase)

The counterintuitive part of momentum, and the part the data supports: you do not buy the stock on the day it is up 8% and trending on social media. Extended entries force wide stops and wreck the risk-reward math. The higher-quality signal is a pullback to a rising 20-day EMA within an established uptrend:

def pullback_signal(s: pd.Series) -> bool:
    ema20 = s.ewm(span=20).mean()
    touched = (s.iloc[-5:] <= ema20.iloc[-5:] * 1.01).any()  # tagged the EMA
    reclaimed = s.iloc[-1] > s.iloc[-2]                       # strength returning
    rising = ema20.iloc[-1] > ema20.iloc[-21]                 # EMA still rising
    return bool(touched and reclaimed and rising)

signals = {t: pullback_signal(close[t].dropna())
           for t in watchlist.ticker}
print({t: v for t, v in signals.items() if v})

Plus one portfolio-level guard, the regime filter. It is a single boolean and it does more risk management than everything else combined:

spy = close["SPY"]
risk_on = spy.iloc[-1] > spy.rolling(200).mean().iloc[-1]

When risk_on is False, the workflow stops taking entries. Momentum's known failure mode is violent crashes at market turning points, and the 200-day filter on the index is the cheapest defense ever discovered.

Step 3: Sizing by Risk, Not by Feelings

Position size is a formula: account risk divided by stop distance. Stops are volatility-scaled using ATR so that a calm mega cap and a volatile mid cap each get proportional room.

def position_size(account: float, risk_pct: float,
                  entry: float, atr: float, atr_mult: float = 2.0):
    stop = entry - atr_mult * atr
    risk_per_share = entry - stop
    shares = int((account * risk_pct) / risk_per_share)
    return shares, round(stop, 2)

def atr(high, low, close, n=14):
    tr = pd.concat([
        high - low,
        (high - close.shift()).abs(),
        (low - close.shift()).abs()
    ], axis=1).max(axis=1)
    return tr.rolling(n).mean()

# Example: $50k account, 1% risk, entry $150, ATR $4
shares, stop = position_size(50_000, 0.01, 150, 4)
print(f"Buy {shares} shares, stop at ${stop}")
# Buy 62 shares, stop at $142.0

That is a $500 maximum loss on a $50,000 account, regardless of how confident anyone feels about the ticker. The formula is the whole point: sizing is the one stage of the pipeline where emotion does the most damage, so it gets zero degrees of freedom.

Step 4: Validate Before You Believe

Everything above is a hypothesis. The minimum viable validation is a vectorized backtest with three honesty mechanics: execute signals on the next bar (shift(1)), subtract realistic costs (~0.1 to 0.2% per round trip), and compare against buy-and-hold as the null hypothesis. I wrote a full guide to that layer, including the look-ahead and survivorship traps that silently inflate results, in a previous post on backtesting trading strategies in Python, so I will not repeat it here.

Two expectations to calibrate against before you run anything. First, a healthy momentum system wins roughly 40 to 55% of trades and profits through asymmetry, with winners 2 to 3 times the size of losers. If your test prints a 85% win rate, hunt for the bug before celebrating. Second, losing streaks of five-plus trades are a statistical certainty at those win rates, which is exactly why you validate: so a normal streak does not look like a broken system.

For the full trading-side workflow that sits on top of this data layer, including regime filters and exit rules with the numbers behind them, this breakdown of how to trade momentum stocks covers the parts that do not fit in a code post. And if you want to iterate on rule variants faster than rewriting pandas each time, platforms in this space have gotten good; Tradie accepts strategy rules in plain English and returns backtests with Monte Carlo distributions, then exports back to Python, which makes it a reasonable rapid-prototyping layer in front of the custom code you trust.

What This Workflow Is and Is Not

It is a data pipeline that removes discretion from four decisions: what to watch, when to enter, how much to buy, and when the environment is hostile. It is not a money printer, and nothing here is financial advice. The academic momentum premium is real, but capturing it net of costs, taxes, and your own behavior is an engineering problem, and like most engineering problems, it is lost or won in the boring parts: data quality, cost modeling, and validation.

Build the screen. Run it for a month against paper trades before real ones. Let the data tell you whether the edge survives contact with your execution.

Backtesting Trading Strategies in Python: The Complete Guide for Developers

Kakembo Muhammed — Tue, 07 Jul 2026 17:11:16 +0000

Roughly 70% of U.S. equity volume is executed by algorithms, and nearly every one of them was validated the same way before touching real money: backtesting trading strategies in Python. Yet most developers who try it lose money anyway. Not because their code is wrong, but because their methodology is. You write a clean strategy, the backtest prints a beautiful equity curve, you deploy it, and the market shreds it in three weeks. That gap between simulated glory and live pain has a name: bias. This guide shows you how to build a backtester that tells the truth. Stop trusting pretty curves. Start engineering honest ones.

Key Takeaways

Backtesting trading strategies in Python requires vectorized pandas operations, realistic cost modeling, and strict separation of signal generation from execution.
Look-ahead bias and survivorship bias inflate backtest returns by 2 to 4 percentage points annually in typical retail setups.
A round trip trade costs 0.2% to 0.9% in commissions, slippage, and spread; ignoring costs turns losing strategies into fake winners.
A 90%+ win rate in a backtest is usually a red flag for overfitting, not evidence of edge.
Walk-forward analysis and out-of-sample testing separate strategies that worked once from strategies that work repeatedly.

Why Most Python Backtests Lie to You
Building a Vectorized Backtester with Pandas
Modeling Costs, Slippage, and Execution Reality
Validating Your Strategy: Walk-Forward and Out-of-Sample Testing
When to Stop Writing Backtesters and Start Testing Strategies
Conclusion
Frequently Asked Questions

Why Most Python Backtests Lie to You

Your backtest is an adversary, not a report card. It will exploit every sloppy line of code to show you returns that never existed. The two most expensive bugs in backtesting trading strategies in Python are not runtime errors. They are silent methodology errors that compile fine and lie beautifully.

Look-Ahead Bias: The Off-By-One Error That Costs Real Money

Look-ahead bias means your strategy uses information that was not available at decision time. The classic version is an indexing mistake. You compute a signal from today's close, then simulate buying at today's close. In live trading, you cannot do that. The close does not exist until the bar is finished.

The fix is one line, and skipping it is the most common failure in retail backtests:

# WRONG: signal and trade on the same bar
df["position"] = np.where(df["sma_fast"] > df["sma_slow"], 1, 0)

# RIGHT: decide today, execute tomorrow
df["position"] = np.where(df["sma_fast"] > df["sma_slow"], 1, 0)
df["position"] = df["position"].shift(1)

That single .shift(1) routinely knocks 15% to 40% off a strategy's simulated annual return. If your edge disappears when you add it, you never had an edge. You had a time machine.

The subtle variants are worse than the obvious one. Computing a z-score with the full series mean instead of an expanding or rolling window leaks the future into every bar. Normalizing features with sklearn fit on the whole dataset before splitting does the same thing. Any operation that touches the entire column before the simulation loop is a suspect. Audit for them the way you audit for SQL injection: assume they exist until proven otherwise.

Survivorship Bias: Testing on the Winners

If you backtest on the current S&P 500 constituent list over the past 20 years, you are only testing companies that survived. The delisted, bankrupt, and acquired names are gone from your dataset, and they are exactly the stocks a real strategy would have bought on the way down. Academic estimates put the survivorship inflation at roughly 1% to 4% per year depending on universe and period, which is often larger than the entire edge a retail strategy claims.

For a deeper treatment of the statistical failure modes, the Wikipedia entry on backtesting is a solid reference point before you write another line of strategy code. Read it once. It will save you a quarter of tuition paid to the market.

Building a Vectorized Backtester with Pandas

Loops are for live trading. Vectors are for research. A vectorized backtest in pandas processes 10 years of daily data in milliseconds, which matters because honest research means testing hundreds of parameter variants, not one.

Here is a complete, honest moving average crossover backtest in about 40 lines. It includes the shift, the costs, and the benchmark comparison that most tutorials skip:

import yfinance as yf
import pandas as pd
import numpy as np

# 1. Data
df = yf.download("SPY", start="2015-01-01", end="2025-01-01", auto_adjust=True)
df = df[["Close"]].copy()

# 2. Signals
df["sma_fast"] = df["Close"].rolling(20).mean()
df["sma_slow"] = df["Close"].rolling(50).mean()
df["signal"] = np.where(df["sma_fast"] > df["sma_slow"], 1, 0)

# 3. Execute NEXT bar. Non-negotiable.
df["position"] = df["signal"].shift(1)

# 4. Returns
df["market_ret"] = df["Close"].pct_change()
df["strategy_ret"] = df["position"] * df["market_ret"]

# 5. Costs: charge 0.1% every time the position changes
cost_per_trade = 0.001
df["trades"] = df["position"].diff().abs()
df["strategy_ret"] -= df["trades"] * cost_per_trade

# 6. Results
df["strategy_equity"] = (1 + df["strategy_ret"]).cumprod()
df["market_equity"] = (1 + df["market_ret"]).cumprod()

ann_ret = df["strategy_ret"].mean() * 252
ann_vol = df["strategy_ret"].std() * np.sqrt(252)
sharpe = ann_ret / ann_vol
max_dd = (df["strategy_equity"] / df["strategy_equity"].cummax() - 1).min()

print(f"Annualized return: {ann_ret:.2%}")
print(f"Sharpe ratio:      {sharpe:.2f}")
print(f"Max drawdown:      {max_dd:.2%}")
print(f"Buy & hold return: {(df['market_equity'].iloc[-1] - 1):.2%}")

Three details make this honest rather than decorative. The shift(1) kills look-ahead. The auto_adjust=True flag handles splits and dividends so you are not trading phantom price gaps. And the buy-and-hold line at the bottom is your null hypothesis: if your strategy cannot beat doing nothing, the correct number of trades is zero.

Data Quality Is Half the Battle

Garbage data produces confident garbage. Before trusting any run, verify three things about your dataset. First, prices must be adjusted for splits and dividends; an unadjusted AAPL series shows a fake 75% crash at the 2020 4-for-1 split, and your strategy will "trade" it. Second, check for missing bars and duplicate timestamps with df.index.duplicated().sum() and a simple calendar diff; gaps silently distort rolling indicators. Third, know your data's timezone and session boundaries, because a daily bar stamped midnight UTC is not the same bar as one stamped at the 4:00 PM ET close.

Free data from yfinance is fine for learning and daily-timeframe research. The moment you move to intraday work or anything you intend to fund, budget $30 to $200 a month for a proper provider like Polygon or Databento. In backtesting trading strategies in Python, data spend is the cheapest insurance you will ever buy.

When you outgrow a single-file script, backtesting.py is the cleanest open-source framework for event-driven testing with built-in optimization heatmaps, and it stays compatible with the pandas skills you already have. Backtrader and VectorBT are the other two serious options, trading simplicity for power in different directions.

Modeling Costs, Slippage, and Execution Reality

A strategy that trades daily and ignores costs is fiction. A realistic round trip costs between 0.2% and 0.9% once you stack commission, spread, and slippage. On a strategy that trades 100 times a year, that is 20% to 90% of capital burned annually on friction alone. Most "profitable" retail backtests die right here.

The math is brutal and worth internalizing. Suppose your signal has a genuine gross edge of 0.15% per trade, which would put you ahead of most retail systems on the planet. At 0.20% round-trip cost, your true expectancy is negative 0.05% per trade. You have a real edge and you are still guaranteed to lose money. This is why professionals obsess over execution while hobbyists obsess over indicators, and why cost modeling belongs in the first version of your backtester, not the last.

The Three Costs You Must Model

Commission is the easy one: a fixed percentage or per-share fee, known in advance. Spread is the gap between bid and ask; you buy at the ask and sell at the bid, so every round trip donates the spread to a market maker. Slippage is the difference between the price that triggered your signal and the price you actually filled at, and it grows with order size, volatility, and how fast the market is moving against you.

A defensible cost model for liquid U.S. large caps in 2026 looks like this: 0.0% to 0.05% commission (most retail brokers are zero), 0.01% to 0.05% spread, and 0.05% to 0.15% slippage. For crypto, triple the slippage. For small caps or exotic forex pairs, model 0.3% or refuse to trade them.

def apply_costs(returns, trades, commission=0.0005,
                spread=0.0003, slippage=0.001):
    total_cost = commission + spread + slippage
    return returns - trades * total_cost

Stress Test the Cost Assumption

Do not pick one cost number. Sweep it. Run the same backtest at 0.05%, 0.10%, 0.20%, and 0.40% per trade and plot the four equity curves together. A robust strategy degrades gracefully across that sweep. A curve-fit strategy collapses somewhere around 0.10%, and you want to discover that in pandas, not in your brokerage statement.

The frequency of your strategy sets the stakes. A monthly rebalance barely notices costs. A strategy averaging two trades a day lives or dies entirely on execution modeling. High turnover demands proof, not optimism.

Validating Your Strategy: Walk-Forward and Out-of-Sample Testing

Here is the uncomfortable truth this entire discipline runs on: a 90%+ win rate backtest is usually a red flag, not a feature. With enough parameters, you can fit any historical dataset perfectly and predict nothing. Overfitting is not a risk in strategy research. It is the default outcome, and validation is how you fight it.

The Train/Test Split You Already Know, Applied to Markets

The minimum standard is out-of-sample testing. Optimize your parameters on 2015 to 2021, then run the frozen strategy on 2022 to 2025 exactly once. If performance holds within roughly 30% of in-sample results, you may have something. If it evaporates, you fit noise. The discipline is in the "exactly once": every time you peek at the test set and adjust, you have quietly converted it into training data.

Walk-Forward Analysis: The Rolling Version

Walk-forward analysis makes this rolling. Optimize on a 3-year window, trade the next 6 months out-of-sample, slide forward, repeat. Stitch the out-of-sample segments together and that concatenated curve is the only performance you are allowed to believe.

def walk_forward(df, train_years=3, test_months=6):
    results = []
    start = df.index.min()
    while True:
        train_end = start + pd.DateOffset(years=train_years)
        test_end = train_end + pd.DateOffset(months=test_months)
        if test_end > df.index.max():
            break
        train = df.loc[start:train_end]
        test = df.loc[train_end:test_end]
        best_params = optimize(train)          # your grid search
        results.append(run(test, best_params)) # frozen params
        start += pd.DateOffset(months=test_months)
    return pd.concat(results)

Monte Carlo: Interrogating a Single History

Even a clean walk-forward result is one path through history. Monte Carlo simulation resamples your trade sequence thousands of times to build a distribution of outcomes, exposing the drawdowns you got lucky enough not to see. The implementation is ten lines: take your list of individual trade returns, shuffle-sample it with replacement 10,000 times using np.random.choice, compound each sample into an equity path, and read the 5th percentile of max drawdown off the resulting distribution. If that number is one you cannot stomach, the strategy fails regardless of its Sharpe ratio.

Regime matters just as much. A strategy validated entirely inside the 2023 to 2025 bull run has never met a bear market, a rate shock, or a volatility spike like the August 2024 yen-carry unwind that briefly sent the VIX above 65. Segment your backtest by regime, using a simple 200-day moving average filter or realized volatility buckets, and demand that the strategy at least survives its worst regime rather than only feasting in its best. This is the part of backtesting trading strategies in Python that separates hobbyists from operators: hobbyists report one number, operators report a distribution.

When to Stop Writing Backtesters and Start Testing Strategies

There is a moment in every developer's algo-trading journey where you realize you have spent four months building infrastructure and four hours actually researching strategies. The backtester became the project. It is a fun project. It is also, usually, the wrong one if your goal is finding an edge rather than building an engine.

The build-it-yourself path teaches you things no platform can: you will never trust a backtest blindly again once you have personally shipped a look-ahead bug. Every developer should build the 40-line version above at least once. But data pipelines, corporate action handling, options chains with Greeks, multi-asset support, and Monte Carlo tooling are each their own engineering project, and they are solved problems. Backtesting trading strategies in Python by hand is a rite of passage; maintaining a production research stack alone is a second job.

This is the gap Tradie targets. You describe a strategy in plain language, and it builds, backtests, and optimizes it across stocks, options, crypto, forex, and indices, with 30+ backtest metrics and Monte Carlo scenario projection handled for you. The workflow that took our walk-forward function a weekend to wire up runs in under 30 seconds, and options strategies come with real Greeks and probability-of-profit instead of a spreadsheet. Usefully for developers, it exports strategies to Python and Pine Script, so it works as a rapid research layer on top of the custom stack you already trust rather than a black box replacing it.

The same team writes solid strategy research if you want to see the methodology applied; their breakdown of order blocks and supply/demand zones is a good example of turning a discretionary chart concept into testable rules.

The honest framing: build your own engine to learn, use a platform to iterate. The bottleneck in strategy research is ideas tested per week, not lines of infrastructure written. Pick the tool that maximizes that number for you, and hold both to the same validation standards this guide laid out.

Conclusion

The market does not pay you for writing code. It pays you for being right about the future more often than you are wrong, after costs. Backtesting trading strategies in Python is how you estimate that probability before risking capital, and the difference between a useful estimate and an expensive fantasy comes down to four disciplines: shift your signals, subtract real costs, test out-of-sample, and treat beautiful equity curves as accusations rather than achievements. Build the 40-line backtester. Break it. Learn why it lied to you. Then decide whether your edge comes from owning the infrastructure or from testing more ideas faster than the next trader. The 40-line script above is enough to start tonight, and for the ideas that survive it, running a deeper backtest on Tradiemight be the start of a better research loop than either of us could write alone.

Frequently Asked Questions

What is backtesting in trading?

Backtesting is the process of running a trading strategy against historical market data to estimate how it would have performed. It produces metrics like annualized return, Sharpe ratio, win rate, and maximum drawdown. A backtest is a filter, not a promise: it cannot prove a strategy will work, but it reliably exposes strategies that never worked.

Is Python good for backtesting trading strategies?

Yes, Python is the industry standard for backtesting trading strategies. Pandas and NumPy handle vectorized computation over millions of price rows in seconds, yfinance provides free historical data, and frameworks like backtesting.py, Backtrader, and VectorBT cover event-driven simulation. Most quant desks and retail algo traders alike research in Python before deploying anywhere.

How much historical data do I need for a reliable backtest?

Use a minimum of 5 years of data for daily strategies, and ideally 10+ years spanning multiple market regimes, including at least one bear market. Intraday strategies need less calendar time but far more bars; 1 to 2 years of minute data is a reasonable floor. Testing only inside a bull market validates nothing.

What is look-ahead bias in backtesting?

Look-ahead bias occurs when a backtest uses information that was not available at the moment of the simulated trade, such as trading on the same bar's close that generated the signal. It silently inflates returns, often by double-digit percentages annually. The standard fix in pandas is shifting your position column by one bar.

Why do backtested strategies fail in live trading?

The usual causes are overfitting to historical noise, unmodeled costs and slippage, look-ahead or survivorship bias, and regime change. A strategy tuned until the backtest looks perfect has typically memorized the past rather than learned a repeatable edge. Out-of-sample and walk-forward validation catch most of these failures before real money does.

What is a good Sharpe ratio for a backtest?

For a realistic retail strategy after costs, a Sharpe ratio between 1.0 and 2.0 out-of-sample is strong. In-sample Sharpes above 3.0 usually indicate overfitting rather than genius. Context matters: compare against buy-and-hold on the same asset over the same period, since the S&P 500 alone has delivered a long-run Sharpe near 0.5 to 0.7.

Can I backtest options strategies in Python?

Yes, but it is significantly harder than equities. You need historical options chains, accurate Greeks, and implied volatility data, which are rarely free, plus modeling for early assignment and IV crush. Many developers use a platform for options backtesting; Tradie, for example, handles 58 options strategies with real Greeks and probability-of-profit built in.

How do I avoid overfitting when backtesting trading strategies?

Limit yourself to few parameters, reserve untouched out-of-sample data, and run walk-forward analysis so parameters are always tested on unseen periods. Sweep your cost assumptions and require the strategy to survive higher friction. Distrust perfection: if results look too good, assume a bug or bias first and an edge last.