Mark Minervini Swing Trading Style Guide⁠‍⁠​‌​‌​​‌‌‍​‌​​‌​‌‌‍​​‌‌​​​‌‍​‌​​‌‌​​‍​​​​​​​‌‍‌​​‌‌​‌​‍‌​​​​​​​‍‌‌​​‌‌‌‌‍‌‌​​​‌​​‍‌‌‌‌‌‌​‌‍‌‌​‌​​​​‍​‌​‌‌‌‌‌‍​‌​​‌​‌‌‍​‌‌​‌​​‌‍‌​‌​‌‌‌​‍​​‌​‌​​​‍‌‌‌​‌​‌‌‍​​‌​‌‌‌​‍​‌‌‌‌‌‌‌‍​​‌​‌‌‌‌‍​‌‌‌​‌​​‍​​​​‌​​‌‍‌​‌‌‌​‌​⁠‍⁠

Overview

Mark Minervini is a 3-time US Investing Champion who turned $100,000 into over $30 million. His SEPA (Specific Entry Point Analysis) methodology combines trend analysis, volatility contraction patterns, and strict risk management into a repeatable system. He emphasizes buying leading stocks at specific low-risk entry points within confirmed uptrends.

Core Philosophy

"The goal is not to buy low and sell high. It's to buy high and sell higher."

"Risk management is not about avoiding losses—it's about keeping losses small so you can stay in the game."

"I don't buy stocks that are going up. I buy stocks that are going up the right way."

Minervini believes that most of the money in the stock market is made in the middle of a move, not at the bottom. By waiting for stocks to prove themselves in a Stage 2 uptrend, you trade with the trend while managing risk through precise entries.

Design Principles

Trend First: Only buy stocks in a confirmed Stage 2 uptrend.

Specific Entry Points: Enter at low-risk pivot points, not randomly.

Volatility Contraction: Tightening price action precedes explosive moves.

Cut Losses Quickly: 7-8% maximum loss, often tighter.

Let Winners Run: Sell strength, not weakness.

The Trend Template (8 Criteria)

A stock MUST pass ALL 8 criteria before consideration:

1. Current price > 150-day MA
2. Current price > 200-day MA
3. 150-day MA > 200-day MA
4. 200-day MA trending up for at least 1 month (ideally 4-5 months)
5. 50-day MA > 150-day MA AND 50-day MA > 200-day MA
6. Current price > 50-day MA
7. Current price at least 25% above 52-week low
8. Current price within 25% of 52-week high (ideally within 15%)

Stage Analysis:

• Stage 1: Basing/accumulation (avoid)

• Stage 2: Advancing/uptrend (BUY ZONE)

• Stage 3: Topping/distribution (avoid)

• Stage 4: Declining/downtrend (avoid)

Volatility Contraction Pattern (VCP)

The VCP is Minervini's signature setup:

VCP Structure:

Price T1 | /
| / \ T2 | / \ /\ T3 | / X \ /\ Pivot | / | X \ /----→ BREAKOUT | / | | / |/ | |
Base C1 C2 C3 (contractions tighten)

T = Thrust (price expansion) C = Contraction (price tightening)

VCP Characteristics:

• Minimum 2 contractions, ideally 3-4

• Each contraction is SHALLOWER than the previous

• Contractions: 1st: 20-35%, 2nd: 10-20%, 3rd: 5-15%, 4th: 3-8%

• Volume DECREASES during contractions (supply drying up)

• Volume INCREASES on breakout (demand returning)

When Swing Trading

Always

• Confirm stock passes ALL 8 trend template criteria

• Wait for a proper VCP or constructive base

• Enter on breakout above pivot with volume surge (50%+ above average)

• Set stop at 7-8% maximum (tighter if possible based on structure)

• Have a sell plan BEFORE you enter

• Trade liquid stocks (avg volume > 400K)

Never

• Buy a stock in Stage 1, 3, or 4

• Chase extended stocks (>10% above pivot)

• Average down on a losing position

• Hold through an 8%+ loss

• Buy on light volume breakouts

• Ignore relative strength vs market

Prefer

• Stocks with RS Rating > 85 (top 15% performers)

• EPS growth > 25% recent quarters

• Tight consolidations (VCP) over wide-and-loose bases

• Breakouts from IPO bases or first Stage 2 breakouts

• Industry group strength (top 20% of groups)

• Institutional accumulation (up weeks on volume)

Code Patterns

