CrackingMarkets
Trading Boosters · · 40 min read

US Stock Momentum Trading System for Retail Traders [Deep research]

I recently tested ChatGPT Pro’s Deep Research functionality (released on Monday, February 3, 2025)—currently priced at $200/month—using the latest o3-mini-high model. My objective? To evaluate how effectively it can assist in developing a US Stock Momentum Trading System for retail traders.

After about 10 minutes of AI-driven analysis, the results were quite impressive. The model pulled together an extensive list of sources, showcasing its research capabilities, and even provided a usable pseudocode for an actual momentum strategy.

Deep Research is shaping up to be a powerful tool for trading strategy development, and in this article, you can see the full results—without having to pay $200 yourself. Check out the AI’s response below!

Prompt I used:

Conduct a deep research study to develop a robust US stock momentum trading system for retail traders. The system should be designed to hold a maximum of 10 stocks per month, with a systematic approach to stock selection, entry, exit, and risk management.

Key Requirements:
Universe of Stocks: Define the universe of stocks to be considered (e.g., S&P 500, Russell 1000, or all US-listed stocks with liquidity filters).
Momentum Criteria: Develop a quantitative momentum ranking methodology (e.g., 6-month/12-month price change, relative strength, moving average crossovers).
Holding Period & Rebalancing: Optimize the rebalancing frequency (e.g., monthly) and determine the most effective stock turnover rules.
Position Sizing: Define position sizing methods (e.g., equal weight, volatility-adjusted).
Risk Management: Implement stop-loss rules, maximum drawdown limits, and position risk controls.
Market Regime Adaptation: Explore methods to adapt the system during bull/bear markets (e.g., cash allocations, moving average filters).
Backtesting & Performance Metrics: Provide historical backtesting results, including CAGR, max drawdown, Sharpe ratio, and win rate, using at least 10+ years of data.
Practical Considerations: Address issues like trading costs, slippage, tax implications, and implementation feasibility for a retail trader.
The final output should include a detailed research report with all key parameters, data-driven justifications, and potential improvements for real-world implementation.

Objective: The goal is to create a practical, high-performing, and easy-to-execute momentum trading system tailored for individual retail traders with limited capital and execution constraints.

Analysis I received:

Momentum investing is a strategy of “buying high and selling higher,” capitalizing on the tendency of recent stock winners to continue outperforming in the medium-term​ stockopedia.com​ stockopedia.com. This research outlines a robust momentum trading system tailored for U.S. stocks, suitable for smaller retail accounts. We cover the full design: stock universe selection, momentum ranking, holding period, position sizing, risk management, adaptation to market regimes, backtesting results, practical implementation issues, and pseudocode for implementation. Each component is backed by data and research findings.

1. Stock Universe and Liquidity Filters

A well-defined stock universe with liquid names is the foundation of a retail momentum strategy. We focus on U.S. equities with adequate liquidity and size to ensure easy trade execution and minimal slippage:

By applying these universe filters, a retail trader keeps the pool to a manageable size (hundreds of stocks instead of thousands) and focuses on liquid names. For example, after applying liquidity, price, and volatility filters, one system reduced the S&P 1500 universe to about ~1,264 tradable stocks​ stockcharts.com​ stockcharts.com. This approach balances breadth (to have enough candidates) with practicality (to ensure trades can be executed easily).

2. Momentum Ranking Criteria

With a defined universe, the next step is quantitatively ranking stocks by momentum. Momentum can be measured in various ways – the goal is to identify stocks with the strongest price strength and trend persistence. Key criteria and indicators include:

By using these criteria, the system identifies the leaders (“recent winners”) in the market. This implements the mantra of momentum investing – buy stocks that are already going up strongly​ stockopedia.com. Studies have shown this approach to be effective because investors and even company management under-react to positive changes, allowing trends to persist ​stockopedia.com. Regular ranking updates are crucial: momentum is a fast-changing factor, so one must frequently scan and rerank to catch new leaders as old trends fade ​stockopedia.com​ stockopedia.com.

3. Holding Period and Rebalancing Frequency

