Recently I came across an interesting article on X.

The author describes how, over the years, he slowly got a "flywheel" spinning: three wheels — cash flow, core assets, and Alpha — that feed back into one another. Strip it all the way down and it really comes to one sentence: first find a way to survive, survive long enough, and only then talk about compounding.

The whole thing was built through hands-on manual practice, relying on personal experience and a feel for the market. But after reading it, one thought surfaced: at bottom, this is a set of disciplines — and discipline is precisely the thing humans are most likely to break and programs are most likely to keep. From a quant perspective, can it be reproduced?

The approach to reproducing it isn't to invent some new strategy from scratch, but to rummage through what we already have: several ready-made things we've built and run before — a DCA strategy, a position-rolling strategy, a coin-selection engine (harness). Which one's natural behavior happens to be exactly the behavior a given wheel requires? Where it lines up, drop it in, and then string them together into a closed loop with capital flows.

The focus of this piece is to make clear why these three were chosen, what the logic of each is, and how it maps onto its wheel.

Wheel 2: Core Assets ← DCA Strategy

What the concept requires

The original article positions core assets as: used for compounding, being a friend of time, never forced to sell even in extreme markets. They are not for "trading" — they are for "holding and waiting." The implied action is just one: keep buying, never actively sell.

What DCA is

DCA stands for Dollar Cost Averaging. The logic is extremely simple: at a fixed interval (say every 7 days), regardless of the current price level, buy a fixed dollar amount of the asset.

Its real power shows when the market falls: with the same $200, you buy more shares when the price is low and fewer when it's high, and over the long run your cost is naturally averaged down to a reasonable level. No need to judge tops and bottoms, no need to time the market — just keep executing.

More importantly, DCA by design has no active-sell action — it naturally only buys, and once bought, holds. This makes it essentially a machine that only takes in, never lets out, accumulating slowly.

Why this one: behavioral equivalence

"Being a friend of time," translated into instructions a machine can execute, is "buy on schedule, never sell." That is behaviorally equivalent to everything left over after you delete the sell logic from DCA. No extra design needed — just remove the take-profit/sell function from a normal DCA, and it becomes the implementation of the core-assets wheel.

Corresponding code:

            javascript
            
            
// Every N days, buy a fixed amount of the core asset, buy only, never sell
if (now - lastDca >= DcaIntervalDays * 86400000) {
    var amount = sizeByCash(CoreSymbol, DcaAmount, CoreLeverage, price);
    marketOrder(CoreSymbol, "buy", amount);
    coreInvested += DcaAmount; // record cumulative cost; the corresponding subtraction never appears
}

Nowhere in the entire strategy is there any logic to sell the core asset — this is deliberate, and it corresponds to "never forced to sell even in extreme markets."

Wheel 1: Cash Flow ← Reserve-Floor Mechanism

What the concept requires

The original article puts cash flow first, but its significance isn't to get rich — it's to "keep you from being forced off the train at exactly the moment you should be getting on." Put bluntly: with steady cash flow coming in, even if the market crashes and your account shrinks dramatically on paper, you don't need to sell assets to sustain your living — you tough it out and wait for compounding to happen.

This is the prerequisite for the whole system to function. Without this safeguard, no matter how well you pick your core assets, being forced to cut them in a big drawdown makes it all for nothing.

How to make it equivalent in quant

Cash flow is essentially something outside the account — salary, side income, IPO/airdrop proceeds. Code can't conjure income out of thin air.

But code can reproduce its core effect: never being forced to sell the core asset. The method is to set a reserve floor in the account — always keep a certain proportion of buffer capital that no order is allowed to touch. The DCA cadence itself, plus this floor, simulates the state of "cash flow keeps coming in and never gets cut off."

In live trading, how comfortably stocked this floor stays actually depends on whether your real external cash flow is stable. This is also the most indirect of the three reproductions — we reproduce its effect, not the thing itself.

            javascript
            
            
// Before each order, check: balance after this order's amount can't fall below the reserve floor
var reserve = equity * ReserveFloorRatio; // e.g. keep 10% of equity
if (balance - DcaAmount < reserve) return; // hit the line, skip — hold the last buffer

Wheel 3: Alpha ← Coin-Selection Engine + Position-Rolling Strategy

