Previous Episode Recap (full text): Yesterday I opened a ZECUSDT futures grid with 200 levels across the 800–2000 USDT range. A $100 short position took a loss, but the Martingale futures grid made over $100, the ZEC spot position added $20, and my account grew to $1080. After withdrawing $200, I continued with the remaining $880. The goal was: grow from $800 to $1000 daily, withdraw $200.

This Episode’s Theme: I’m not relying on luck. This piece is a deep research I did for myself—the mathematical reality of grids and Martingales, how to scientifically construct the “15-minute range strategy” I’m designing, what tech stack to choose, where to find real alpha, and finally the prompt I’m handing to the AI for the LynxCrypto system.

0. First, Three Buckets of Cold Water (Expectation Management)

Before diving into any technical detail, let me put the hardest numbers from this research on the table. They set the tone for every decision that follows:

1. The retail baseline is losing. In a study of the Brazilian stock-index futures market, retail traders who traded for more than 300 days lost money 97% of the time, and only 1.1% earned more than the local minimum wage ($16/day). Chague et al. 2019, cited in Day trading — Wikipedia

2. A pretty backtest ≠ future effectiveness. The latest pre-registered experiment of 2026 (MinervaScore) found that a composite score integrating five robustness checks—including the Deflated Sharpe Ratio and the probability of backtest overfitting—had nearly zero predictive power for future returns (Spearman ρ=0.013, p=0.40). Equity Strategy Backtesting: MinervaScore (arXiv:2608.23808)

3. Publication equals decay. The single variable “year of publication” explains 30% of the variance in factor Sharpe decay—any systematic strategy you can find online is likely already on its way to失效. Why and how systematic strategies decay (arXiv:2105.01380)

Taken together, these three points mean: growing from $800 to $1000 daily (a 25% daily return) is not a “goal” but a behavioral trap that will push you to add to losing positions to make up for drawdown days. The sensible objective function is “last long enough + have a slightly positive expectancy,” and profit is a byproduct of survival. Every system design that follows operates under this assumption.

1. My 200-Level Grid: Understand the Math First

1.1 The Underlying Structure of a Grid

My parameters: 800–2000 USDT, 200 levels, arithmetic, step size 6 USDT. Here’s a detail easily overlooked: in an arithmetic grid, the percentage step at the bottom of the range (0.75%) is 2.5× the percentage step at the top (0.30%). A geometric grid, by contrast, gives ~0.459% per level and naturally tilts toward “heavier buys at the bottom,” better suiting high-volatility instruments. Arithmetic and Geometric grid types — Gainium

The profit per level must survive the fee hurdle. Bybit’s official formula: profit per level = price interval × quantity per level × completed levels − fees. The contract taker fee is 0.055% (VIP0), so round-trip fees are ~0.11%—any level with a gross profit margin below 0.11% is literally working for the exchange. Bybit itself caps the maximum number of levels to ensure “grid profit > fees.” P&L Calculations (Futures Grid Bot) — Bybit Bybit Trading Fee Structure

There is also a slow bleed: perpetual contracts settle funding every 8 hours (00:00 / 08:00 / 16:00 UTC). A 50,000 U notional grid position at a mild +0.01% per 8h rate gets drained ~450 U per month; in extreme regimes when the rate spikes to +0.10% per 8h, the drain hits 45% of principal each month. Pionex Futures Grid explainer What Are Funding Rates — Cube Exchange

1.2 The Liquidation Math of Martingale Position Sizing (I modeled it myself)

The most valuable part of the research: I built my own model of the liquidation price for a “200-level grid + Martingale compounding.” Model (note: my inference, not cited from any source): the margin at level i is M₀·m^i (m = compounding multiplier), leverage L, and the average cost of the full grid is P̄. The approximate liquidation price for a full-position account is:

1

P_liq = (Q·P̄ − M_total) / (Q·(1 − mmr))

Q is total coin held, and mmr (maintenance margin rate) is set at 0.5%—in practice it climbs with position tiers, so the estimate is optimistic; real liquidation comes sooner.

Scenario: price grinds from 2000 down to fill the entire long grid:

Structural conclusion (straight from the arithmetic): as long as the compounding multiplier m > 1, geometric-series summation forces nearly all margin onto the final levels near 2000 (with m=1.1 and a $10,000 budget, the first level posts ~0.00005 U and the last ~909 U—a 170-million-to-one spread). Average cost gets pushed to 1900+. Even at 2x leverage, liquidation falls inside the grid range. Martingale does not enlarge your survival zone; it swaps a nominal sense of “covering 60% drawdowns” for an actual exposure of “22% drop and you’re dead.”

