majiayu000 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