Trend Template Scanner

class TrendTemplateScanner: """ Minervini Trend Template: all 8 criteria must pass. This is the first filter—non-negotiable. """

def check_trend_template(self, 
                          df: pd.DataFrame,
                          min_200ma_uptrend_days: int = 22) -> TrendTemplateResult:
    """
    Check if stock passes all 8 trend template criteria.
    """
    close = df['close']
    
    # Calculate moving averages
    ma_50 = close.rolling(50).mean()
    ma_150 = close.rolling(150).mean()
    ma_200 = close.rolling(200).mean()
    
    current_price = close.iloc[-1]
    current_50ma = ma_50.iloc[-1]
    current_150ma = ma_150.iloc[-1]
    current_200ma = ma_200.iloc[-1]
    
    # 52-week high/low
    high_52w = close.rolling(252).max().iloc[-1]
    low_52w = close.rolling(252).min().iloc[-1]
    
    # Check 200-day MA trend
    ma_200_month_ago = ma_200.iloc[-min_200ma_uptrend_days]
    ma_200_trending_up = current_200ma > ma_200_month_ago
    
    criteria = {
        '1_price_above_150ma': current_price > current_150ma,
        '2_price_above_200ma': current_price > current_200ma,
        '3_150ma_above_200ma': current_150ma > current_200ma,
        '4_200ma_trending_up': ma_200_trending_up,
        '5_50ma_above_150_and_200': (current_50ma > current_150ma) and (current_50ma > current_200ma),
        '6_price_above_50ma': current_price > current_50ma,
        '7_price_25pct_above_52w_low': current_price >= low_52w * 1.25,
        '8_price_within_25pct_of_52w_high': current_price >= high_52w * 0.75,
    }
    
    all_pass = all(criteria.values())
    
    return TrendTemplateResult(
        passes=all_pass,
        criteria=criteria,
        stage=self.determine_stage(df, criteria),
        price=current_price,
        ma_50=current_50ma,
        ma_150=current_150ma,
        ma_200=current_200ma,
        pct_from_52w_high=(current_price - high_52w) / high_52w * 100,
        pct_from_52w_low=(current_price - low_52w) / low_52w * 100
    )

def determine_stage(self, df: pd.DataFrame, criteria: dict) -> int:
    """
    Determine Weinstein Stage (1-4).
    """
    if all(criteria.values()):
        return 2  # Stage 2 uptrend
    
    close = df['close']
    ma_200 = close.rolling(200).mean()
    
    # Stage 4: Price below declining 200 MA
    if close.iloc[-1] < ma_200.iloc[-1] and ma_200.iloc[-1] < ma_200.iloc[-22]:
        return 4
    
    # Stage 3: Price near/below flattening 200 MA
    if close.iloc[-1] < ma_200.iloc[-1] * 1.05:
        return 3
    
    # Stage 1: Basing
    return 1

def scan_universe(self, 
                  symbols: List[str], 
                  data: Dict[str, pd.DataFrame]) -> List[TrendTemplateResult]:
    """
    Scan universe for stocks passing trend template.
    """
    results = []
    
    for symbol in symbols:
        df = data[symbol]
        if len(df) < 200:  # Need enough history
            continue
        
        result = self.check_trend_template(df)
        result.symbol = symbol
        
        if result.passes:
            results.append(result)
    
    # Sort by proximity to 52-week high (tighter = better)
    return sorted(results, key=lambda x: x.pct_from_52w_high, reverse=True)

VCP Pattern Detector

class VCPDetector: """ Volatility Contraction Pattern detection. The tighter the contractions, the more explosive the breakout. """

def __init__(self, 
             min_contractions: int = 2,
             max_first_contraction: float = 0.35,
             contraction_ratio: float = 0.6):
    self.min_contractions = min_contractions
    self.max_first_contraction = max_first_contraction
    self.contraction_ratio = contraction_ratio  # Each contraction should be this % of previous