This explains why my Martingale grid made “over $100” yesterday: its high win rate is by design. The optional stopping theorem strictly proves that under finite capital (always true in reality), Martingale loses in the long run; its payout distribution is “frequent small gains + rare total wipeout.” The probability of hitting a 6-loss streak in 200 trials is ~84%; a 10-loss streak (costing 1023× the initial bet) has ~11% probability in 200 trials. Martingale (betting system) — Wikipedia Stated in institutional terms, a Martingale grid “doesn’t safely recover losses—it delays and amplifies them until the mean reverts or the account dies first.” Many prop firms explicitly ban such strategies. Grid Trading: How It Works and Where It Breaks — Audacity Capital

My checklist for remodeling the grid (from research + my own calculations):

• Fix compounding multiplier at m=1 (equal lot sizes per level), so drawdown is linear and calculable.
• Add a hard circuit breaker: if the grid’s floating P&L hits X% of margin, flatten everything—Audacity Capital calls this “the single most important control.”
• Replace the fixed 6 U step with ATR-dynamic spacing: spacing = clamp(ATR% × 0.6, 1%, 4%). In tests, switching ETH from a fixed 1.5% spacing to 1.0% (≈0.6×ATR) roughly doubled fill frequency. Dynamic grid spacing with ATR — dev.to
• Trend filter: use ADX to judge the regime and pause interval grids in trending markets (details in the next section).

2. My “15-Minute Range Strategy”: From Intuition to Executable Design

My initial instinct was: use the range of 15-min candles to find a band that captures most volatility, compute an entry point that balances risk/reward, go long and short on both sides, reverse immediately when the long side ends, and use some indicator to avoid being run over by a one-way trend. After research, this instinct was decomposed into five literature-backed concrete decisions.

2.1 How to define the range: don’t use fixed ticks—use volatility-adaptive bands

Three mature industry-standard approaches to “historical-volatility-defined channels”:

• Keltner Channel: EMA20 ± 2.0×ATR(10). Uses ATR (smoother than standard deviation) and EMA (more responsive than SMA)—the most suitable off-the-shelf structure for a “volatility-adaptive range.” Keltner Channels — StockCharts ChartSchool
• Bollinger Bands: SMA20 ± 2σ. Caveat: due to fat tails and serial correlation in price series, only ~88% (not the 95% a normality assumption would suggest) of prices actually fall inside the band. Bollinger Bands — Wikipedia
• Donchian Channel: N=20 highest/lowest price (the Turtles used dual 20/55 periods). Donchian channel — Wikipedia

The academic result closest to my instinct is the Opening Range Breakout (ORB): Holmberg et al. set breakout thresholds based on return distributions and enter only when price crosses them, finding statistically significant positive returns on crude-oil futures. Assessing the profitability of intraday opening range breakout strategies — Umeå University

Decision for implementation: entry threshold = prev_close ± k × ATR(15min) or ±k × rolling-range quantile, with k calibrated via parameter sweep rather than guessed.

2.2 Breakout-following or mean reversion? — Let the regime choose for you

This was the most counter-intuitive finding in the research: the industry-default breakout-following rule is statistically unstable in academic tests; the reverse (mean-reversion) usage actually has positive-return records. Lento et al. (2007) found no outperformance of standard Bollinger strategies over buy-and-hold; but Balsara et al. (2007) found that contrarian channel-break rules retained significant positive returns even after a 0.5% cost deduction. Bollinger Bands — Wikipedia (Note: this evidence comes from daily stock/forex and cannot be directly extrapolated to crypto 15-min, but the direction is worth respecting.)

Another warning: the Donchian default parameters posted only a 35% win rate across 360 years of cross-market data in 4,887 trades—“likely unprofitable after slippage.” Donchian channel — Wikipedia

Decision for implementation: don’t commit to a single mode. Use a regime filter to pick one—

• ADX < 20 (no trend): mean-reversion mode; fade touches of the Keltner upper/lower bands. The 20/25 threshold is Wilder’s original calibration. ADX — StockCharts ChartSchool
• ADX > 25 (strong trend): breakout-following only, and absolutely no stop-and-reverse—exactly the “avoid one-way trends” guard I need.
• 20–25 grey zone: cut position size or stand aside.
• Multi-timeframe confirmation: 15-min signals only enter when 1H/4H EMA direction aligns (standard top-down convention). How To Perform A Multi TimeFrame Analysis — Tradeciety

