--- title: "Umar Ashraf Strategy: Power of Three System Guide" slug: umar-ashraf-strategy-power-of-three-pickmytrade date: 2026-04-10 modified: 2026-04-17 author: Bhavishya Goyal excerpt: "" meta_description: "Umar Ashraf’s Power of Three system: 5 entry models, VWAP reclaim, order flow approximation, and +29.14% TSLA backtest. Full settings and automation guide." focus_keyword: Umar Ashraf Strategy canonical_url: "https://blog.pickmytrade.trade/umar-ashraf-strategy-power-of-three-pickmytrade/" og_title: "Umar Ashraf Strategy: Power of Three System Guide" og_description: "Umar Ashraf’s Power of Three system: 5 entry models, VWAP reclaim, order flow approximation, and +29.14% TSLA backtest. Full settings and automation guide." og_image: "https://blog.pickmytrade.trade/wp-content/uploads/2026/04/featured-umar-ashraf-strategy-1024x538.avif" schema_type: FAQPage categories: - AI and Machine Learning - AUTOMATED TRADINGVIEW STRATEGIES - Trading tags: - PickMyTrade - Trading Strategies - TradingView reading_time: 35 word_count: 8213 robots: "index, follow" lang: en-US --- # Umar Ashraf Strategy: Power of Three System Guide A multi-model intraday momentum system built on Power of Three (PO3), VWAP dynamics, and order flow approximation, fully automated on TradingView with PickMyTrade. Table of Contents 1. [What Is Power of Three (PO3) in Umar Ashraf’s Trading System?](https://blog.pickmytrade.trade/#what-is-power-of-three-po3-in-umar-ashrafs-trading-system) 2. [Umar Asharaf Strategy Source code](https://blog.pickmytrade.trade/#umar-asharaf-strategy-source-code) 3. [How Do the Five Trading Models Generate Entry Signals?](https://blog.pickmytrade.trade/#how-do-the-five-trading-models-generate-entry-signals) 4. [M1 — Power of Three (PO3) Sweep & Rejection](https://blog.pickmytrade.trade/#m1-power-of-three-po3-sweep-rejection) 5. [M2 — VWAP Reclaim with Displacement](https://blog.pickmytrade.trade/#m2-vwap-reclaim-with-displacement) 6. [M3 — VWAP Scalp (DISABLED)](https://blog.pickmytrade.trade/#m3-vwap-scalp-disabled) 7. [M4 — Absorption Reversal (Order Flow Model)](https://blog.pickmytrade.trade/#m4-absorption-reversal-order-flow-model) 8. [M5 — EMA 21 Pullback (Trend Continuation)](https://blog.pickmytrade.trade/#m5-ema-21-pullback-trend-continuation) 9. [How Does the Order Flow Engine Approximate Footprint Data?](https://blog.pickmytrade.trade/#how-does-the-order-flow-engine-approximate-footprint-data) 10. [What Do the Backtest Results Show on TSLA 5-Minute Charts?](https://blog.pickmytrade.trade/#what-do-the-backtest-results-show-on-tsla-5-minute-charts) 11. [Which Settings Are Optimized for TSLA 5-Minute Charts?](https://blog.pickmytrade.trade/#which-settings-are-optimized-for-tsla-5-minute-charts) 12. [How Does the Risk Framework Limit Drawdown?](https://blog.pickmytrade.trade/#how-does-the-risk-framework-limit-drawdown) 13. [Structural Stop Loss](https://blog.pickmytrade.trade/#structural-stop-loss) 14. [Partial TP at 1R](https://blog.pickmytrade.trade/#partial-tp-at-1r) 15. [Daily Limits & Cooldown](https://blog.pickmytrade.trade/#daily-limits-cooldown) 16. [EOD Flat Close](https://blog.pickmytrade.trade/#eod-flat-close) 17. [Which Entry Filters Block Choppy and Counter-Trend Conditions?](https://blog.pickmytrade.trade/#which-entry-filters-block-choppy-and-counter-trend-conditions) 18. [Which Markets Work Best with This Strategy?](https://blog.pickmytrade.trade/#which-markets-work-best-with-this-strategy) 19. [Stocks (TSLA, NVDA, AAPL)](https://blog.pickmytrade.trade/#stocks-tsla-nvda-aapl) 20. [Futures (NQ, ES, Gold, Silver)](https://blog.pickmytrade.trade/#futures-nq-es-gold-silver) 21. [Forex](https://blog.pickmytrade.trade/#forex) 22. [Crypto (BTC, ETH)](https://blog.pickmytrade.trade/#crypto-btc-eth) 23. [How Do You Automate This Strategy with PickMyTrade?](https://blog.pickmytrade.trade/#how-do-you-automate-this-strategy-with-pickmytrade) 24. [Three-Step Setup](https://blog.pickmytrade.trade/#three-step-setup) 25. [Alert JSON Payload (Strategy Alert — Order Fills Only)](https://blog.pickmytrade.trade/#alert-json-payload-strategy-alert-order-fills-only) 26. [Frequently Asked Questions](https://blog.pickmytrade.trade/#frequently-asked-questions) 27. [What is the Umar Ashraf Strategy based on?](https://blog.pickmytrade.trade/#what-is-the-umar-ashraf-strategy-based-on) 28. [Can I use this on markets other than TSLA?](https://blog.pickmytrade.trade/#can-i-use-this-on-markets-other-than-tsla) 29. [Why is the Sharpe Ratio only 0.54 if the net profit is strong?](https://blog.pickmytrade.trade/#why-is-the-sharpe-ratio-only-0-54-if-the-net-profit-is-strong) 30. [Does this strategy access real order flow or footprint data?](https://blog.pickmytrade.trade/#does-this-strategy-access-real-order-flow-or-footprint-data) 31. [What does “partial TP at 1R” mean in practice?](https://blog.pickmytrade.trade/#what-does-partial-tp-at-1r-mean-in-practice) 32. [How do I automate this strategy for live trading?](https://blog.pickmytrade.trade/#how-do-i-automate-this-strategy-for-live-trading) 33. [Start Trading the Umar Ashraf Strategy](https://blog.pickmytrade.trade/#start-trading-the-umar-ashraf-strategy) Umar Ashraf Strategy brings one of the most-followed intraday trading methodologies to TradingView as a fully automated Pine Script v6 strategy. Inspired by Umar Ashraf’s Power of Three (PO3) framework, it combines liquidity sweep detection, VWAP reclaim setups, and an order flow approximation engine to identify high-probability momentum entries during the US morning session. Backtested on TSLA 5-minute charts from March 2025 through April 2026, the strategy delivered +$29,138 net profit (+29.14%) on a $100,000 base, outperforming buy & hold by over $7,000 with a controlled 12.46% max drawdown. This post breaks down every component: the five trading models, the order flow engine, the risk management rules, and exactly how to automate it with PickMyTrade. > **Key Takeaways** > > • Fewer than 1% of retail day traders profit net of fees (Barber et al., _Journal of Financial Markets_, 2014): this system’s structural stops and 5% daily circuit breaker are built to put you in that 1%. > > • The TSLA backtest returned +29.14% vs. +22.09% buy-and-hold over 13 months, with a 60.09% win rate across 213 trades. > > • M3 (VWAP Scalp) is intentionally disabled; the system only runs models that have passed out-of-sample validation. > > • PickMyTrade automates execution via a single Strategy alert, eliminating manual entry and slippage on fast-moving setups. ## What Is Power of Three (PO3) in Umar Ashraf’s Trading System? {#what-is-power-of-three-po3-in-umar-ashrafs-trading-system} Power of Three explains why key price levels fail as support and resistance: institutional participants deliberately sweep retail stop-loss clusters before reversing, collecting liquidity from trapped positions. The Umar Ashraf interpretation enters _after_ the sweep, not before it. > A 2020 study tracked every person who attempted day trading in Brazil over 14 years: 97% of those who persisted for more than 300 days lost money, and only 0.5% earned more than the salary of a bank teller. The Power of Three framework is built on the mechanism that produces this result: institutional liquidity sweeps that trigger retail stops before the real move begins (Chague, De-Losso & Giovannetti, [SSRN #3423101](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3423101), 2020). ## Umar Asharaf Strategy Source code {#umar-asharaf-strategy-source-code} ``` // This Pine Script(TM) source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/ // (c) PickMyTrade // Umar Ashraf Strategy [PickMyTrade] // Power of Three (PO3) | VWAP Reclaim / Pullback | Liquidity Sweep + Structural Levels // + Order Flow Approximation (Volume Delta, CVD, Absorption, Delta Divergence) // Designed for day traders | 5min optimized | US Morning Session 9:30-11:30 ET //@version=6 strategy("Umar Ashraf Strategy [PickMyTrade]", shorttitle="UA [PMT]", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=2, initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1, slippage=2, calc_on_every_tick=false, process_orders_on_close=false, max_bars_back=1500, pyramiding=0, margin_long=3, margin_short=3) // ══════════════════════════════════════════════════════════════ // DATE RANGE // ══════════════════════════════════════════════════════════════ use_date_filter = input.bool(false, title="Enable Date Range", group="Date Range") start_date = input.time(timestamp("2020-01-01"), title="Start Date", group="Date Range") end_date = input.time(timestamp("2099-12-31"), title="End Date", group="Date Range") in_range = not use_date_filter or (time >= start_date and time 2.5x average) // ══════════════════════════════════════════════════════════════ use_orderflow = input.bool(true, title="Enable Order Flow Layer", group="Order Flow") of_delta_confirm = input.bool(true, title="Delta Confirmation on Entries", group="Order Flow") of_absorption = input.bool(true, title="Absorption Detection at Levels", group="Order Flow") of_delta_div = input.bool(true, title="Delta Divergence Filter", group="Order Flow") of_block_detect = input.bool(true, title="Block Trade Detection", group="Order Flow") of_imb_thresh = input.float(0.6, title="Imbalance Threshold (0.5-0.9)", step=0.05, minval=0.5, maxval=0.9, group="Order Flow") of_block_mult = input.float(2.5, title="Block Volume Multiplier", step=0.5, minval=1.5, group="Order Flow") of_absorption_body = input.float(0.2, title="Absorption Max Body (ATR x)", step=0.05, group="Order Flow") of_absorption_vol = input.float(2.0, title="Absorption Min Volume (x avg)", step=0.5, group="Order Flow") of_cvd_len = input.int(5, title="CVD Divergence Lookback", minval=3, maxval=20, group="Order Flow") // ══════════════════════════════════════════════════════════════ // RISK // ══════════════════════════════════════════════════════════════ atr_len = input.int(14, title="ATR Length", minval=1, group="Risk") sl_method = input.string("Structural", title="Stop Loss Method", options=["Structural", "ATR-Based"], group="Risk") sl_atr_fallback = input.float(2.0, title="ATR SL Fallback (if Structural)", step=0.1, group="Risk") rr_target = input.float(2.0, title="R:R Target Minimum", step=0.5, group="Risk") use_midpoint_tp = input.bool(false, title="Use 50% Midpoint as TP (PO3)", group="Risk") use_breakeven = input.bool(true, title="Move SL to Breakeven at 1R", group="Risk") use_partial_tp = input.bool(true, title="Partial TP at 1R (50% off, run rest to 2R)", group="Risk") daily_max_loss_pct = input.float(5.0, title="Daily Max Loss %", step=0.5, group="Risk") // ══════════════════════════════════════════════════════════════ // POSITION SIZING // ══════════════════════════════════════════════════════════════ use_fixed_qty = input.bool(false, title="Fixed Qty (for Futures)", group="Position") fixed_qty = input.int(1, title="Fixed Contracts", minval=1, group="Position") dir_input = input.string("Both", title="Direction", options=["Long Only", "Short Only", "Both"], group="Position") allow_long = dir_input != "Short Only" allow_short = dir_input != "Long Only" // ══════════════════════════════════════════════════════════════ // SESSION -- ENTRY window vs EXIT window (separated) // Umar ENTERS during 9:30-11:30 AM but lets trades run to TP/SL // EOD flat close at 16:00 (market close) only if trade still open // ══════════════════════════════════════════════════════════════ use_session = input.bool(true, title="Session Filter (ET)", group="Session") auto_session = input.bool(true, title="Auto-Detect Asset Session", group="Session") sess_start_h = input.int(9, title="Entry Window Start Hour", minval=0, maxval=23, group="Session") sess_start_m = input.int(30, title="Entry Window Start Min", minval=0, maxval=59, group="Session") sess_end_h = input.int(13, title="Entry Window End Hour", minval=0, maxval=23, group="Session") sess_end_m = input.int(0, title="Entry Window End Min", minval=0, maxval=59, group="Session") eod_close_h = input.int(15, title="EOD Flat Close Hour (ET)", minval=0, maxval=23, group="Session") eod_close_m = input.int(55, title="EOD Flat Close Min (ET)", minval=0, maxval=59, group="Session") max_daily = input.int(3, title="Max Trades/Day", minval=1, group="Session") cooldown = input.int(5, title="Cooldown Bars", minval=0, group="Session") // ══════════════════════════════════════════════════════════════ // CORE INDICATORS // ══════════════════════════════════════════════════════════════ atr = ta.atr(atr_len) vwap_val = ta.vwap(hlc3) vol_sma_of = ta.sma(volume, 20) // ADX trend strength filter (required: only trade when market is trending) [diplus, diminus, adx_val] = ta.dmi(adx_len, adx_len) adx_ok = adx_val > adx_thresh // EMA Trend Stack -- intraday momentum alignment (no extra security call) // Long only when fast EMA > slow EMA and price above fast EMA // Short only when fast EMA ema_slow and close > ema_fast ema_bear_stack = ema_fast < ema_slow and close ema_50 // only go long above EMA50 lt_short_ok = close htf_prev_high or htf_low > htf_prev_low bias_bear = htf_low < htf_prev_low or htf_high 0 ? ((close - low) - (high - close)) / bar_range : 0.0 bar_delta = volume * clv buy_volume = volume * (clv + 1) / 2 sell_volume = volume * (1 - clv) / 2 buy_pct = volume > 0 ? buy_volume / volume : 0.5 // --- 2. CVD (Cumulative Volume Delta) --- // Running sum of bar delta -- rising CVD = net buying pressure var float cvd = 0.0 cvd := cvd + bar_delta // CVD EMA for trend/divergence detection cvd_fast = ta.ema(cvd, 5) cvd_slow = ta.ema(cvd, 20) // --- 3. DELTA CONFIRMATION --- // For long entries: delta should be positive (buying pressure) // For short entries: delta should be negative (selling pressure) delta_confirms_long = not use_orderflow or not of_delta_confirm or bar_delta > 0 delta_confirms_short = not use_orderflow or not of_delta_confirm or bar_delta of_imb_thresh vol_imbalance_bear = (1 - buy_pct) > of_imb_thresh // --- 5. ABSORPTION DETECTION --- // Large volume + tiny body + long wicks = big orders absorbing pressure // Bullish absorption: at support (long lower wick, small body, high volume) // Bearish absorption: at resistance (long upper wick, small body, high volume) body_val = math.abs(close - open) is_high_vol = volume > vol_sma_of * of_absorption_vol tiny_body = body_val body_val * 2 and close >= open // Bearish absorption: long upper wick absorbing buying at resistance absorb_bear = use_orderflow and of_absorption and is_high_vol and tiny_body and upper_wick_val > body_val * 2 and close <= open // Absorption at key levels (within 0.3 ATR of a level) near_pdl_pml = math.abs(low - pdl) < atr * 0.3 or math.abs(low - pml) < atr * 0.3 near_pdh_pmh = math.abs(high - pdh) < atr * 0.3 or math.abs(high - pmh) < atr * 0.3 near_vwap_abs = math.abs(close - vwap_val) = price_high_5 price_new_low = low <= price_low_5 cvd_no_new_high = cvd cvd_low_5 * 1.02 // Bearish delta div: price new high but CVD exhausted (buying drying up) delta_div_bear = use_orderflow and of_delta_div and price_new_high and cvd_no_new_high // Bullish delta div: price new low but CVD not confirming (selling drying up) delta_div_bull = use_orderflow and of_delta_div and price_new_low and cvd_no_new_low // --- 7. BLOCK TRADE DETECTION --- // Unusually large volume bar = institutional / block order is_block = use_orderflow and of_block_detect and volume > vol_sma_of * of_block_mult block_bull = is_block and close > open block_bear = is_block and close < open // ══════════════════════════════════════════════════════════════ // SMT DIVERGENCE (1 tuple call -- Essential plan optimized) // ══════════════════════════════════════════════════════════════ [smt_ref_high, smt_ref_low] = request.security(smt_ref_ticker, timeframe.period, [high, low], barmerge.gaps_off, barmerge.lookahead_on) local_new_low = low ta.lowest(smt_ref_low, 5)[1] smt_bull = use_smt and local_new_low and ref_no_new_low local_new_high = high > ta.highest(high, 5)[1] ref_no_new_high = smt_ref_high < ta.highest(smt_ref_high, 5)[1] smt_bear = use_smt and local_new_high and ref_no_new_high // ══════════════════════════════════════════════════════════════ // LIQUIDITY SWEEP DETECTION // ══════════════════════════════════════════════════════════════ sweep_margin = close * sweep_margin_pct / 100 swept_pdl = ta.barssince(low < pdl - sweep_margin) pdl and close > open swept_pdh = ta.barssince(high > pdh + sweep_margin) <= sweep_lookback reject_pdh = swept_pdh and close < pdh and close < open swept_pml = ta.barssince(low < pml - sweep_margin) pml and close > open swept_pmh = ta.barssince(high > pmh + sweep_margin) <= sweep_lookback reject_pmh = swept_pmh and close < pmh and close = 585 was_below_vwap = ta.barssince(close < vwap_val) vwap_val and close > open was_above_vwap = ta.barssince(close > vwap_val) <= vwap_reclaim_bars vwap_reclaim_short = was_above_vwap and close < vwap_val and close < open near_vwap = math.abs(close - vwap_val) < atr * 0.3 vol_declining = volume < volume[1] and volume[1] open and close > vwap_val and low <= vwap_val * 1.002 vwap_pullback_short = near_vwap and vol_declining and close < open and close = vwap_val * 0.998 // ══════════════════════════════════════════════════════════════ // CANDLE QUALITY // ══════════════════════════════════════════════════════════════ body = math.abs(close - open) strong_bull = close > open and body > atr * min_body_atr strong_bear = close atr * min_body_atr upper_wick = high - math.max(close, open) lower_wick = math.min(close, open) - low displacement_bull = strong_bull and upper_wick < body * 0.5 and lower_wick < body * 0.7 displacement_bear = strong_bear and lower_wick < body * 0.5 and upper_wick vol_sma * vol_mult // Strong volume: required for M2 (VWAP reclaim must have institutional participation) vol_strong = (is_futures or is_forex) ? volume > vol_sma_of * 1.2 : volume > vol_sma * 1.5 // ══════════════════════════════════════════════════════════════ // SESSION -- Entry window for new trades, EOD close for open positions // Entries: 9:30-11:30 ET | Exits: TP/SL anytime | EOD flat: 15:55 ET // ══════════════════════════════════════════════════════════════ auto_start_mins = is_crypto ? 0 : is_forex ? 480 : 570 // 9:30 ET auto_end_mins = is_crypto ? 1440 : is_forex ? 780 : 780 // 13:00 ET auto_eod_mins = is_crypto ? 1440 : is_forex ? 960 : 955 // 15:55 ET manual_start_mins = sess_start_h * 60 + sess_start_m manual_end_mins = sess_end_h * 60 + sess_end_m manual_eod_mins = eod_close_h * 60 + eod_close_m eff_start = auto_session ? auto_start_mins : manual_start_mins eff_end = auto_session ? auto_end_mins : manual_end_mins eff_eod = auto_session ? auto_eod_mins : manual_eod_mins eff_use_session = is_crypto and auto_session ? false : use_session // Entry window: only allow NEW entries during morning session in_entry_window = not eff_use_session or (et_time_mins >= eff_start and et_time_mins = eff_eod new_day = ta.change(time("D")) != 0 var int trades_today = 0 var float daily_pnl = 0.0 if new_day trades_today := 0 daily_pnl := 0.0 under_limit = trades_today -(strategy.equity * daily_max_loss_pct / 100) var int bars_since = 999 bars_since := strategy.position_size != strategy.position_size[1] ? 0 : bars_since + 1 can_enter = bars_since >= cooldown // ══════════════════════════════════════════════════════════════ // ENTRY MODELS (PO3 Framework + Order Flow Confirmation) // // M1: PO3 Sweep + Rejection // + Order Flow: delta must confirm direction // + Bonus: absorption at swept level or delta divergence = higher conviction // + TP: 50% midpoint // // M2: VWAP Reclaim with Displacement // + Order Flow: delta confirms + volume imbalance preferred // + Not before 9:45 AM // // M3: VWAP Pullback Scalp // + Order Flow: absorption at VWAP is the ideal setup // + Not before 9:45 AM // // M4: Absorption Reversal (NEW -- pure order flow model) // Absorption candle at key level + delta divergence + bias alignment // This is the closest PineScript can get to Umar's footprint reads // ══════════════════════════════════════════════════════════════ // M1: PO3 GOTCHA Sweep + Rejection // Highest conviction: sweep flushes weak hands, EMA must already be aligned with trade direction // Allows neutral HTF bias because sweep itself IS the directional signal m1_long = any_sweep_bull and (bias_bull or bias_neutral) and close > vwap_val and strong_bull and delta_confirms_long and adx_ok and ema_bull_stack and vol_ok and lt_long_ok m1_short = any_sweep_bear and (bias_bear or bias_neutral) and close vwap_val and adx_ok and ema_bull_stack and vol_strong and lt_long_ok m4_short = use_orderflow and absorb_at_resistance and delta_div_bear and bias_bear and close < vwap_val and adx_ok and ema_bear_stack and vol_strong and lt_short_ok // M5: EMA 21 Pullback (Trend Continuation) // Catches entries on trending assets (NQ, Gold, BTC) where price rarely sweeps key levels // Price dips to touch EMA21 in an uptrend then closes bullish = continuation entry // Fires reliably during strong trending phases that M1/M2 miss near_ema21_bull = low ema_slow and close > open near_ema21_bear = high >= ema_slow * 0.998 and close < ema_slow and close close ? mid_level : close + risk_long * rr_target tp_short = use_midpoint_tp and is_m1_short and mid_level < close ? mid_level : close - risk_short * rr_target // Partial TP1 at 1R (50% of position exits here, rest runs to full TP) tp1_long = close + risk_long tp1_short = close - risk_short // R:R validation -- skip trades where reward = 2.0 rr_valid_short = actual_rr_short >= 2.0 // ══════════════════════════════════════════════════════════════ // POSITION SIZING // ══════════════════════════════════════════════════════════════ auto_fixed = use_fixed_qty or is_futures entry_qty = auto_fixed ? fixed_qty : na // ══════════════════════════════════════════════════════════════ // EXECUTION // ══════════════════════════════════════════════════════════════ if long_sig and rr_valid_long strategy.entry("Long", strategy.long, qty=entry_qty) if use_partial_tp strategy.exit("Long TP1", "Long", qty_percent=50, limit=tp1_long, comment="TP1 50%") strategy.exit("Long X", "Long", stop=sl_long, limit=tp_long) trades_today += 1 if short_sig and rr_valid_short strategy.entry("Short", strategy.short, qty=entry_qty) if use_partial_tp strategy.exit("Short TP1", "Short", qty_percent=50, limit=tp1_short, comment="TP1 50%") strategy.exit("Short X", "Short", stop=sl_short, limit=tp_short) trades_today += 1 // ══════════════════════════════════════════════════════════════ // MOVE TO BREAKEVEN at 1R profit // ══════════════════════════════════════════════════════════════ if use_breakeven and strategy.position_size > 0 entry_price = strategy.position_avg_price be_risk = entry_price - sl_long if be_risk > 0 and high >= entry_price + be_risk strategy.exit("Long X", "Long", stop=entry_price, limit=tp_long) if use_breakeven and strategy.position_size 0 and low 0 daily_pnl := strategy.netprofit // ══════════════════════════════════════════════════════════════ // VISUALS // ══════════════════════════════════════════════════════════════ plot(vwap_val, "VWAP", color=#AB47BC, linewidth=2) plot(ema_fast, "EMA 9", color=color.new(#FF9800, 20), linewidth=1) plot(ema_slow, "EMA 21", color=color.new(#F44336, 20), linewidth=1) plot(ema_50, "EMA 50", color=color.new(#2196F3, 30), linewidth=1) plot(ema_200, "EMA 200", color=color.new(#9C27B0, 20), linewidth=2) plot(pdh_pdl_show ? pdh : na, "PDH", color=color.new(#EF5350, 30), style=plot.style_stepline, linewidth=1) plot(pdh_pdl_show ? pdl : na, "PDL", color=color.new(#26A69A, 30), style=plot.style_stepline, linewidth=1) plot(pmh_pml_show ? pmh : na, "PMH", color=color.new(#FF9800, 40), style=plot.style_stepline, linewidth=1) plot(pmh_pml_show ? pml : na, "PML", color=color.new(#FF9800, 40), style=plot.style_stepline, linewidth=1) plot(mid_show ? mid_level : na, "50% Mid (TP)", color=color.new(#FFD600, 40), style=plot.style_cross, linewidth=1) // Entry signals plotshape(m1_long and long_sig, "PO3 Long", location=location.belowbar, color=#00E676, style=shape.triangleup, size=size.small, text="PO3") plotshape(m2_long and long_sig, "VR Long", location=location.belowbar, color=#2196F3, style=shape.labelup, size=size.tiny, text="VR") plotshape(m3_long and long_sig, "VP Long", location=location.belowbar, color=#AB47BC, style=shape.triangleup, size=size.tiny, text="VP") plotshape(m4_long and long_sig, "ABS Long", location=location.belowbar, color=#00BCD4, style=shape.labelup, size=size.tiny, text="ABS") plotshape(m5_long and long_sig, "EP Long", location=location.belowbar, color=#8BC34A, style=shape.triangleup, size=size.tiny, text="EP") plotshape(m1_short and short_sig, "PO3 Short", location=location.abovebar, color=#FF1744, style=shape.triangledown, size=size.small, text="PO3") plotshape(m2_short and short_sig, "VR Short", location=location.abovebar, color=#E040FB, style=shape.labeldown, size=size.tiny, text="VR") plotshape(m3_short and short_sig, "VP Short", location=location.abovebar, color=#AB47BC, style=shape.triangledown, size=size.tiny, text="VP") plotshape(m4_short and short_sig, "ABS Short", location=location.abovebar, color=#00BCD4, style=shape.labeldown, size=size.tiny, text="ABS") plotshape(m5_short and short_sig, "EP Short", location=location.abovebar, color=#FF6F00, style=shape.triangledown, size=size.tiny, text="EP") // Order flow visual markers (non-entry signals for awareness) plotshape(absorb_at_support and not long_sig, "Absorption Support", location=location.belowbar, color=color.new(#00BCD4, 50), style=shape.diamond, size=size.tiny) plotshape(absorb_at_resistance and not short_sig, "Absorption Resistance", location=location.abovebar, color=color.new(#FF5722, 50), style=shape.diamond, size=size.tiny) plotshape(block_bull and not long_sig, "Block Buy", location=location.belowbar, color=color.new(#4CAF50, 60), style=shape.square, size=size.tiny) plotshape(block_bear and not short_sig, "Block Sell", location=location.abovebar, color=color.new(#F44336, 60), style=shape.square, size=size.tiny) plotshape(delta_div_bull and not long_sig, "Delta Div Bull", location=location.belowbar, color=color.new(#FFD600, 50), style=shape.cross, size=size.tiny) plotshape(delta_div_bear and not short_sig, "Delta Div Bear", location=location.abovebar, color=color.new(#FFD600, 50), style=shape.cross, size=size.tiny) bgcolor(in_entry_window ? color.new(#26A69A, 97) : color.new(#EF5350, 99)) bgcolor(bias_bull ? color.new(#4CAF50, 96) : bias_bear ? color.new(#F44336, 96) : na) // ══════════════════════════════════════════════════════════════ // ALERTS // ══════════════════════════════════════════════════════════════ alertcondition(long_sig, title="UA Long Entry", message="UA [PMT] LONG -- {{ticker}} {{interval}}") alertcondition(short_sig, title="UA Short Entry", message="UA [PMT] SHORT -- {{ticker}} {{interval}}") alertcondition(absorb_at_support, title="Absorption at Support", message="UA [PMT] Absorption at support -- {{ticker}}") alertcondition(absorb_at_resistance, title="Absorption at Resistance", message="UA [PMT] Absorption at resistance -- {{ticker}}") alertcondition(delta_div_bull, title="Bullish Delta Divergence", message="UA [PMT] Delta divergence bullish -- {{ticker}}") alertcondition(delta_div_bear, title="Bearish Delta Divergence", message="UA [PMT] Delta divergence bearish -- {{ticker}}") // ══════════════════════════════════════════════════════════════ // DASHBOARD // ══════════════════════════════════════════════════════════════ asset_label = is_crypto ? "CRYPTO" : is_forex ? "FOREX" : is_futures ? "FUTURES" : "STOCK" sess_h1 = auto_session ? (eff_start / 60) : sess_start_h sess_m1 = auto_session ? (eff_start % 60) : sess_start_m sess_h2 = auto_session ? (eff_end / 60) : sess_end_h sess_m2 = auto_session ? (eff_end % 60) : sess_end_m sess_label = eff_use_session ? str.tostring(sess_h1) + ":" + (sess_m1 < 10 ? "0" : "") + str.tostring(sess_m1) + "-" + str.tostring(sess_h2) + ":" + (sess_m2 0 ? "+" + str.tostring(bar_delta, "#") : str.tostring(bar_delta, "#") cvd_trend = cvd_fast > cvd_slow ? "RISING" : "FALLING" var color BG = color.new(#1E1E1E, 10) var color BD = color.new(#333333, 0) if barstate.islast var table d = table.new(position.top_right, 2, 19, bgcolor=BG, border_color=BD, border_width=1, frame_color=BD, frame_width=1) table.cell(d, 0, 0, "UMAR ASHRAF v9.0", text_color=#FFD600, text_size=size.small, text_halign=text.align_left) table.cell(d, 1, 0, "[PickMyTrade]", text_color=#00E676, text_size=size.small, text_halign=text.align_right) table.cell(d, 0, 1, "ASSET", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 1, asset_label, text_color=#2196F3, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 2, "BIAS", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 2, bias_bull ? "BULLISH" : bias_bear ? "BEARISH" : "NEUTRAL", text_color=bias_bull ? #00E676 : bias_bear ? #EF5350 : #9E9E9E, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 3, "PDH / PDL", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 3, str.tostring(pdh, format.mintick) + " / " + str.tostring(pdl, format.mintick), text_color=#EEEEEE, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 4, "PMH / PML", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 4, str.tostring(pmh, format.mintick) + " / " + str.tostring(pml, format.mintick), text_color=#FF9800, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 5, "VWAP", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 5, str.tostring(vwap_val, format.mintick), text_color=#AB47BC, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 6, "50% TP", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 6, str.tostring(mid_level, format.mintick), text_color=#FFD600, text_size=size.tiny, text_halign=text.align_right) // Order Flow section table.cell(d, 0, 7, "--- ORDER FLOW ---", text_color=#00BCD4, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 7, use_orderflow ? "ON" : "OFF", text_color=use_orderflow ? #00E676 : #616161, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 8, "DELTA", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 8, delta_label, text_color=bar_delta > 0 ? #00E676 : #EF5350, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 9, "CVD TREND", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 9, cvd_trend, text_color=cvd_fast > cvd_slow ? #00E676 : #EF5350, text_size=size.tiny, text_halign=text.align_right) table.cell(d, 0, 10, "BUY %", text_color=#9E9E9E, text_size=size.tiny, text_halign=text.align_left) table.cell(d, 1, 10, str.tostring(buy_pct * 100, "#.0") + "%", text_color=buy_pct > 0.6 ? #00E676 : buy_pct 2× average + body Of 888 trading algorithms analyzed with at least six months of live data, in-sample Sharpe ratio was nearly useless at predicting live Sharpe: R² of 0.01 to 0.02. Only models trained on multiple combined risk features reached R² = 0.17. This is why the Umar Ashraf system runs five distinct entry models: signal-type diversification reduces the risk that any single backtest-optimized setup dominates live returns (Wiecki, Campbell, Lent & Stauth, [SSRN #2745220](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2745220), 2016). --- ## How Does the Order Flow Engine Approximate Footprint Data? {#how-does-the-order-flow-engine-approximate-footprint-data} The order flow engine approximates institutional activity through six OHLCV-derived signals: volume delta via the CLV method, cumulative volume delta (CVD) with EMA comparison, delta divergence between price and CVD, absorption candle detection (high volume + minimal body), block trade identification at 2.5× average volume, and volume imbalance thresholds above 60% buy ratio. None of these access real footprint or Level 2 data; TradingView does not provide it. > Volume-weighted average price was formalized as an institutional execution benchmark in a 1988 _Journal of Finance_ paper by Berkowitz, Logue & Noser Jr., making it one of the longest-standing algorithmic execution tools still in active institutional use. Institutions defend and reclaim VWAP for their own cost-efficiency reasons, which is why VWAP reclaim signals carry genuine directional weight: the buyers at that level have both the motive and the size to follow through. --- ## What Do the Backtest Results Show on TSLA 5-Minute Charts? {#what-do-the-backtest-results-show-on-tsla-5-minute-charts} Backtest run on TradingView Strategy Tester, TSLA 5-minute chart, March 2025 – April 2026, $100,000 starting capital, commission $0.01/share, slippage 2 ticks. | Metric | Value | | --- | --- | | Net Profit | +$29,138 (+29.14%) | | Buy & Hold Return | $22,085 (22.09%) | | Strategy Outperformance | +$7,053 vs. Buy & Hold | | CAGR | 27.82% | | Total Trades | 213 | | Win Rate | 60.09% | | Profit Factor | 1.63 | | Avg Win / Avg Loss | $588 / $543 | | Largest Win / Loss | $2,338 / $1,788 | | Max Drawdown | 12.46% | | Sharpe Ratio | 0.54 | | Sortino Ratio | 1.40 | | Commission Paid | $16,944 | **Parameters:** Initial capital: $100,000 · Commission: 0.1% · Slippage: 2 ticks · Partial TP at 1R · 4:1 R:R Umar Ashraf Strategy vs. Benchmarks: Return and Risk Metrics (TSLA Backtest Mar 2025–Apr 2026) Strategy Returns vs. Benchmarks TSLA 5-Min Backtest (Mar 2025–Apr 2026) vs. Reference Data UA Strategy (TSLA) TSLA Buy & Hold SPY Intraday Momentum ¹ +29.14% +22.09% +19.6% ann. Key Risk Metrics: UA Strategy 60.1% Win Rate 213 trades 1.63 Profit Factor gross P/L ratio 12.46% Max Drawdown $100k base 1.40 Sortino Ratio downside-adjusted ¹ Zarattini, Aziz & Barbon (2024), SPY 2007–2024, Swiss Finance Institute RP24-97, SSRN #4824172. UA Strategy results are hypothetical backtest only. Past performance does not guarantee future results. > The Zarattini, Aziz & Barbon (2024) SPY intraday momentum study found that on FOMC announcement days, return predictability rises to an R-squared of 11% with annualized returns of 20.04%, showing that intraday momentum edge concentrates on high-information events. This mirrors the M1 and M2 entry logic: conviction is highest immediately after a structural event (liquidity sweep or VWAP break), not during a drift session ([SSRN #4824172](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4824172), 2024). --- ## Which Settings Are Optimized for TSLA 5-Minute Charts? {#which-settings-are-optimized-for-tsla-5-minute-charts} These values emerged after iterating through over 40 parameter combinations on TSLA’s 5-minute chart. The sweep lookback window and ADX minimum threshold had the largest individual impact on signal quality. Every asset requires its own independent optimization cycle; applying these values directly to NQ or BTC without re-testing will almost certainly degrade performance, because the microstructure assumptions embedded in each setting are TSLA-specific. | Setting | Value | | --- | --- | | Sweep Lookback | 10 bars | | Sweep Margin | 0.5% | | ADX Length | 11 | | ADX Min Strength | 21 | | R:R Target | 4.0 | | VWAP Reclaim Lookback | 5 bars | | Min Body (ATR ×) | 1.0 | | Volume Multiplier | 1.3 | | SMT Divergence | ON (QQQ) | | Max Trades / Day | 10 | | Cooldown | 7 bars | | Partial TP at 1R | ON | | Breakeven | OFF | | Entry Window | 9:30–13:00 ET | > The ADX minimum of 21 was not chosen arbitrarily. At thresholds below 18, the strategy generates roughly 35% more entries on TSLA but with a materially lower profit factor (approximately 1.42 vs. 1.63), because low-ADX conditions produce false displacement signals that look like PO3 sweeps but lack institutional follow-through. The sweep lookback of 10 bars balances recency against enough context to confirm a genuine structural level violation rather than a noise wick. --- ## How Does the Risk Framework Limit Drawdown? {#how-does-the-risk-framework-limit-drawdown} ### Structural Stop Loss {#structural-stop-loss} Stop placed below the 3-bar swing low/high + 0.2–0.3 ATR buffer. Capped at 3× ATR maximum to prevent unusually wide stops. For M1 sweeps, the stop is placed below the sweep candle’s actual wick. ### Partial TP at 1R {#partial-tp-at-1r} 50% of the position exits at 1R profit (TP1). The remaining 50% runs to the full 4R target or the 50% PDH–PDL midpoint on M1 setups. This locks in profit while giving the second half of the position room to capture a larger move, and ensures the trade cannot turn into a net loser after reaching its first profit target. ### Daily Limits & Cooldown {#daily-limits-cooldown} Maximum trades per day cap + minimum N-bar cooldown between any two entries prevents over-trading. A daily max loss circuit breaker (5% of equity) halts all entries for the remainder of the session. ### EOD Flat Close {#eod-flat-close} All open positions close automatically at 15:55 ET regardless of P&L. Entries are only allowed within the 9:30–13:00 ET morning session window. > Fewer than 1% of retail day traders generate net positive returns after transaction costs across any rolling 12-month period. The primary differentiator is systematic risk enforcement: hard stops, position limits, and daily loss caps that prevent compounding losses during adverse sessions (Barber, Lee, Liu & Odean, [SSRN #529063](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=529063), 2014). The structural stop, partial TP at 1R, and 5% daily circuit breaker in this system directly implement that finding. --- ## Which Entry Filters Block Choppy and Counter-Trend Conditions? {#which-entry-filters-block-choppy-and-counter-trend-conditions} | Filter | Logic | Purpose | | --- | --- | --- | | ADX Trend Strength | ADX > 21 | Blocks entries in ranging/choppy conditions | | EMA 9/21 Intraday Stack | EMA 9 > EMA 21 for longs | Ensures entries align with intraday momentum | | EMA 50 Long-Term Filter | Close > EMA 50 for longs | Prevents counter-trend entries | | HTF 4H Structural Bias | Higher high/low on 4H = bullish | Aligns entries with higher-timeframe structure | | SMT Divergence (Optional) | TSLA vs. QQQ non-confirmation | Detects institutional non-confirmation | | Session Window | 9:30–13:00 ET only | Captures highest-liquidity morning session | > A 2025 SSRN paper on intraday momentum strategy optimization found that dynamic exit and parameter adjustment, rather than fixed rules, drove the largest performance improvements, pushing Sharpe ratios above 3.0 on test instruments. The ADX, EMA stack, and HTF bias filters in this system serve the same purpose: they raise the entry bar in non-trending conditions and confirm directional conviction before committing size (Maróy, [SSRN #5095349](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5095349), 2025). --- ## Which Markets Work Best with This Strategy? {#which-markets-work-best-with-this-strategy} ### Stocks (TSLA, NVDA, AAPL) {#stocks-tsla-nvda-aapl} Optimized for volatile momentum stocks. Use percent-of-equity sizing. Session filter auto-sets to 9:30–13:00 ET. Volume filter active. M1 PO3 sweeps are most frequent on high-float volatile stocks with defined daily levels. ### Futures (NQ, ES, Gold, Silver) {#futures-nq-es-gold-silver} Enable Fixed Qty mode and set contracts manually. Volume filter bypassed (futures volume is reliable). M5 EMA 21 pullback is especially effective on trending NQ sessions where price rarely sweeps daily levels and M1 seldom fires. ### Forex {#forex} Volume filter bypassed. Session auto-sets to London open (8:00 AM ET). Works well on EURUSD and GBPUSD with appropriate lot sizing. ### Crypto (BTC, ETH) {#crypto-btc-eth} Session filter disabled (24/7 market). EOD close disabled. M5 EMA pullback performs well during trending crypto sessions. Adjust sweep margin % for higher crypto volatility. > The global algorithmic trading market reached $21.06 billion in 2024, projected at 12.9% CAGR through 2030 ([Grand View Research](https://www.grandviewresearch.com/industry-analysis/algorithmic-trading-market-report), 2025). Each asset class has distinct microstructure: equity momentum concentrates at open, futures run nearly 24 hours, forex peaks at session overlaps. Applying TSLA settings to NQ or BTC without re-optimization is the most common cause of poor live performance on non-equity assets. --- ## How Do You Automate This Strategy with PickMyTrade? {#how-do-you-automate-this-strategy-with-pickmytrade} This strategy includes built-in TradingView alertconditions for every signal type: long entries, short entries, absorption markers, and delta divergence. Once you have confirmed the strategy on your asset, PickMyTrade handles the execution automatically without any manual intervention. For complete broker setup walkthroughs, see the [TradingView to Tradovate automation guide](https://blog.pickmytrade.trade/tradingview-to-tradovate-automation/) and the [Interactive Brokers alert setup guide](https://blog.pickmytrade.trade/interactive-brokers-tradingview-alerts/), which cover platform-specific configuration for both brokers. ### Three-Step Setup {#three-step-setup} 1. **Add to TradingView:** Open the strategy on TradingView, add it to your 5-minute chart, and apply your optimized settings for your asset. 2. **Connect PickMyTrade:** Link your broker to PickMyTrade. Supports prop firm accounts, futures, stocks, and crypto brokers. 3. **Create ONE Strategy Alert:** In TradingView, create a new alert on the strategy. Set the condition to **“Order fills only”** (not “Any alert() function call”, not a separate alertcondition). Paste the JSON payload below into the alert message. PickMyTrade fires orders in real time: entry, SL, and TP placed automatically. **⚠ Duplicate trades warning:** This strategy contains both `strategy.entry()` calls and `alertcondition()` signals. If you create a Strategy alert AND a separate alertcondition alert for the same symbol, TradingView fires both, sending two orders per entry to PickMyTrade. Use exactly one alert per symbol: the Strategy alert with “Order fills only”. ### Alert JSON Payload (Strategy Alert — Order Fills Only) {#alert-json-payload-strategy-alert-order-fills-only} Paste this into the TradingView alert message field. Replace `your_token_here` and `your_account_id` with your PickMyTrade credentials. The `{{strategy.order.*}}` variables populate automatically from the strategy at fill time; they do not work in alertcondition alerts. ``` { "symbol": "{{ticker}}", "date": "{{timenow}}", "data": "{{strategy.order.action}}", "quantity": "{{strategy.order.contracts}}", "risk_percentage": 0, "price": "{{close}}", "tp": 0, "percentage_tp": 0, "dollar_tp": 0, "sl": 0, "dollar_sl": 0, "percentage_sl": 0, "trail": 0, "trail_stop": 0, "trail_trigger": 0, "trail_freq": 0, "update_tp": false, "update_sl": false, "breakeven": 0, "token": "your_token_here", "pyramid": true, "reverse_order_close": false, "account_id": "your_account_id", "multiple_accounts": [ { "token": "your_token_here", "account_id": "your_account_id", "risk_percentage": 0, "quantity_multiplier": 1 } ] } ``` The strategy gives you the signal. PickMyTrade makes sure it executes without fail, every time, at the right size, with the right SL and TP. > The algorithmic trading market’s 12.9% annual growth rate through 2030 reflects a direct shift: retail traders are moving from discretionary to rules-based execution, and broker execution infrastructure is the layer that determines whether that shift reaches the actual order book at the right size and time. PickMyTrade sits at that junction, converting TradingView’s alert output into broker-native orders with entry, stop-loss, and take-profit parameters set from the strategy’s own logic (Grand View Research, 2025). --- ## Frequently Asked Questions {#frequently-asked-questions} ### What is the Umar Ashraf Strategy based on? {#what-is-the-umar-ashraf-strategy-based-on} It is a multi-model intraday strategy inspired by Umar Ashraf’s trading methodology, which centers on Power of Three (PO3), a Smart Money Concepts framework that trades liquidity sweeps of key daily and weekly levels. The Pine Script implementation adds VWAP dynamics, order flow approximation, and systematic risk management on top of these core concepts. ### Can I use this on markets other than TSLA? {#can-i-use-this-on-markets-other-than-tsla} Yes. The strategy is compatible with stocks, futures (NQ, ES, Gold, Silver), forex, and crypto. The asset type is auto-detected and session windows adjust automatically. However, the optimized settings shown here are specific to TSLA on the 5-minute timeframe. Every asset requires its own independent optimization. Do not apply TSLA settings to NQ or BTC without re-testing. ### Why is the Sharpe Ratio only 0.54 if the net profit is strong? {#why-is-the-sharpe-ratio-only-0-54-if-the-net-profit-is-strong} The Sharpe Ratio measures risk-adjusted return relative to total volatility. Intraday strategies on volatile instruments like TSLA naturally produce high trade-to-trade variance, which depresses the Sharpe Ratio even when absolute returns are healthy. The Sortino Ratio of 1.40, which only penalizes downside volatility, gives a better picture of the strategy’s actual risk profile. A Sortino above 1.0 is generally considered acceptable for intraday momentum systems. ### Does this strategy access real order flow or footprint data? {#does-this-strategy-access-real-order-flow-or-footprint-data} No. TradingView Pine Script cannot access Level 2 DOM, tape data, or footprint charts. This strategy approximates order flow using volume delta (CLV method), cumulative volume delta (CVD), absorption detection, and delta divergence, all derived from OHLCV data. This produces directional bias information that improves signal quality, but it is not a substitute for real footprint analysis. ### What does “partial TP at 1R” mean in practice? {#what-does-partial-tp-at-1r-mean-in-practice} When the trade reaches 1× your initial risk in profit, 50% of the position is automatically closed at that level. The remaining 50% continues to the full 4R target. This approach locks in profit on the initial risk while giving the second half of the position room to capture a larger move. ### How do I automate this strategy for live trading? {#how-do-i-automate-this-strategy-for-live-trading} Add the strategy to your TradingView chart and configure your settings. In TradingView Alerts, create a single alert on the strategy and set the condition to “Order fills only”; do not create separate alertcondition alerts, as that causes duplicate orders. Paste the JSON payload into the alert message field, connect PickMyTrade to your broker, and PickMyTrade will place every entry, stop-loss, and take-profit automatically in real time. --- ## Start Trading the Umar Ashraf Strategy {#start-trading-the-umar-ashraf-strategy} The Umar Ashraf Strategy is available now as a public Pine Script v6 strategy on TradingView. Add it to your 5-minute chart, apply the optimized settings for your asset, forward-test for a minimum of 30 trades, then automate execution with PickMyTrade. _Disclaimer: Past performance does not guarantee future results. All backtest results shown are hypothetical and based on historical data with the benefit of hindsight. The settings shown are optimized for TSLA and may not be suitable for other assets without independent optimization. This strategy is provided for educational and informational purposes only. Trading involves substantial risk of loss. Always conduct your own due diligence and consult a qualified financial advisor before risking real capital. © PickMyTrade_ For AI tools & developers:[View Markdown →](https://blog.pickmytrade.trade/umar-ashraf-strategy-power-of-three-pickmytrade.md)