trading_bot_v4/ATR_BASED_TP_ROADMAP.md

ATR-Based Take Profit System - Roadmap

Current Status: 📋 PLANNING (Needs more data)

Date Added: November 12, 2025
Priority: Medium (after 50+ trades collected with ATR data)

Concept

Replace fixed percentage TP1/TP2 targets with ATR-based dynamic targets that adapt to market volatility.

Current System (Fixed %)

TP1: Entry + 0.4% (always)
TP2: Entry + 0.7% (always)
SL:  Entry - 1.0% (always)

Proposed System (ATR Multipliers)

TP1: Entry + (ATR × TP1_MULTIPLIER)
TP2: Entry + (ATR × TP2_MULTIPLIER)
SL:  Entry - (ATR × SL_MULTIPLIER)

Example with ATR = 0.26% at $160.62 entry:

• 1.5x ATR TP1: $161.25 (+0.39%) ← Close to current 0.4%!
• 2.5x ATR TP2: $161.66 (+0.65%) ← Close to current 0.7%!
• 2.0x ATR SL: $159.79 (-0.52%) ← Tighter than current -1.0%

Benefits

✅ Adapts to volatility automatically

• Calm market (ATR 0.15%): Tighter targets, faster profit locks
• Volatile market (ATR 0.50%): Wider targets, more room to run

✅ Data already available

• ATR saved in database (atrAtEntry field)
• TradingView signals include ATR value
• 159 historical trades to backtest against

✅ Aligns with existing systems

• Already using ATR for trailing stop calculation
• Consistent risk management approach
• Easy to add as config toggle

Implementation Plan

Phase 1: Data Collection (IN PROGRESS ✅)

Status: Currently collecting ATR data with every trade

• ✅ atrAtEntry field added to database (Nov 11)
• ✅ ATR-based trailing stop implemented (Nov 11)
• ✅ TradingView signals passing ATR value
• 🔄 Need 50+ trades with ATR data for meaningful backtest

Current progress: 1 trade with ATR tracking (need 49 more)

Phase 2: Backtest Analysis (NEXT - After 50+ trades)

Goal: Determine optimal ATR multipliers through historical data

Backtest queries to run:

-- Test different TP1 multipliers (1.0x, 1.5x, 2.0x, 2.5x)
WITH atr_tp1_simulation AS (
  SELECT 
    id,
    symbol,
    direction,
    entryPrice,
    "atrAtEntry",
    "maxFavorableExcursion" as mfe,
    realizedPnL,
    -- Simulate TP1 at different ATR multipliers
    (entryPrice * "atrAtEntry" / 100 * 1.0) as tp1_1x_distance,
    (entryPrice * "atrAtEntry" / 100 * 1.5) as tp1_15x_distance,
    (entryPrice * "atrAtEntry" / 100 * 2.0) as tp1_2x_distance,
    -- Check if MFE would have hit each TP1 level
    CASE WHEN "maxFavorableExcursion" >= ("atrAtEntry" * 1.0) THEN 1 ELSE 0 END as hit_1x,
    CASE WHEN "maxFavorableExcursion" >= ("atrAtEntry" * 1.5) THEN 1 ELSE 0 END as hit_15x,
    CASE WHEN "maxFavorableExcursion" >= ("atrAtEntry" * 2.0) THEN 1 ELSE 0 END as hit_2x
  FROM "Trade"
  WHERE "atrAtEntry" IS NOT NULL
    AND "exitReason" IS NOT NULL
)
SELECT 
  'TP1 at 1.0x ATR' as strategy,
  COUNT(*) as total_trades,
  SUM(hit_1x) as tp1_hits,
  ROUND(100.0 * SUM(hit_1x) / COUNT(*), 1) as hit_rate,
  ROUND(AVG("atrAtEntry" * 1.0), 2) as avg_target_pct
FROM atr_tp1_simulation
UNION ALL
SELECT 
  'TP1 at 1.5x ATR' as strategy,
  COUNT(*) as total_trades,
  SUM(hit_15x) as tp1_hits,
  ROUND(100.0 * SUM(hit_15x) / COUNT(*), 1) as hit_rate,
  ROUND(AVG("atrAtEntry" * 1.5), 2) as avg_target_pct
FROM atr_tp1_simulation
UNION ALL
SELECT 
  'TP1 at 2.0x ATR' as strategy,
  COUNT(*) as total_trades,
  SUM(hit_2x) as tp1_hits,
  ROUND(100.0 * SUM(hit_2x) / COUNT(*), 1) as hit_rate,
  ROUND(AVG("atrAtEntry" * 2.0), 2) as avg_target_pct
FROM atr_tp1_simulation;

Metrics to compare:

• TP1 hit rate (target 80%+)
• Average profit per TP1 hit
• Comparison vs current fixed 0.4% system
• Win rate impact
• Total P&L impact

Phase 3: Configuration Implementation

Add new ENV variables:

# ATR-based targets (optional, defaults to fixed %)
USE_ATR_BASED_TARGETS=false  # Toggle feature
TP1_ATR_MULTIPLIER=1.5       # TP1 = entry + (ATR × 1.5)
TP2_ATR_MULTIPLIER=2.5       # TP2 = entry + (ATR × 2.5)
SL_ATR_MULTIPLIER=2.0        # SL = entry - (ATR × 2.0)

