DEV Community: Mahesh

I rebuilt a viral "3,888% return" TradingView strategy — it landed almost exactly at coin-flip odds

Mahesh — Sun, 26 Jul 2026 18:47:15 +0000

A trading YouTube channel (Trading with DaviddTech)
posted a video claiming a "strange 63% win rate" TradingView indicator, turned into a full
strategy (three indicators stacked together, nicknamed "Manergy Cloud" in the video), backtested
on BTCUSDT at 1-hour bars with a claimed 3,888% total return, 62.8% win rate, profit factor
2.1, over 237 trades — using 10x leverage.

I wanted to actually test this, not just read the claim. This post walks through what happened
when I tried — including the part where the video's own central indicator turned out not to
actually exist anywhere obtainable.

What the video claims

Strategy name: "Manergy Cloud," tested on BTCUSDT, 1-hour timeframe, 10x leverage.
Entry indicators: an "EWMA" (the video's own term — stated as "Entropy Weighted Moving Average," not the standard exponentially-weighted moving average) filters for tradeable vs. choppy conditions; a public Range Filter (by Donovan Wool) sets trend direction; an "LMO" (Lead-Lag Moving Oscillator) confirms entries.
Risk: ATR bands (3x multiple) for the stop, fixed 1:2 reward:risk.
Claimed results: 3,888% total P&L, profit factor 2.1, 62.8% win rate (149W/88L over 237 trades), 21% max drawdown, longest losing streak 6 trades, longest winning streak 16.

Treat every number above as a claim from the video, not an independently verified fact.

The reproducibility problem — this is the actual headline finding

Before writing any code, I checked the video's own comment section. Multiple top comments (6+
likes each) report:

"The EWMA Indikator is not on Tradingview or in your website"
"Why post a video to copy a strategy but not provide the indicators?"

The video's description pushes a Skool community, a "strategyfactory.ai" resource link, and a
pinned comment offering "all my TradingView strategies & tools... for FREE. LIMITED SPACES!" —
classic lead-gen structure. Neither the "EWMA" nor the "LMO" indicator used in the video is a
standard, publicly-documented technique with a known formula, and per the video's own audience,
neither is actually available anywhere to check.

This matters more than the headline return number. It means nobody watching that video can
actually verify the 3,888%/62.8% claim — not because the underlying idea is necessarily fake,
but because the specific indicators driving entries were never published. That's worth knowing
before anyone trades real money on the strength of that number.

What I actually tested

Given the reproducibility gap, I built the closest honest equivalent I could, being explicit about
what's faithful and what's reconstructed:

Component	Status
Range Filter (Donovan Wool)	Faithful — this is one of TradingView's most widely-used open-source indicators; its formula is public and well-documented.
ATR Bands stop / 1:2 R:R	Faithful — standard Wilder ATR, exactly as the video describes the risk setup.
"LMO" (Lead-Lag Oscillator)	Reconstructed. No public formula exists under this name. I built a plausible lead/lag EMA-crossover oscillator matching the video's description (green line above zero / red line below zero confirms direction) — not the creator's actual, never-published formula.
"EWMA" regime filter	Reconstructed. Also not obtainable (confirmed by the video's own commenters). I substituted a Kaufman-style efficiency-ratio choppiness filter — a standard, well-documented technique for the same purpose (filter out sideways/choppy conditions), not a reproduction of whatever the video's version actually computes.

I also substituted instruments: MES, MNQ, SPY, and QQQ (unlevered), instead of BTCUSDT at 10x
leverage — both because this pipeline focuses on US equity/futures instruments, and because
crypto's 24/7 session structure and leverage assumptions aren't directly comparable to what most
readers of this blog are actually trading.

Bottom line on scope: this backtest tests my reconstruction of the described strategy shape, not
a verified port of the video's actual strategy. That's a materially weaker claim than
"replicated his results" — and an important distinction, not a footnote.

The signal, in Python

# strategy_logic.py (excerpt)
class ManergyCloudSignal:
    """
    Entry confirmed when: regime filter is 'green' (trending, not choppy)
    AND Range Filter direction flips AND LMO green/red lines confirm the
    same side. Risk: ATR-band stop (3x ATR), fixed 1:2 reward:risk.
    """
    def signals(self):
        long_flip = self.df["rf_trend_up"] & ~self.df["rf_trend_up"].shift(1).fillna(False)
        short_flip = self.df["rf_trend_down"] & ~self.df["rf_trend_down"].shift(1).fillna(False)

        long_confirm = long_flip & (self.df["lmo_green"] > 0) & (self.df["lmo_red"] < 0) & self.df["regime_green"]
        short_confirm = short_flip & (self.df["lmo_green"] < 0) & (self.df["lmo_red"] > 0) & self.df["regime_green"]
        # ... ATR-band stop distance attached per signal, entry filled at next bar's open

The Range Filter is a faithful port of Donovan Wool's published stateful smoothing-band algorithm
(a var-style filter line that only moves when price closes outside its current band, direction
flips tracked via consecutive up/down move counters). The regime filter is a Kaufman efficiency
ratio: net directional displacement over a window, divided by total absolute movement in that
window — high efficiency means trending, low means choppy.

Backtester is fully event-driven and causal: entries fill at the next bar's open after a signal
(never the signal bar's own close), stop-vs-target resolved bar-by-bar using only that bar's real
High/Low (stop wins on same-bar ambiguity), commission ($0.85/side) and slippage (1 tick/side)
applied on both entry and exit.

The same logic in Pine Script v6

//@version=6
strategy("Manergy Cloud-Style (Range Filter + Reconstructed LMO/Regime)", overlay=true)

// Range Filter (Donovan Wool, faithful)
avgRng = ta.ema(math.abs(close - close[1]), rfLen)
smoothRng = ta.ema(avgRng, rfLen * 2 - 1) * rfMult
var float rfFilt = na
rfFilt := na(rfFilt[1]) ? close :
     close > rfFilt[1] ? math.max(rfFilt[1], close - smoothRng) : math.min(rfFilt[1], close + smoothRng)

// Reconstructed regime filter (Kaufman efficiency ratio, stands in for the
// video's unobtainable "EWMA" indicator)
netMove = math.abs(close - close[entropyWindow])
totalMove = math.sum(math.abs(close - close[1]), entropyWindow)
efficiency = totalMove == 0 ? 0.0 : netMove / totalMove
regimeGreen = efficiency > (1 - entropyThreshold)

// Entry + ATR-band stop / 1:2 R:R target
if longEntry
    stopPrice = close - atr[1] * atrMult
    targetPrice = close + atr[1] * atrMult * rr
    strategy.entry("Long", strategy.long)
    strategy.exit("Long Exit", from_entry="Long", stop=stopPrice, limit=targetPrice)

Unlike the earlier CFTC-based post on this blog, this strategy is fully computable bar-by-bar from
OHLCV alone — no external weekly data feed needed — so this is a real strategy() script, not
just a signal overlay. Same reconstruction caveat applies: the LMO and regime-filter portions are
approximations of the video's description, not verified ports of its actual formulas.

Backtest results

Hourly bars, real historical data: MES/MNQ from ~3.25 years of Tiger continuous-futures data
(Apr 2023–Jul 2026), SPY/QQQ from ~1 year of Tiger hourly bars (Jul 2025–Jul 2026 — Tiger's
hourly-history API appears capped around a year, a real data-window limitation worth flagging
rather than hiding).

Instrument	Trades	Win Rate	Gross P&L	Net P&L (after costs)	Profit Factor	Max Drawdown	Sharpe	Stopped Out
MES	3,563	34.5%	$490.99	-$5,566.11	0.99	-$49,767	-0.29	65.0%
MNQ	3,687	35.1%	$17,506.78	+$11,238.88	1.01	-$111,396	0.29	64.8%
SPY	310	32.9%	$186.75	-$340.25	0.81	-$561	-1.68	66.5%
QQQ	315	33.7%	$97.77	-$437.73	0.81	-$820	-1.73	66.3%

All trade counts (310–3,687) are comfortably above the ~50-trade threshold I use to trust a result
at all — MES and MNQ especially so.

The actual finding: win rates cluster tightly at 33–35% — almost exactly the mathematical
breakeven point for a fixed 1:2 reward:risk setup (1 ÷ (1+2) = 33.3%). Before costs, this strategy
lands right at coin-flip-adjusted-for-payout. After realistic commission and slippage, three of
four instruments go net negative. MNQ's apparent "win" (+$11,239 net) comes with a -$111,396 max
drawdown — over 9x the eventual profit — which is nowhere close to a usable risk-adjusted result
regardless of the headline sign.

The ~65% stop-out rate across all four instruments is consistent with a strategy sitting almost
exactly at its own breakeven line: neither a clear edge nor a clear failure at the entry-logic
level, just costs and drawdown doing what they do to a coin flip run thousands of times.

Honest caveats

This tests a reconstruction, not the original strategy. The LMO and "EWMA" components are approximations built from the video's description, not verified ports of the creator's actual (never-published) formulas. A genuinely faithful test isn't possible with what's public.
Instrument and leverage mismatch with the source video. Tested on unlevered MES/MNQ/SPY/QQQ hourly bars, not BTCUSDT at 10x leverage — a fundamentally different risk profile than the video's claimed 3,888% figure, which should be read as a leveraged-crypto number, not comparable to an unlevered-equity-index number.
SPY/QQQ only got ~1 year of hourly data (a Tiger API history limit for hourly bars, not a choice) — meaningfully less than MES/MNQ's 3.25 years. Their trade counts (310, 315) still clear the reliability floor, but with a shorter, more recent sample.
Costs are estimates ($0.85/side commission, 1 tick slippage/side), not a confirmed real fee schedule.
No partial exits or trailing stops — a fixed stop and fixed 1:2 target only, matching what the video described, though a real trader might manage the position differently.

Bottom line

The video's headline claim (3,888% return, 62.8% win rate) can't actually be independently
verified — its central indicators aren't publicly available, a fact confirmed by the video's own
audience in the comments, not just my own search. When I rebuilt the described strategy shape
using faithful public components (Range Filter, ATR bands) plus honest reconstructions for the
unavailable pieces, on real MES/MNQ/SPY/QQQ hourly data, the result landed almost exactly at the
mathematical breakeven win rate for its own reward:risk ratio — and lost money after costs on
three of four instruments tested, with the fourth "winning" instrument carrying a drawdown far
larger than its eventual profit.

This doesn't prove the original video's claim is false — it's possible the real, unpublished
indicators genuinely do something meaningfully different from my reconstruction. But it does mean
nobody can currently verify that claim from the outside, and the closest honest attempt at
rebuilding it didn't show an edge.

Full code and trade logs for this post are private for now — ask if you want them.

I tried to port an Indian FII/DII trading strategy to MNQ, MES, SPY, and QQQ — it lost money on all four

Mahesh — Sun, 26 Jul 2026 17:22:43 +0000

A trading YouTube podcast (Upsurge Club, ft. Amit Dhamija)
describes a strategy built entirely around India's NSE exchange data: daily FII (Foreign
Institutional Investor) / DII (Domestic Institutional Investor) / Proprietary / Retail
participant-wise open interest. The claim is that tracking whether "smart money" is building or
unwinding positions gives a real edge over price action alone.

I wanted to know: does anything like this exist for US markets, and if you build the closest
honest equivalent, does it actually work? This post walks through the whole process — including
the part where the answer is no.

What the video claims

Four participant categories move the market: FIIs, DIIs, Proprietary traders, and Retail.
Retail traders lose money overwhelmingly — the video cites SEBI data putting this above 90%.
The edge comes from daily participant-wise open interest, published by NSE, tracked day-over-day to see who's adding vs. unwinding positions.
A second, separate signal comes from option open-interest concentration at specific strikes (e.g. Nifty 24,000) as support/resistance.

Treat all of the above as claims from the video, not independently verified facts — in
particular I have not verified the "90% of retail traders lose money" SEBI figure myself, I'm
relaying what the video states.

Does this exist for US markets?

Short answer: not at the same frequency, and not from any single source.

NSE data Dhamija uses	Closest US equivalent	What's lost
Daily FII/DII/Pro/Retail open interest	CFTC Traders in Financial Futures (TFF) — free, no-auth Socrata API	Weekly, not daily. Report is "as of" Tuesday, released the following Friday — a multi-day-old read vs. NSE's next-day data.
Strike-level option OI walls	SPY/QQQ/SPX option chain OI (available live via most broker APIs, including Tiger Brokers, which I already had wired up)	Broker APIs expose current OI only — no historical time series by strike, so this piece can't be backtested, only paper-traded going forward.

I found this out by actually grepping my environment for existing broker credentials rather than
assuming — turns out I already had Tiger Brokers' API configured for live trading, and CFTC
publishes their institutional positioning report as a completely free public API. No new
accounts or paid data vendors needed.

Because the strike-OI piece isn't backtestable with data I actually have, this post only tests
the weekly institutional-bias half of the strategy. That's an important, honest limitation, not
a footnote — it's entirely possible the real edge (if any) lives in the untested timing piece.

The signal, in Python

# strategy_logic_fii.py
class WeeklyBiasSignal:
    """
    Each week, CFTC reports the leveraged-fund community's net change in
    long/short S&P 500 or Nasdaq-100 futures positioning.

    bias = +1 if leveraged funds net-ADDED to longs this week
           -1 if they net-ADDED to shorts
            0 if flat -> no trade that week

    usable_from = report_date + 6 days: the Monday after the Friday public
    release -- the first day this information could causally be acted on.
    """
    def __init__(self, tff_df):
        self.tff = tff_df.copy()
        self.tff["report_date"] = pd.to_datetime(self.tff["report_date"], utc=True)
        self.tff["usable_from"] = pd.to_datetime(self.tff["usable_from"], utc=True)
        self.tff = self.tff.sort_values("usable_from").reset_index(drop=True)

    def signals(self):
        return self.tff[self.tff["bias"] != 0][
            ["report_date", "usable_from", "bias", "lev_money_net_change", "open_interest_all"]
        ].reset_index(drop=True)

Trade rule: enter at Monday's open in the direction of bias, hold to that week's Friday close,
one position at a time. A 2×ATR(14) stop-loss is applied — sized using only prior days' ATR
(shifted, so Monday's stop never peeks at Friday-or-later data) and walked day-by-day through the
week with proper gap-fill handling if price opens beyond the stop.

The full backtester is event-driven and causal throughout: no signal is ever used before its real
public-release date, no fill is assumed instantly at the signal price, and every trade accounts
for commission ($0.85/side, an estimate) and slippage (1 tick/side).

The same signal in Pine Script v6

//@version=6
indicator("Weekly Leveraged-Fund Bias (CFTC TFF)", overlay=true)

// Pine can't call an external REST API mid-script, so the weekly CFTC bias
// has to be injected as an external data series -- e.g. via a CSV-backed
// custom symbol imported into TradingView, or manually via input.int() for
// manual/replay use. This is NOT equivalent to the live Python pipeline,
// which pulls CFTC's API directly -- treat this Pine version as a chart
// overlay for eyeballing the signal against price action, not a
// self-contained backtestable strategy.

bias = input.int(0, "Weekly bias (+1/-1/0, set manually per CFTC release)", minval=-1, maxval=1)

atrLen = input.int(14, "ATR length")
atrMult = input.float(2.0, "Stop ATR multiple")

atr = ta.atr(atrLen)
isMonday = dayofweek == dayofweek.monday

var float stopPrice = na
if isMonday and bias != 0
    stopPrice := bias == 1 ? close - atrMult * atr : close + atrMult * atr

plotshape(isMonday and bias == 1, style=shape.triangleup, location=location.belowbar, color=color.green, title="Long bias")
plotshape(isMonday and bias == -1, style=shape.triangledown, location=location.abovebar, color=color.red, title="Short bias")
plot(stopPrice, title="ATR Stop", color=color.orange, style=plot.style_circles)

I want to flag this plainly: the Pine version is a simplification of the Python one, not an
independent implementation of the same thing. It can't fetch CFTC's weekly report on its own, so
the bias has to be fed in manually or via an imported custom series. If you're going to trust one
of these two versions, trust the Python backtest below — that's the one that actually ran against
real historical data end to end.

Backtest results

Four instruments, same signal, same 2×ATR(14) stop, real cost assumptions. All figures are trade
counts × real historical daily bars — MES/MNQ from ~3.25 years of Tiger continuous-futures data
(Apr 2023–Jul 2026), SPY/QQQ from ~6 years of Tiger daily bars (Jul 2020–Jul 2026).

Instrument	Trades	Win Rate	Gross P&L	Net P&L (after costs)	Profit Factor	Sharpe	Stopped Out
MES	166	47.0%	-$1,725.70	-$2,007.90	0.94	-0.15	18.7%
MNQ	166	52.4%	-$6,459.35	-$6,741.55	0.91	-0.26	18.1%
SPY	312	42.6%	+$114.12	-$416.28	0.71	-0.99	16.3%
QQQ	312	42.0%	+$23.67	-$506.73	0.69	-1.02	17.0%

Every instrument loses money net of costs. Trade counts (166-312) are comfortably above the
~50-trade threshold I use to trust a result at all, so this isn't a small-sample fluke — it's a
real, if modest, negative edge for this specific version of the signal.

The stop-loss barely moved the needle versus no stop at all. Only 16-19% of trades ever hit it —
the problem here isn't blown-up losing trades, it's that the underlying win rate (42-52%) combined
with the payoff structure doesn't clear its own costs. A stop fixes tail risk; it doesn't fix a
weak base rate.

Honest caveats

This tests roughly half of Dhamija's actual method. The strike-level option-OI timing piece — arguably where his edge, if real, actually lives — isn't backtestable with any data source I have access to (broker APIs only expose current OI, not history). It would need forward paper-testing, not a backtest, to evaluate.
CFTC's reporting lag is real and large relative to NSE's. A multi-day-old institutional positioning read is a fundamentally weaker signal than next-day data, independent of whether the underlying idea has merit.
Costs are estimates ($0.85/side commission, 1 tick slippage/side), not a confirmed real fee schedule.
Fixed weekly hold, no intra-week profit-taking — a real implementation might manage this differently, though I'd want to see it tested rather than assumed to help.
MNQ's Tiger continuous-contract data initially had a gap that cut it off ~3 months before the final "as of" date; caught and re-pulled before finalizing these numbers, but worth mentioning as a reminder to always sanity-check a data pull's actual date range rather than trust the fetch script silently.

Bottom line

The honest finding: weekly CFTC leveraged-fund positioning, on its own, is not a profitable
signal on MNQ, MES, SPY, or QQQ. This doesn't disprove Dhamija's method on its home turf (NSE) —
it means the specific piece of it that's actually testable with public US data doesn't hold up by
itself. If you want to take this further, the two real next steps are (1) get a historical
options-OI-by-strike dataset to test the timing layer this post couldn't touch, or (2) forward
paper-trade that layer live since it can't be validated historically.

Full code, trade logs, and data-fetch scripts for this post are private for now — ask if you
want them.