2.3 “Reverse immediately after the long side ends” is a trap

My original stop-and-reverse design (always in the market, instant long-to-short flips) has a well-known structural flaw: whipsaw drag compounds in chop—your “death by a thousand stops”—and each flip incurs close + open fees plus double slippage. At crypto taker fees of ~0.055% one-way, a few flips on a chop day can swallow the entire expected profit. How To Manage Whipsaws — Optimus Futures Whipsaw in Trading — 5paisa

Decision for implementation: allow a “flat” (no position) state. After closing, observe; new-direction entries require ADX/multi-timeframe confirmation before entry. Flat is a legitimate position.

2.4 Exit: time stops deserve more weight than price stops

QuantifiedStrategies backtests show that time stops are “the simplest and most underestimated exit”—they reduce drawdown, shorten exposure time, and are less prone to overfitting; fixed stops and trailing stops in their tests often degraded strategy performance. When to Exit a Trade — QuantifiedStrategies

Decision for implementation: if the target is not hit within N 15-min bars after entry, force-exit; price stops are reserved for catastrophe insurance only (placed 1×ATR beyond the channel), not as the routine exit.

2.5 Three Special Considerations for Perpetual Contracts

• Funding-rate timing博弈: you only pay/receive funding when you hold a position across the 00/08/16 UTC settlement windows. A +0.05% per 8h rate translates to roughly 54.75% annualized cost to the payer. Since most 15-min positions won’t span a settlement point, record “signal direction vs. funding sign” to avoid holding longs across a highly positive funding window. Cube Exchange Bimal Institute
• Mark-price liquidation: liquidation is triggered by the mark price (which embeds the funding-rate basis), not the last trade price. Funding payments continuously erode margin and pull the liquidation price toward the current price. Backtests that ignore mark-price rules simultaneously undercount “wick liquidations” and overcount “mark-price protection.” Cube Exchange
• Extreme funding rates are reverse signals: in 2024, BTC aggregate funding was negative on only 26 days of the year—a persistently positive rate does not imply an imminent reversal, but historically, extreme rates above 0.1% per 8h preceded 10–30% drawdowns (the latter is the source’s view, stated as such). Cube Exchange Bimal Institute

3. Tech Stack Selection (Tested in 2025–2026)

I tested each framework’s maintenance status live via the GitHub API (as of 2026-09-04), and the conclusion is clear.

3.1 Language: Python, no debate

Freqtrade, Hummingbot, Jesse, OctoBot, vectorbt, vn.py—all Python; the pandas/NumPy ecosystem is immediately available. TypeScript is the source language for CCXT and updates fastest, but the quantitative backtesting ecosystem is far weaker than Python’s. Rust (the NautilusTrader kernel) belongs to latency-sensitive scenarios—irrelevant for an $880 account. CCXT GitHub NautilusTrader GitHub

CCXT is the de facto industry standard: TypeScript source transpiled to 7 languages, covering 104 exchanges, unifying REST + WebSocket APIs, with a built-in rate limiter and a uniform exception hierarchy. Custom execution layer = Python + ccxt (asyncio). CCXT GitHub

3.2 Frameworks: phased composition, not a single pick

3.3 Exchange and Account Security

• Fee primary-source data: Bybit futures VIP0 taker 0.055% / maker 0.020% (the only exchange whose fee schedule I pulled directly this round; Binance/OKX pages were behind anti-scraping blocks—use your account’s actual rates in practice). Bybit Trading Fee Structure
• OKX officially confirms a spot/futures grid bot (Futures Grid). OKX Trading Bots
• API key least-privilege: contract trade permissions only + IP whitelist + withdrawals disabled; isolate each bot under a separate sub-account. This is Freqtrade’s official security guidance. Freqtrade Exchange Notes
• Simulated trading first: Binance futures testnet (supported by Hummingbot), Bybit demo mode (supported by Freqtrade). Only go live after the dry run passes.

3.4 24/7 Operations

Barriers to entry are low: Freqtrade needs a minimum of 2 GB RAM / 2 vCPUs—a 2C2G overseas VPS suffices (avoid Binance-restricted regions). Docker deployment + systemd/tmux daemon + NTP clock sync (mandatory; clock drift breaks exchange signatures) + Telegram alerts (Freqtrade ships built-in /status /profit /forceexit commands). Freqtrade Installation Freqtrade GitHub