def detect_vcp(self, df: pd.DataFrame) -> VCPResult:
    """
    Detect VCP pattern in price data.
    """
    close = df['close']
    high = df['high']
    low = df['low']
    volume = df['volume']
    
    # Find recent high (potential left side of base)
    lookback = 60  # ~3 months
    recent_high_idx = high.iloc[-lookback:].idxmax()
    recent_high = high.loc[recent_high_idx]
    
    # Find contractions from that high
    contractions = self.find_contractions(df, recent_high_idx)
    
    if len(contractions) < self.min_contractions:
        return VCPResult(valid=False, reason="Insufficient contractions")
    
    # Validate contraction depths are decreasing
    if not self.validate_contraction_depths(contractions):
        return VCPResult(valid=False, reason="Contractions not tightening")
    
    # Check volume pattern (should decrease during base)
    if not self.validate_volume_pattern(df, recent_high_idx):
        return VCPResult(valid=False, reason="Volume not contracting")
    
    # Calculate pivot point
    pivot = self.calculate_pivot(df, contractions)
    
    # Calculate tightness score (lower is better)
    tightness = contractions[-1]['depth']
    
    return VCPResult(
        valid=True,
        contractions=contractions,
        pivot_price=pivot,
        tightness_pct=tightness * 100,
        base_length_days=(df.index[-1] - df.index[recent_high_idx]).days,
        volume_dry_up=self.calculate_volume_dryup(df, recent_high_idx)
    )

def find_contractions(self, 
                      df: pd.DataFrame, 
                      start_idx) -> List[dict]:
    """
    Find swing high/low contractions from start point.
    """
    high = df['high']
    low = df['low']
    
    contractions = []
    current_high = high.loc[start_idx]
    
    # Walk forward finding contractions
    subset = df.loc[start_idx:]
    
    i = 0
    while i < len(subset) - 5:
        # Find next swing low
        window = subset.iloc[i:i+10]
        swing_low_idx = window['low'].idxmin()
        swing_low = window['low'].loc[swing_low_idx]
        
        # Find next swing high after that
        remaining = subset.loc[swing_low_idx:]
        if len(remaining) < 5:
            break
        
        next_window = remaining.iloc[:10]
        swing_high_idx = next_window['high'].idxmax()
        swing_high = next_window['high'].loc[swing_high_idx]
        
        depth = (current_high - swing_low) / current_high
        
        contractions.append({
            'high': current_high,
            'low': swing_low,
            'depth': depth,
            'high_date': start_idx if len(contractions) == 0 else swing_high_idx,
            'low_date': swing_low_idx
        })
        
        current_high = swing_high
        i = subset.index.get_loc(swing_high_idx) - subset.index.get_loc(subset.index[0])
        i += 1
    
    return contractions

def validate_contraction_depths(self, contractions: List[dict]) -> bool:
    """
    Each contraction should be shallower than the previous.
    """
    for i in range(1, len(contractions)):
        if contractions[i]['depth'] >= contractions[i-1]['depth'] * 1.1:  # Allow 10% tolerance
            return False
    return True