Update trading config:

// config/trading.ts
export const DEFAULT_TRADING_CONFIG = {
  // ... existing config
  
  // ATR-based targets (optional override for fixed %)
  useAtrBasedTargets: false,
  tp1AtrMultiplier: 1.5,
  tp2AtrMultiplier: 2.5,
  slAtrMultiplier: 2.0,
}

Update execute endpoint:

// app/api/trading/execute/route.ts
if (config.useAtrBasedTargets && body.atr) {
  const atrValue = body.atr / 100 // Convert % to decimal
  const atrInDollars = entryPrice * atrValue
  
  tp1Price = entryPrice + (atrInDollars * config.tp1AtrMultiplier)
  tp2Price = entryPrice + (atrInDollars * config.tp2AtrMultiplier)
  stopLossPrice = entryPrice - (atrInDollars * config.slAtrMultiplier)
  
  console.log(`📊 ATR-based targets (ATR=${body.atr}%):`)
  console.log(`   TP1: $${tp1Price.toFixed(4)} (${config.tp1AtrMultiplier}x ATR)`)
  console.log(`   TP2: $${tp2Price.toFixed(4)} (${config.tp2AtrMultiplier}x ATR)`)
  console.log(`   SL:  $${stopLossPrice.toFixed(4)} (${config.slAtrMultiplier}x ATR)`)
} else {
  // Fallback to fixed % (current system)
  tp1Price = calculatePrice(entryPrice, config.takeProfit1Percent, body.direction)
  // ... existing logic
}

Phase 4: A/B Testing (After backtest shows promise)

Run parallel comparison for 20-30 trades:

• 50% trades: Fixed % targets (control group)
• 50% trades: ATR-based targets (test group)
• Compare: Win rate, profit factor, avg P&L

Phase 5: Full Deployment

If A/B test shows improvement:

• Enable by default for all new trades
• Keep fixed % as fallback when ATR unavailable
• Document in copilot-instructions.md

Expected Multipliers (Based on initial analysis)

Conservative (High win rate focus):

TP1: 1.0-1.5x ATR
TP2: 2.0-2.5x ATR
SL:  2.0-3.0x ATR

Balanced (Current ~equivalent):

TP1: 1.5-2.0x ATR
TP2: 2.5-3.5x ATR
SL:  2.5-3.5x ATR

Aggressive (Larger winners):

TP1: 2.0-3.0x ATR
TP2: 3.5-5.0x ATR
SL:  3.0-4.0x ATR

Risks & Considerations

⚠️ Potential issues:

1. Very low ATR (<0.15%) might create targets too tight
2. Very high ATR (>0.8%) might create targets unreachable
3. Need min/max clamping to prevent extreme values
4. ATR from TradingView must be fresh (<5min old)

Mitigation:

// Clamp ATR to reasonable range
const clampedAtr = Math.max(0.15, Math.min(0.8, body.atr))

// Or use hybrid: max of fixed % or ATR-based
const tp1Price = Math.max(
  calculatePrice(entryPrice, 0.4, direction),  // Fixed minimum
  entryPrice + (atrInDollars * config.tp1AtrMultiplier)  // ATR-based
)

Dependencies

✅ Already implemented:

• ATR data collection from TradingView
• atrAtEntry field in database
• ATR-based trailing stop logic

⏳ Need before implementation:

• 50+ trades with ATR data (currently 1/50)
• Backtest analysis results
• Optimal multiplier determination

Success Metrics

System is successful if ATR-based approach shows:

• ✅ TP1 hit rate ≥ 75% (vs current ~70%)
• ✅ Win rate maintained or improved (target 60%+)
• ✅ Profit factor > 1.5 (vs current varies)
• ✅ Better performance in volatile vs calm markets
• ✅ Total P&L improvement of 10%+

Timeline Estimate

Phase 1 (Data Collection): 2-4 weeks

• Depends on signal frequency (3-5 trades/day = 10-17 days)
• Need indicator v6 deployed to production

Phase 2 (Backtest): 1-2 days

• Run SQL analysis
• Generate comparison reports
• Determine optimal multipliers

Phase 3 (Implementation): 2-3 hours

• Add config options
• Update execute endpoint
• Add settings UI controls

Phase 4 (A/B Testing): 2-3 weeks

• Run parallel comparison
• Statistical significance testing

Total: ~6-8 weeks from today

Notes

• This complements existing ATR-based trailing stop (already working well)
• Creates unified risk management: entry, TP, SL, and trailing all based on ATR
• Could be symbol-specific (SOL might need different multipliers than ETH)
• Aligns with Phase 1 goals (prove system works with data-driven decisions)

References

• ATR Trailing Stop Implementation: ATR_TRAILING_STOP_FIX.md
• Trade Database Schema: prisma/schema.prisma (line 74: atrAtEntry Float?)
• Position Scaling Roadmap: POSITION_SCALING_ROADMAP.md (similar data-driven approach)
• Current Execute Logic: app/api/trading/execute/route.ts (lines 280-310)

---

Status: Documented and ready for Phase 2 when sufficient data collected. Next Action: Wait for 50+ trades with ATR data, then run backtest analysis.