Momentum strategies inherently require regular rebalancing to rotate into the newest outperforming stocks. The optimal holding period balances capturing the momentum effect versus incurring too much turnover:

In summary, the strategy will hold a rotating basket of ~10 top momentum stocks, updated monthly. Regular rebalancing is critical – as one study notes, momentum requires continually refreshing into recent winners, since even the strongest trends tend to revert after 6-12 months​ stockopedia.com​ stockopedia.com. Monthly turnover allows the strategy to stay in phase with shifting market leadership, which is vital for maintaining performance.

4. Position Sizing for Small Accounts

Position sizing determines how much capital to allocate to each stock. For smaller accounts, position sizing must balance simplicity, risk control, and account constraints (like avoiding too many small odd-lot trades). We consider a few approaches:

In summary, equal-weighting 10 positions (approximately 10% of capital each) is a solid baseline for a retail momentum portfolio. It’s straightforward and has been used in many momentum implementations​ spglobal.com​ spglobal.com. Traders seeking more refinement can use a risk-based formula (ensuring, for example, each position would lose ~1% of account if stopped out), but should be mindful that in extreme markets equal-weight and risk-weight tend to converge in outcome ​turingtrader.com. The priority is to ensure no single trade can make or break the account – distributing risk evenly across positions.

5. Risk Management Rules

Momentum trading can be highly profitable but also volatile. Proper risk management is critical to protect the downside and preserve capital through inevitable drawdowns. We incorporate several layers of risk control:

In combination, these risk measures aim to mitigate downside while preserving upside. Momentum trading will still have drawdowns – it’s volatile by nature​ stockcharts.com– but prudent risk management ensures that no single trade or market event destroys our capital. For example, a well-managed momentum portfolio in testing had a max drawdown of ~20% while delivering strong returns​ stockcharts.com​ stockcharts.com, thanks to trend filters and stops. The trader’s mindset must be disciplined: accept many small losses (momentum strategies often have 40–50% losing trades ​stockcharts.com​ stockcharts.com) in exchange for big winners that drive the profits. Risk rules enforce those small losses and prevent holding the losers too long.

6. Adapting to Market Regimes

Market conditions fluctuate between bull markets, bear markets, and sideways periods. A robust momentum system should adapt to different market regimes to avoid chasing momentum in unfavorable environments. We incorporate mechanisms to detect regime changes and adjust our strategy:

By adapting to market regimes, the momentum system becomes more robust to different environments. In essence, full throttle during bull trends, defensive during bears. This adaptation is crucial because momentum, while powerful, has an “Achilles’ heel” during regime shifts​ stockopedia.com​ stockopedia.com. Incorporating regime filters (trend filter, volatility filter, crash indicator) helps avoid the worst outcomes without sacrificing much of the upside. For instance, a momentum strategy that only traded in uptrend periods of the market achieved similar returns with significantly lower drawdowns in testing​ stockcharts.com ​stockcharts.com. Our system will primarily rely on the simple 200-day moving average market filter and the option to hold cash – easy to implement and proven effective over decades of market history​ therobusttrader.com​ therobusttrader.com.

7. Backtesting Results and Performance Metrics

To validate the momentum strategy, we conduct backtests over at least the past 10–15 years (preferably even 20+ years to include different cycles). Key performance metrics to evaluate include Compound Annual Growth Rate (CAGR), Sharpe ratio, maximum drawdown, volatility, win rate, and portfolio turnover. Below we summarize typical results from momentum strategy research and what one might expect from our system:

Overall, the backtest will demonstrate whether the selected momentum criteria and risk controls produced superior risk-adjusted returns. We will look at CAGR, Sharpe, Max DD, win rate, and annual returns to ensure the strategy meets expectations. If results show too low a Sharpe or intolerable drawdowns, we’d refine the filters or stops accordingly. But given prior research, a well-designed momentum system has delivered attractive performance, such as double-digit annual returns with moderate drawdowns stockcharts.com​ stockcharts.com, making it a compelling strategy for growth of a small account (as long as the trader can stick through the rough patches with discipline​ stockcharts.com ​stockcharts.com).