4. Where to Find Real Alpha (and Realistic Expectations)

4.1 The practical way to “scan the internet for strategies”

Not by reading every TradingView script. Instead, structure the search: Quantpedia curates 1000+ strategies, 2000+ papers, and 800+ out-of-sample backtests, filterable by asset class / rebalance frequency / in- vs. out-of-sample performance, then batch-reproduced through a unified engine. Quantpedia Screener GitHub hosts open-source funding-rate arbitrage implementations (e.g., aoki-h-jp/funding-rate-arbitrage). TradingView community scripts are fine for signal inspiration; they’re not production-ready.

4.2 Verified alpha categories in crypto (ranked by retail feasibility)

1. Funding-rate / basis arbitrage: structurally deterministic. Academic research confirms crypto basis deviations exceed traditional FX, but they converge over time—arbitrage is becoming crowded. Fundamentals of Perpetual Futures (arXiv:2212.06888)
2. On-chain flow signals: ETH net inflows have 1–6 hour intraday predictive power over returns and volatility, and the pattern is significantly different from BTC. Return and Volatility Forecasting Using On-Chain Flows (arXiv:2411.06327)
3. Momentum / cross-sectional momentum: the 150+ anomalies documented in academia concentrate almost entirely in illiquid small-cap stocks and exclude costs; they decay sharply after publication—the same holds for crypto micro-caps. “Paper backtest ≠ after-costs deliverable.” Market anomaly — Wikipedia
4. Market making: retail is constrained by latency and inventory management; only low-frequency quote provision is viable, with tiny capacity. Deep RL in Cryptocurrency Market Making (arXiv:1911.08647)

Counterexample warning: the on-chain fundamental metric TVL, once broadly trusted, was found to be “surprisingly irrelevant” to coin returns—no independent alpha. The Surprising Irrelevance of TVL (arXiv:2506.03287)

4.3 The research pipeline (with traps flagged at every step)

1
2

Hypothesis → Data (CCXT / Tardis tick-level) → Vectorized backtest → Walk-forward OOS
     → Dry-run for weeks → Small-capital live → Scale up

• Overfitting defenses: cap parameter-search iterations, fix the OOS window, log the number of attempts into the backtest report (MinervaScore philosophy); pick the “plateau” on the parameter heatmap, not the sharp peak.
• Look-ahead bias: run Freqtrade’s lookahead-analysis first to catch peeking before anything else.
• Portfolio level: crypto daily returns are ~60% correlated pairwise—multi-coin is not diversification; multi-strategy logic is (funding arb vs. trend vs. mean-reversion). Correlation without Factors (arXiv:2412.04263)

Realistic expectations: most strategies will fail; a few low-capacity edge strategies squeeze marginal profits; alpha comes mainly from structural premiums (funding, basis, liquidity provision), not from prediction skill. Under rigorous academic OOS protocols, the better result sits at 44.55% annualized / Sharpe 1.55—that’s an upper-bound reference, not a retail baseline. From Hypotheses to Factors (arXiv:2604.26747) Shift the target from “predict direction” to “harvest structural premiums,” and your survival probability jumps an order of magnitude.

5. LynxCrypto: The Development Prompt to Hand to AI

The prompt below is my next construction blueprint—feed it to an AI coding agent (Claude Code / Kimi Code) and build the quantitative system from scratch.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# LynxCrypto — Personal Crypto Quantitative Trading System: Development Prompt

## Role and Objective

You are a senior quantitative trading engineer. Design and implement from scratch a personal crypto quantitative trading system named **LynxCrypto**.
The core goal is not "predicting price direction" but: **harvesting structural premiums in the crypto market (grid-volatility capture + funding rates + range mean-reversion) under strict risk controls, and continuously incubating new strategies at the research stage**.

Hard constraints (non-negotiable):
- Starting capital ~880 USDT; every strategy must pass the tri-gate of backtest + walk-forward + dry-run before going live.
- System-level circuit breaker supersedes all strategy logic: if daily total loss hits 3% of account equity or a single strategy drawdown reaches 15%, immediately flatten all positions in that strategy, pause for 24 hours, and fire a Telegram alert.
- **Martingale / any form of loss-averaging is forbidden** (compounding multiplier must always equal 1); only fixed lot sizes or anti-Martingale (profit-confirmed scaling requires an independent risk-approval function) are allowed.
- Leverage cap: 3x for general strategies, 2x for grid strategies.

## Tech Stack (Research-finalized, do not change)