def validate_volume_pattern(self, df: pd.DataFrame, start_idx) -> bool:
    """
    Volume should decrease during the base formation.
    """
    volume = df['volume']
    subset = volume.loc[start_idx:]
    
    if len(subset) < 20:
        return False
    
    first_half_avg = subset.iloc[:len(subset)//2].mean()
    second_half_avg = subset.iloc[len(subset)//2:].mean()
    
    return second_half_avg < first_half_avg * 0.9  # Volume should be lower

def calculate_pivot(self, df: pd.DataFrame, contractions: List[dict]) -> float:
    """
    Pivot is the high of the last contraction.
    """
    if not contractions:
        return df['high'].iloc[-20:].max()
    
    return contractions[-1]['high']

def calculate_volume_dryup(self, df: pd.DataFrame, start_idx) -> float:
    """
    How much has volume dried up during the base?
    """
    volume = df['volume']
    avg_volume_before = volume.loc[:start_idx].iloc[-20:].mean()
    recent_volume = volume.iloc[-5:].mean()
    
    return (avg_volume_before - recent_volume) / avg_volume_before

Entry and Risk Management

class MinerviniTradeManager: """ Entry, position sizing, and risk management per Minervini rules. """

def __init__(self, 
             account_size: float,
             max_risk_per_trade: float = 0.01,  # 1%
             max_position_pct: float = 0.25):    # 25% max single position
    self.account = account_size
    self.risk_per_trade = max_risk_per_trade
    self.max_position = max_position_pct

def calculate_entry(self, 
                    vcp: VCPResult, 
                    current_price: float) -> EntryPlan:
    """
    Calculate entry point and buy zone.
    """
    pivot = vcp.pivot_price
    
    # Buy zone: pivot to 5% above pivot
    buy_zone_low = pivot
    buy_zone_high = pivot * 1.05
    
    # Is current price in buy zone?
    in_buy_zone = buy_zone_low <= current_price <= buy_zone_high
    
    # Extended if >5% above pivot
    extended = current_price > buy_zone_high
    
    return EntryPlan(
        pivot_price=pivot,
        buy_zone=(buy_zone_low, buy_zone_high),
        current_price=current_price,
        in_buy_zone=in_buy_zone,
        extended=extended,
        pct_above_pivot=(current_price - pivot) / pivot * 100
    )

def calculate_stop(self, 
                   entry_price: float, 
                   vcp: VCPResult,
                   max_stop_pct: float = 0.08) -> StopPlan:
    """
    Calculate stop loss based on chart structure.
    Minervini: max 7-8%, but tighter if structure allows.
    """
    # Option 1: Below the last contraction low
    structure_stop = vcp.contractions[-1]['low'] * 0.99  # 1% below
    structure_stop_pct = (entry_price - structure_stop) / entry_price
    
    # Option 2: Fixed percentage
    fixed_stop = entry_price * (1 - max_stop_pct)
    
    # Use tighter of the two
    if structure_stop_pct <= max_stop_pct:
        stop_price = structure_stop
        stop_type = 'STRUCTURE'
    else:
        stop_price = fixed_stop
        stop_type = 'FIXED_PCT'
    
    return StopPlan(
        stop_price=stop_price,
        stop_pct=(entry_price - stop_price) / entry_price * 100,
        stop_type=stop_type,
        structure_stop=structure_stop,
        fixed_stop=fixed_stop
    )

def calculate_position_size(self, 
                             entry_price: float, 
                             stop_price: float) -> PositionSize:
    """
    Position sizing based on risk.
    """
    risk_amount = self.account * self.risk_per_trade
    risk_per_share = entry_price - stop_price
    
    # Shares based on risk
    shares_by_risk = int(risk_amount / risk_per_share)
    
    # Max position check
    max_shares = int(self.account * self.max_position / entry_price)
    
    final_shares = min(shares_by_risk, max_shares)
    
    return PositionSize(
        shares=final_shares,
        position_value=final_shares * entry_price,
        position_pct=final_shares * entry_price / self.account * 100,
        risk_dollars=final_shares * risk_per_share,
        risk_pct=final_shares * risk_per_share / self.account * 100,
        limited_by='RISK' if shares_by_risk < max_shares else 'MAX_POSITION'
    )

def create_trade_plan(self, 
                      symbol: str,
                      df: pd.DataFrame,
                      vcp: VCPResult) -> TradePlan:
    """
    Complete trade plan with entry, stop, and targets.
    """
    current_price = df['close'].iloc[-1]
    
    entry = self.calculate_entry(vcp, current_price)
    stop = self.calculate_stop(entry.pivot_price, vcp)
    position = self.calculate_position_size(entry.pivot_price, stop.stop_price)
    
    # Profit targets
    risk = entry.pivot_price - stop.stop_price
    target_1 = entry.pivot_price + (risk * 2)   # 2:1
    target_2 = entry.pivot_price + (risk * 3)   # 3:1
    target_3 = entry.pivot_price * 1.20         # 20% move
    
    return TradePlan(
        symbol=symbol,
        entry=entry,
        stop=stop,
        position=position,
        targets={
            '2R': target_1,
            '3R': target_2,
            '20%': target_3
        },
        risk_reward_ratio=2.0,  # Minimum acceptable
        breakout_volume_required=df['volume'].rolling(50).mean().iloc[-1] * 1.5
    )

Sell Rules

class MinerviniSellRules: """ Minervini's selling discipline: protect gains, cut losses. """

def check_sell_signals(self, 
                       trade: ActiveTrade,
                       df: pd.DataFrame) -> List[SellSignal]:
    """
    Check all sell rules and return triggered signals.
    """
    signals = []
    current_price = df['close'].iloc[-1]
    
    # 1. STOP LOSS (mandatory)
    if current_price <= trade.stop_price:
        signals.append(SellSignal(
            type='STOP_LOSS',
            priority=1,
            action='SELL_ALL',
            reason=f'Price {current_price:.2f} hit stop {trade.stop_price:.2f}'
        ))
    
    # 2. Climax top (sell into strength)
    if self.detect_climax_top(df, trade):
        signals.append(SellSignal(
            type='CLIMAX_TOP',
            priority=2,
            action='SELL_HALF',
            reason='Climactic price/volume action'
        ))
    
    # 3. Break of 50-day MA after extended run
    if self.check_50ma_break(df, trade):
        signals.append(SellSignal(
            type='50MA_BREAK',
            priority=3,
            action='SELL_HALF',
            reason='Closed below 50-day MA after extended move'
        ))
    
    # 4. Lower low after lower high (trend change)
    if self.detect_lower_low(df):
        signals.append(SellSignal(
            type='TREND_CHANGE',
            priority=2,
            action='SELL_ALL',
            reason='Lower high followed by lower low'
        ))
    
    # 5. Holding period too long without progress
    if self.check_stalled_trade(trade, current_price):
        signals.append(SellSignal(
            type='TIME_STOP',
            priority=4,
            action='REVIEW',
            reason='Position stalled for 3+ weeks'
        ))
    
    return sorted(signals, key=lambda x: x.priority)

def detect_climax_top(self, df: pd.DataFrame, trade: ActiveTrade) -> bool:
    """
    Climax top: largest single-day gain on highest volume.
    Often signals exhaustion.
    """
    close = df['close']
    volume = df['volume']
    
    # Recent daily returns
    daily_return = close.pct_change().iloc[-1]
    avg_return = close.pct_change().iloc[-50:].mean()
    
    # Volume comparison
    current_volume = volume.iloc[-1]
    avg_volume = volume.rolling(50).mean().iloc[-1]
    
    # Climax: big up day (>2x average return) on huge volume (>2x average)
    is_climax = (daily_return > avg_return * 3) and (current_volume > avg_volume * 2)
    
    # Only matters if we're already up significantly
    current_gain = (close.iloc[-1] - trade.entry_price) / trade.entry_price
    
    return is_climax and current_gain > 0.20

def check_50ma_break(self, df: pd.DataFrame, trade: ActiveTrade) -> bool:
    """
    Close below 50 MA after being extended above it.
    """
    close = df['close']
    ma_50 = close.rolling(50).mean()
    
    current_price = close.iloc[-1]
    current_50ma = ma_50.iloc[-1]
    
    # Was extended above 50 MA?
    max_extension = ((close.iloc[-20:] - ma_50.iloc[-20:]) / ma_50.iloc[-20:]).max()
    
    return current_price < current_50ma and max_extension > 0.10

def detect_lower_low(self, df: pd.DataFrame) -> bool:
    """
    Lower high followed by lower low = potential trend change.
    """
    high = df['high']
    low = df['low']
    
    # Find recent swing points
    recent_high_1 = high.iloc[-20:-10].max()
    recent_high_2 = high.iloc[-10:].max()
    recent_low_1 = low.iloc[-20:-10].min()
    recent_low_2 = low.iloc[-10:].min()
    
    lower_high = recent_high_2 < recent_high_1
    lower_low = recent_low_2 < recent_low_1
    
    return lower_high and lower_low

def check_stalled_trade(self, 
                        trade: ActiveTrade, 
                        current_price: float,
                        max_stall_days: int = 15) -> bool:
    """
    Position going nowhere for too long.
    """
    days_held = (datetime.now() - trade.entry_date).days
    gain_pct = (current_price - trade.entry_price) / trade.entry_price
    
    # Stalled: held >15 days with <5% gain
    return days_held > max_stall_days and gain_pct < 0.05

Mental Model

Minervini approaches swing trading by asking:

• Is it Stage 2? If not, skip it entirely

• Is there a proper base? VCP or constructive pattern

• Where's the pivot? Specific entry point with defined risk

• What's my risk? Stop before entry, always

• Am I early or late? Only buy in the buy zone, never extended

The Trade Checklist

□ Stock passes ALL 8 trend template criteria □ VCP or proper base pattern identified □ Volume declining during base (supply dried up) □ Pivot point clearly defined □ Entry within 5% of pivot (not extended) □ Stop loss set (max 7-8%, tighter if possible) □ Position sized to 1% account risk □ Volume surge on breakout (50%+ above average) □ RS Rating > 80 (top performers) □ EPS growth positive and accelerating

Signature Minervini Moves

• Trend Template (8 criteria filter)

• Volatility Contraction Pattern (VCP)

• Stage 2 only (never Stage 1, 3, or 4)

• Buy at pivot, not before

• 7-8% maximum stop loss

• Sell into strength (climax tops)

• Position sizing by risk

• Volume confirmation on breakout