Note: We will use total return data (including dividends) and account for realistic constraints in backtesting (e.g., use historical index constituents to avoid survivorship bias ​stockcharts.com​ stockcharts.com, include estimated trading costs). This ensures performance metrics are not overstated relative to real-world conditions.

8. Practical Considerations for Real-World Implementation

Implementing this momentum system in a real trading account requires addressing several practical issues: trading costs, slippage, taxes, and execution feasibility. Below we discuss these considerations and how to mitigate them for retail traders:

In summary, from a practical standpoint: keep trading costs low (use a commission-free broker and liquid stocks), be mindful of tax efficiency, execute trades systematically with minimal slippage, and remain disciplined. The strategy is implementable with standard tools and a monthly commitment of time. By accounting for these real-world factors, a retail trader can closely approximate the backtested performance in actual execution​ eaminvestors.com​ eaminvestors.com, which is the ultimate goal.

9. Pseudocode and Implementation Outline

Finally, we provide a structured outline and pseudocode to implement the momentum system. This serves as a step-by-step guide that a retail trader or programmer can follow on their platform of choice:

Define Universe & Data:

  1. Gather Universe List: Start with a list of all candidate stocks (e.g., constituents of S&P 500 + Russell 1000, or S&P 1500). Update this list periodically (e.g., annually) to account for index changes and to avoid survivorship bias in backtests ​stockcharts.com ​stockcharts.com.
  2. Fetch Data: For each stock in the universe, retrieve historical price data (daily or weekly closes) and volume. Adjust prices for dividends and splits to use total returns​ stockcharts.com ​stockcharts.com.
  3. Apply Filters: Remove stocks that do not meet criteria:
    • Exclude those with 50-day avg dollar-volume < $5,000,000 (or 50-day avg share volume < 300k) ​stockcharts.com​ stockcharts.com.
    • Exclude those with price < $10 (based on a 20-day moving average price, for example)​ stockcharts.com ​stockcharts.com.
    • (Optional) Exclude stocks with extremely high recent volatility (e.g., top 1% standard deviation) to avoid ultra-volatile names ​stockcharts.com​ stockcharts.com.
    • (Optional) Exclude stocks that doubled in the last 6 months to avoid buying after a parabolic move ​stockcharts.com ​stockcharts.com (this was suggested by Arthur Hill). After filtering, proceed with the remaining universe.

Momentum Ranking Calculation (performed at each rebalance date):

  1. Compute Momentum Metric: For each stock in the filtered universe, calculate the chosen momentum indicator. For example:

momentum_score[stock] = TotalReturn(stock, past 6 months)

  1. where TotalReturn could be (Price_today / Price_6months_ago – 1) * 100%. Alternatively, use a combination (e.g., 9-month return minus 1-month return).
  2. Trend Filter on Stock (optional): If using individual trend criteria, ensure stock’s 50-day > 200-day or 10-week > 40-week EMA. If a stock is not in an uptrend, you may penalize its score or drop it. (This can be integrated into the ranking by, for instance, setting momentum_score to –inf for stocks failing the trend check so they never get picked).
  3. Rank Stocks: Sort the stocks by momentum_score in descending order. Create a ranked list of tickers.

Portfolio Construction (at rebalance date):

  1. Market Regime Check: Before selecting positions, check the overall market trend:

if S&P500_index_price < S&P500_200day_MA:
set inRiskOffMode = True
else:
set inRiskOffMode = False

position_size[stock] = min( MaxCap*TotalPortfolioValue,
(RiskPerTrade * TotalPortfolioValue) / (CurrentPrice - StopPrice) )

where RiskPerTrade might be 1% (=0.01), and MaxCap maybe 0.15 (15% of portfolio max per stock).

Ensure the sum of allocated amounts does not exceed available capital (if using rounding, adjust the last position slightly or hold a tiny cash remainder).

