BTC Trading System Development: Risks, Testing & Scaling

Hey folks, I've been working on a BTC trading system for about 8 months now. My main focus isn’t on chasing short-term gains, but rather on managing risks, preserving capital, and making sure it works well in different market conditions. I’ve also done some initial tests on various altcoins, and they seem to behave in a similar way, without any noticeable drop in risk profile, but BTC is still my main target. I’ve been keeping track of performance results through TradingView’s reports, which I review and export monthly. In this thread, I’ll be sharing Strategy Tester reports for several months, from November till now, posted as separate screenshots. Just a few clarifications to clear up any confusion: The main trading logic hasn’t changed over these months. I’ve fine-tuned the execution details, internal safeguards, and overall implementation quality. The risk framework and structural limits have remained stable. Position sizing and capital management are built right into the strategy. Every trade has a set Stop Loss and Take Profit. No leverage has been used yet (I’m still working on that part). Trading fees are included in the calculations. Slippage is limited to TradingView’s default model. When I tweak the TP / SL / Commission settings: Entry points get adjusted. Profitability might drop. But the system doesn’t switch to unstable or high-risk modes. Here are some key metrics from my multi-month backtests: Profit Factor: ranges from about 2.24 up to 8.2 Win Rate: between 52% and 78% Maximum Drawdown: seen between 0.6% and 3.6% Just sharing these numbers for context, not making any performance promises.

Interesting thread, thanks for laying things out clearly. A few thoughts from someone who’s been through the “TV → live → scale” pipeline more than once. I personally treat TV Strategy Tester as a falsification tool, not a validation tool, so your framing here is healthy. It’s good at killing bad ideas early, but it’s overly optimistic once you start caring about execution nuance. The biggest gaps I’ve seen vs live are: * partial fills being ignored, * optimistic bar-based TP/SL sequencing, * and slippage behaving very differently during volatility expansion.   On lower TFs, these add up faster than people expect, even on BTC. The drawdown numbers are honestly the most interesting part to me. Sub-4% max DD across multiple months with trades happening suggests either: * very tight risk constraints (good), * or a regime that hasn’t yet been stress-tested by a real volatility shock.   I’d be curious how this behaved during sudden liquidity vacuums (news candles, weekend gaps, etc.), because that’s where many “robust” systems quietly break. On BTC specifically: * Capital scaling usually isn’t an issue until you’re pushing sizes that meaningfully interact with the order book on your execution timeframe. On lower TFs, this can happen sooner than people think. * Distribution scaling is mostly irrelevant unless signals are public or synchronized. Edge decay usually comes from execution correlation, not the idea itself. * The biggest jump in quality I’ve seen is moving off TradingView alerts into a custom execution layer, even before size increases. Not for speed alone, but for control over order logic and failure modes. TV itself isn’t the main leakage vector, people are. Screenshots, behavior patterns, and over-confidence tend to leak more than code. That said, once multiple accounts are running the same logic, execution clustering becomes a real concern.

Thanks for the thoughtful feedback. I want to clarify one point where I may see things slightly differently. I don’t really view TradingView as a “model” of the market that later needs a separate validation step. It executes the exact strategy logic on real historical data and continues to do so in live market conditions. In that sense, the system is already being forward-tested continuously, not hypothetically. Regarding volatility shocks: the reported period already includes multiple high-stress regimes, including sharp drawdowns, fast intraday moves, and very recent high-volatility events. Risk controls and stop logic held during those conditions, and a significant portion of the downside was captured on the short side. Where I fully agree there is still uncertainty is execution: order handling, fills, latency, and exchange-specific behavior. That’s the primary reason I’m focusing next on moving from TradingView alerts to direct exchange execution, not because I doubt the logic under stress, but because execution is where most real-world failure modes live. If you’re open to sharing, I’d be interested in which execution-related issues (rather than signal logic) caused the biggest divergence for you once you moved off TradingView.