- Language: Python 3.11+ (strategy, backtest, and execution end-to-end)
- Exchange connectivity: CCXT (asyncio); initially connect to one exchange only (Binance USDT-perpetual + spot); abstract the interface layer for later OKX/Bybit expansion
- Backtesting: vectorbt (parameter sweep + walk-forward + range_split multi-sample OOS)
- Live engine: implement and make swappable between (a) Freqtrade strategy-plugin form (for trend/signal strategies) and (b) a custom lightweight executor (for grid strategies when hedge-mode two-way positions are required)
- Persistence: SQLite (orders, fills, equity curve, signal logs); schema versioned with code
- Configuration: YAML + Pydantic validation; API keys via environment variables, never written to disk or database
- Alerts: Telegram Bot (open/close positions, circuit-breaker events, daily equity report)
- Deployment: Docker Compose, systemd restart policy, in-container NTP-sync check (startup self-test item)

## System Architecture (module boundaries must be clear, independently testable)

1. `data/` — Market-data layer: pull 1m/15m/1h/4h candles + funding rates + mark prices via CCXT, persist as Parquet; incremental updates; data-quality checks (gaps, duplicates, anomalous jumps).
2. `features/` — Indicators and features: ATR, ADX, EMA slope, Keltner channel (EMA20 ± 2×ATR10), rolling-range quantiles, funding-rate sign and time-to-settlement. All vectorized; no look-ahead allowed; every indicator ships with a unit test (known-input hand-calculated output check).
3. `regime/` — Market-regime classifier: ADX<20 = ranging / ADX>25 = trending / intermediate = grey zone; layered with 1H/4H EMA direction filter. Output a unified Regime enum for strategies to consume.
4. `strategies/` — Strategy plugins (unified interface: on_bar → Signal | None; each strategy owns its parameter schema, defaults, and failure conditions):
   - `grid_neutral.py`: equal-lot futures grid, ATR-dynamic spacing `spacing = clamp(ATR% × 0.6, 1%, 4%)`; if drift exceeds 7%, re-center; if price breaks the band, treat as a circuit-breaker event, not a chase.
   - `range_reversion_15m.py`: 15-min range strategy—enabled only when regime = ranging; entry = price touches Keltner upper/lower band (fade); exit = middle band or time stop (N bars to target not reached); catastrophe stop placed 1×ATR outside the channel.
   - `breakout_15m.py`: enabled only when regime = trending; entry = prev_close ± k×ATR breakout with multi-timeframe alignment; **stop-and-reverse is forbidden**—after a close, a full signal reconfirmation is required before re-entry.
   - `funding_carry.py` (phase 2): skeleton for funding-rate arbitrage when rates are elevated; paper-only for now.
5. `risk/` — Risk-control hub (strategies cannot bypass): position limits, leverage caps, circuit breakers (daily loss / drawdown two-tier), funding-rate settlement checks (expected cost counted when a position spans a 00/08/16 UTC settlement window), consecutive-loss counter (3-loss streak in a single strategy auto-cuts position by 50%).
6. `backtest/` — Backtest pipeline: fees at maker 0.02% / taker 0.055% round-trip; slippage default 0.02%; funding simulated at 8h settlements; liquidation modeled via mark-price rules; output report must include: number of attempts, parameter heatmap, walk-forward分段 performance, in- vs. out-of-sample comparison, max drawdown, probability of ruin (Monte-Carlo bootstrap resampling).
7. `live/` — Live executor: WebSocket market data + REST order placement; reconnect on disconnect; order-state reconciliation (local orders vs. exchange openOrders every minute); API-exception-classified retries (NetworkError = retryable / AuthenticationError = immediate halt + alert).
8. `ops/` — Daily equity snapshot, weekly report generation, strategy-performance attribution (P&L decomposed by strategy / regime / time-of-day).

## Development Milestones (each delivers runnable code + tests)

- M1: data + features + unit tests; able to pull and persist ZECUSDT historical data.
- M2: backtest pipeline + first backtest report for `range_reversion_15m` (with all anti-overfit outputs).
- M3: regime classifier + `breakout_15m`; walk-forward comparison report for both strategies.
- M4: risk hub + refactored `grid_neutral` (equal lots + ATR spacing + circuit breaker).
- M5: live executor in dry-run mode; run for 2 full weeks with zero reconciliation errors before enabling the live switch.
- M6: live switch (with `--i-know-what-im-doing` confirmation flag), Telegram alerts, daily report.

## Acceptance Criteria

- Every