Execution of Trades:

  1. Compare to Current Holdings: On rebalance day, look at currently held stocks versus the new top picks:
    • Sell any current holding that is not in the new top list (or if in risk-off, sell all if going to cash).
    • Buy any stock in the top list that is not currently held.
    • If a current holding is still in the top list, hold onto it (possibly rebalance its size if using equal weight – e.g., top off or sell a bit to get back to equal weight if needed).
    • It's possible some positions remain the same and some new ones enter.
  2. Place Orders: Execute sell orders first (to free up capital), then buys. Use appropriate order types (market-on-open or limit orders as planned). For backtesting, assume ideal execution at the next day open price (with a slippage assumption).
  3. After Execution: Update the portfolio holdings and cash balance. Track the entry price for each position (used for stop calculations and performance tracking).

Intra-Rebalance Monitoring (between monthly rebalances):

  1. Stop-Loss Monitoring: Each day (or intraday), check each holding’s price against its stop level:

for each stock in portfolio:
if Price(stock) <= StopPrice(stock):
sell stock (stop triggered)
move proceeds to cash

  1. After a stop-out, you might optionally replace it with the next-highest momentum stock at that time, or wait until next rebalance. A simple approach is to wait for next scheduled rebalance to reallocate that cash, to avoid too-frequent trading. If stops are hit often, you might consider mid-month replacements from the current ranks.
  2. Market Regime Monitoring: Also monitor the S&P 500 trend. If a regime filter triggers mid-cycle (e.g., market falls below 200-day), one could choose to scale out rather than waiting. This might be advanced logic; our baseline will adjust positions at the next monthly check unless an extreme move compels immediate action.

Loop: The above steps (4–14) repeat each rebalance period (monthly):

  1. Next Rebalance: At the next month’s end, recalc momentum scores, adjust ranks, and go through selection again. This rotational process continues, building an equity curve over time.

Backtest and Record Metrics:

  1. Record Performance: At each step, record portfolio value, returns, and trades made. Track metrics such as CAGR, volatility, Sharpe (can be calculated at end), max drawdown (track the highest portfolio value and subsequent drops), etc.
  2. Analyze Turnover: Count trades and turnover% = (total value of trades in a year) / (average portfolio value).
  3. Verify Constraints: Ensure the strategy adhered to constraints (e.g., never more than 10 stocks, respected filters, etc.).

This pseudocode can be translated into a simple algorithm on many platforms. For example, in Python pseudocode:

universe = load_universe()  # initial stock list
portfolio = {}  # dict to hold current positions and shares
cash = initial_capital

for date in rebalance_dates:
    prices = get_prices(universe, date)
    volumes = get_volumes(universe, date)
    # 1. Apply filters
    tradable_stocks = [stk for stk in universe if avg_volume(stk,50,date) > min_vol 
                       and avg_price(stk,20,date) > min_price]
    # 2. Compute momentum scores
    scores = {stk: total_return(stk, lookback_period, date) for stk in tradable_stocks}
    # Optionally enforce stock trend filter:
    for stk in list(scores.keys()):
        if not uptrend(stk, date): 
            del scores[stk]
    # 3. Market regime check
    market_trend = calc_SP500_trend(date)
    if market_trend == "bear":
        target_positions = []  # possibly go to cash
    else:
        # 4. Rank and pick top N
        top_stocks = sort_by_value(scores, descending=True)[:10]
        target_positions = top_stocks
    # 5. Determine new trades
    sells = [stk for stk in portfolio if stk not in target_positions]
    buys  = [stk for stk in target_positions if stk not in portfolio]
    # (If len(target_positions) < len(portfolio) due to bear regime, sells might include all current holdings)
    # 6. Execute sells
    for stk in sells:
        sell_price = get_price(stk, date, exec_time="open")
        cash += sell_price * portfolio[stk]
        portfolio.pop(stk)
    # 7. Execute buys
    allocate_capital = cash  # assume use all cash for new buys
    if target_positions:
        alloc_per_stock = allocate_capital / len(target_positions)
    for stk in target_positions:
        if stk not in portfolio:
            buy_price = get_price(stk, date, exec_time="open")
            shares = alloc_per_stock / buy_price
            portfolio[stk] = shares
            cash -= shares * buy_price
        else:
            # if already held, optionally rebalance quantity to equal weight
            current_val = portfolio[stk] * buy_price
            desired_val = alloc_per_stock
            if abs(current_val - desired_val)/desired_val > rebalance_threshold:
                # top up or trim to rebalance
                delta_val = desired_val - current_val
                if delta_val > 0:  # buy more
                    add_shares = delta_val / buy_price
                    portfolio[stk] += add_shares
                    cash -= add_shares * buy_price
                else:  # sell some
                    rem_shares = -delta_val / buy_price
                    portfolio[stk] -= rem_shares
                    cash += rem_shares * buy_price
    # 8. Set stop prices for new holdings
    for stk in portfolio:
        set_stop[stk] = get_price(stk, date) * (1 - stop_loss_pct)
    # (Between rebalances, monitor stops and adjust portfolio accordingly)