The Alpha wheel is the most complex; it needs to be split in two: where the targets come from, and how to trade them once you have them. These two things map to two separate strategies.

What the concept requires

The original article says Alpha's significance is "to trade tiny cost for huge upside," and emphasizes: the money you make can't be spent — it all has to be funneled into the core assets to amplify the principal.

Two keywords: "tiny cost" — meaning the loss cap on every single trade must be sealed shut, so one mistake can't break your bones; "huge upside" — meaning once you're right, let the profit run as far as possible rather than bailing on a small gain. This is a naturally asymmetric structure: small loss in the bad case, large gain in the good case.

Top half: Coin-selection engine (harness) — find the right targets

The crypto market has hundreds to thousands of perpetual contract instruments. Picking one at random and applying a strategy will most likely waste time or even lose money. The coin-selection engine solves exactly the question of "which coins should I trade on."

Layer 1 — Volume filter

Sort all USDT perpetual contracts in descending order by dollar volume (price × volume) and keep the top 120.

Why use volume as the first screen? Coins with large volume have two benefits: one, liquidity is sufficient, so orders won't get eaten up by a wide bid-ask spread; two, there are enough participants in the game, making it easier for capturable trends to form. With low-volume altcoins, the price is easily manipulated, and even the best strategy run on them is useless.

Layer 2 — Moving-average backtest scoring

For each shortlisted coin, run historical backtests with several moving-average parameter combinations (e.g. MA5/20, MA10/30, MA20/60), and compute the core metrics for each parameter set: win rate (share of profitable trades), profit/loss ratio (average win / average loss), max drawdown, and number of signals. Then weight the results into a composite score.

This step is to find out whether the MA strategy has historically actually worked on this coin. Not every coin has a clear trend — some chop sideways for long stretches, and the MA signals are all false breakouts. Kick those coins out early and don't waste bullets on them.

Layer 3 — Breakout-potential bonus

Add two dynamic factors into the score:

• Volatility percentile: where the current ATR (Average True Range, a measure of price volatility) sits in the percentile of its historical data. The closer to the high end, the larger current volatility is relative to history, and the more likely a big move is.
• Volume-surge coefficient: the average volume of the last 5 candles ÷ the average volume of the last 50 candles. If this value is clearly greater than 1, recent volume is abnormally elevated relative to the past, capital may be flowing in, and it's an early signal of a "potential breakout."

These two factors stacked together are meant to lean, beyond static historical performance, toward targets that are "currently showing unusual activity."

The final output is a whitelist, usually the 3 to 5 coins with the highest composite scores in the current phase.

            javascript
            
            
// Coin-selection engine: volume filter → backtest scoring → breakout factors → whitelist
var pool = tickers
    .filter(t => t.Symbol.endsWith("USDT.swap"))
    .sort(byQuoteVolumeDesc)
    .slice(0, TopVolumeN);

for (var coin of pool) {
    var volPct = calcVolPct(records);            // volatility historical percentile
    var surge = calcVolumeSurge(records);        // recent volume-surge coefficient
    var bt = bestBacktestScore(records, maParamsList); // MA backtest composite score
    var score = bt * 0.56 + volPct * VolSurgeBonus + surge * VolSurgeBonus;
    if (score >= threshold) whitelist.push(coin);
}

Bottom half: Position-rolling strategy — leverage small into big

With a whitelist in hand, you still need a trading method. Here we use the position-rolling strategy we wrote before; its mechanics fit Alpha's asymmetry requirement closely.

What the position-rolling strategy is

It's a futures trend-following strategy based on moving-average crossover signals.

First, understand moving averages: take a weighted average of the closing prices of the past N candles and you get the EMA (Exponential Moving Average). The EMA gives more weight to recent prices, so it reacts faster than a plain moving average. The crossover signal works like this: a short-period EMA (e.g. EMA5) crossing up through a long-period EMA (e.g. EMA10) is a "golden cross," meaning the short-term uptrend is stronger than the long-term — a long signal; the reverse is a "death cross," a short signal.

"Rolling the position" means: after each take-profit, if the MA direction still holds (i.e. the trend is still there), immediately re-enter and keep holding with the trend. In a strong trend, this method compounds profit round after round, rather than grabbing one move and leaving.