This is a rough outline. In a common trading platform, one could implement this logic via their scripting language or even manually:

The pseudocode above highlights the main steps: filter universe, rank by momentum, apply market filter, choose top N, size positions, execute trades, manage stops. By following these steps, a retail trader can effectively implement the momentum system. It’s important to test the code/approach on historical data (paper trading) before committing real money, to ensure all details are handled (such as handling gaps, dividends, etc.).

With this implementation plan, even those using basic tools can operationalize the strategy. For example, one could perform steps 1-3 in a spreadsheet, then use their brokerage to execute 4-7. Over time, one might automate more of it as comfort with coding or platforms grows.

Final note: Always monitor the system’s performance and market behavior. If conditions change or if backtest assumptions no longer hold (e.g., a regime of persistently high volatility), be prepared to refine parameters (like stop size or universe). The pseudocode provides a solid starting framework which can be iteratively improved.

Conclusion

In summary, we have developed a comprehensive momentum trading system for U.S. stocks tailored to retail traders with smaller accounts. The strategy focuses on liquid mid-to-large cap stocks, ranks them by robust momentum indicators, and holds a concentrated portfolio of the top performers with monthly rebalancing. We emphasized prudent position sizing (leaning towards equal weights for simplicity), and layered on multiple risk management techniques – from stop-losses on individual stocks to market-wide trend filters – to protect against adverse market swings. By adapting to market regimes (going to cash in bear trends or high-volatility periods), the system aims to avoid the known pitfalls of momentum crashes while capturing the upside during favorable conditions.

Backtesting evidence and cited research support the efficacy of momentum investing: historically higher returns and Sharpe ratios than the broad market, albeit with higher turnover​ stockcharts.com​ stockcharts.com. Key performance metrics like a ~10-15% CAGR, moderate drawdowns (20-30%), and win rates around 50-60% were observed in similar approaches, indicating a positive expectancy strategy​ stockcharts.com ​stockcharts.com. With modern zero-commission trading and careful stock selection, the approach is feasible for small accounts – transaction costs can be kept low ​eaminvestors.com ​eaminvestors.com, and diversification across 10 stocks is achievable even with limited capital.

We also addressed practical considerations to ensure a smooth real-world implementation. The importance of discipline and consistency cannot be overstated: momentum strategies can test one’s conviction during whipsaws, but following the system’s rules is crucial to achieve the long-term edge​ stockcharts.com​ stockcharts.com. Continuous monitoring of performance and market changes will allow for incremental improvements – for instance, adjusting filters or exploring enhancements like incorporating fundamental momentum (earnings surprises) or using intraday data for timing entries could be future tweaks.

Potential enhancements for real-world application include:

By adhering to the framework outlined – Universe → Momentum Ranking → Portfolio Construction → Risk Controls → Regime Adaptation – retail traders can implement a momentum system that is both robust and actionable. With diligent execution, the strategy offers a data-driven path to potentially outperform the market while managing risks, aligning with the core momentum principle that “the trend is your friend” as long as it is correctly harnessed. The provided pseudocode and guidelines equip traders to start trading this strategy or to further research and customize it to their needs.

Sources:

These sources and our analysis collectively validate the strategy parameters and provide confidence in the approach. By combining academic insights with practical trading knowledge, the designed momentum system is both evidence-based and tuned for real-world use by a retail trader. stockcharts.com​stockcharts.com

Share Tweet Share Share Email

Read next