Every trade has a hard stop: if the price moves against you beyond a set amount (e.g. -8%), it force-closes. This stop caps the maximum loss on every single trade — no matter how bad the market gets, a single-trade loss won't exceed this number. This is the source of the "tiny cost" mechanism.

Why this one: matching the asymmetric structure

Alpha requires "cost tiny and capped + profit as large as possible" — an asymmetric payoff structure. The position-rolling strategy naturally has this structure:

• Hard stop = the "ticket price" of each bet; if you lose, this is the most you lose, no more.
• Trailing take-profit + rolling re-entry = if you're right, let the profit run with the trend, with no fixed cap in theory.

The two are the same thing stated differently in structure. The specific code:

            javascript
            
            
// Cost cap: hit the hard stop and exit immediately — this is the ticket-price ceiling for each bet
if (pnlPct <= -AlphaStopPct) close("hard stop");

// Let profit run: the higher the peak, the more giveback room allowed — give big winners room to breathe
var giveback = Math.max(15, maxPnl * 0.3);
if (maxPnl - pnlPct >= giveback) close("trailing take-profit");

// After take-profit, if the trend still holds, roll the position and keep holding — compound the profit
if (shouldRoll(records, direction)) openAlpha(direction, price);

Organic integration: feeding Alpha's profit back into core

The coin-selection engine finds targets, the position-rolling strategy generates returns — but that's not enough. Back to the original article: Alpha's real value is "to funnel principal to the core assets." So there must be a capital line: the money Alpha makes buys back core assets one-way; when it loses, it absolutely does not reach back and touch the core principal.

            javascript
            
            
// Once Alpha's realized profit accumulates to a certain amount, buy back core assets
if (alphaPnlBank >= AlphaSweepMin) {
    var amt = sizeByCash(CoreSymbol, alphaPnlBank, 1, price);
    marketOrder(CoreSymbol, "buy", amt); // profit flows to core, enlarging the principal base
    coreInvested += alphaPnlBank;
    alphaPnlBank = 0;
}

It's precisely this line that turns three independent old strategies from "each running on its own" into "one wheel that feeds itself": DCA keeps feeding the core, the coin-selection engine picks candidates, the position-rolling strategy leverages small into big, the profit feeds back into the core, the core grows larger and larger, and the multiples required later get smaller and smaller.

What quant actually does here

To sum it up in one sentence: the value of reproducing it isn't being "smarter," it's being "more disciplined."

What makes the original system hard isn't that the logic is hard to understand — it's that humans find it too hard to execute: itchy hands wanting to sell in a crash, FOMO chasing in on a big gain, wanting to quit after a small loss, being forced to cut the core assets you should have held when you suddenly need cash. These mistakes aren't from not understanding the principles — they're from emotion.

Code won't be forced to sell (the reserve floor backstops it), won't FOMO (it only acts on the whitelist and signals), won't stop the wheel (when Alpha's tiny cost is wiped out it just waits for the next trade and never touches the core). We didn't make the theory more powerful — we just handed the few most anti-human rules in it to an executor with no emotions.

This is only a shallow attempt

To be clear, this is far from the finish line, and there's one part that is clearly a different path to implementation.

The real Alpha in the original article — IPOs/airdrops, presales, early structural opportunities — leverages small into big through information and resources. Position-rolling + MA coin-selection is another form of leveraging small into big, earning returns by riding trending markets. The two paths differ, but the core logic is entirely shared. In choppy markets, this trend strategy will inevitably suffer the attrition of repeated small stop-outs; it and the native opportunities complement each other, together forming the source of Alpha returns. The truly scarce opportunities still have to be judged by a human, and after earning them, manually feed them back into the core along the same line.

Also, a good backtest doesn't mean live trading will profit. Fees, funding rates, slippage — these are easily ignored in a backtest, but in live trading they eat away at the margin bit by bit. Code holds the discipline, but it won't instinctively hit the brakes when it should be conservative.

So what to do next isn't to rush in with big capital, but to first run it long-term on a demo account and with small positions: are those wheels feeding each other, and is the Alpha part actually adding points or just busywork? Then take the real data and refine it round after round.

That line from the original article holds equally well for polishing this system — it can be slow, but it can't stop.

(The above is only a record of one line of thinking and does not constitute investment advice.)

Original link: "My Zero-to-Ten-Million Flywheel System: Cash Flow · Core Assets · Alpha"