Linear Martingale

The canonical martingale grid: level i commits i lots AND carries i take-profit targets. It is the only family member where exposure and exit granularity grow together, which is what makes it useful — a partial bounce books partial profit instead of waiting for one all-or-nothing exit.

At level i the engine opens i orders of one base lot each, and each of those orders receives its own take-profit one target step away. So the ladder is not just heavier at depth, it is more granular: level 8 can close three of its eight units on a small retrace and keep the rest working. Order count therefore grows quadratically with depth while size grows linearly.

Because level i opens i separate unit orders, each carrying its own take-profit, order count grows quadratically with depth while size grows linearly. At 10 levels this ladder rests 55 entry orders. Check the venue's open-order limit before configuring depth.

Below is the wizard's own ladder table and the trading terminal's chart engine, both driven by buildLadderPlan for this mode. Change the level count, spread or target and the rung prices, sizes, capital ramp and chart lines recompute exactly as they would in the grid designer.

Cost is the triangular number of the depth, so it accelerates quietly — the step from 10 to 20 levels is far larger than the step from 5 to 10. Because the curve is polynomial rather than exponential, it stays fundable at moderate depth, which is why it is the most commonly deployed martingale variant.

Read the cost vs 5 levels column as the escalation test. A flat ladder doubles when the depth doubles; anything materially above that is a curve whose coverage has to be bought rather than simply configured.

With every rung filled, the volume-weighted average entry is 92.14 against a base of 100 and a deepest rung of 90.00 — so the average sits 79% of the way down the covered range. Getting back to flat from the bottom therefore needs a 2.38% bounce, against 5.00% for a flat ladder of the same depth — 2.62% less work.

Size grows with depth, so most of the position — and nearly all of the risk — ends up in the deepest rungs that filled last. The average entry therefore falls faster than the price does, and a modest retrace recovers a disproportionate amount. The same property is the liability: a trend that keeps going forces the largest orders at the worst prices, and the capital requirement rises faster than the coverage it buys. Capital follows the triangular number, so ten levels cost 55× base and twenty cost 210×.

The last row is the metric that separates modes. Profit for a full cycle is the target percentage of deployed capital in every mode, so it cannot discriminate. What differs is how much capital has to sit reserved to earn one shallow cycle: this mode reserves 55.0× base to collect 1.8 bps of it when the first rung completes.

Choppy mean-reversion where price grinds down and back repeatedly rather than trending. The multi-order structure monetises exactly that texture: many small exits during the chop, without needing a full round trip to the average entry.

Level i holds i orders of base size, so it also carries i take-profit targets. Exposure grows 1×, 2×, 3×… Recovery is fast and the extra targets book profit on each bounce. Capital grows with the triangular number.

Two distinct risks, and operators usually only plan for the first. The capital ramp is the obvious one. The second is order-slot exhaustion: a 20-level ladder rests 210 entry orders and up to as many exits, which collides with venue limits long before capital does.

This is the product's grid backtester, not a summary of one. It fetches public candles for the instrument you pick, rebuilds the ladder anchored on the first candle of the window, then applies the engine's own fill, take-profit, refill and stop-loss rules bar by bar. The caveat block inside the panel is part of the output — read it before trusting a number.

First the arithmetic, then the market. The table below is computed from the size curves alone; the sweep underneath replays every one of those ladders over the same real candle window, with grid_mode as the only variable.

• Mean-reverting instruments with enough texture that partial exits actually trigger.
• You want profit-taking to begin on a partial bounce rather than only at full recovery.
• Depth is moderate (roughly 8–15 levels) and funded with real reserves.

• The venue's open-order limit is tight — level 20 alone rests 20 orders.
• Fees are charged per order rather than per notional; the order count works against you directly.
• The instrument trends persistently; the triangular ramp is a poor way to fund a trend.

• Cap the depth before you cap anything else. Coverage bought with a triangular ramp is the most expensive coverage in the catalog outside the exponential curves.
• If you want the recovery profile without the order count, use `dca_linear`: same size curve, one order per level.
• If you want the shape but a hard ceiling on per-level size, use capped linear.

• Monitor open-order count against the venue limit, not just margin. This is the mode that hits it first.
• Watch the deepest filled level, not the P&L. Depth is the leading indicator; P&L is the lagging one.
• Compare peak committed notional against the account, weekly. A growth curve that has never been deep has never been tested.
• Treat every level increase as a capital decision: adding levels to a growth curve is not a linear cost.

1. 1
   Order-slot exhaustion

   Deep levels want more orders than the venue will hold. Rejections arrive as gaps in the ladder, which quietly turns the configured curve into a different, shallower one. Check the pending-orders grid against the plan after every deep excursion.
2. 2
   Triangular surprise

   Because the curve is not exponential, operators approve depth increases mentally as "a bit more". Twenty levels cost roughly four times ten levels, not twice. The capital table in this article is the antidote.
3. 3
   Trend absorption

   In a sustained trend the largest orders fill at the worst prices and no exits complete, so the position is both maximal and unrealised. This is the scenario the stop loss exists for.

• A tight target amplifies the multi-order advantage — small retraces complete more of the stacked exits.
• Trailing plus a triangular ramp is an expensive combination: each shift re-places a heavier ladder.
• Spread sets how fast the ladder consumes depth. Widening it buys coverage for the same level count at the cost of fewer fills.
• Target sets what each cycle books. Below round-trip fees plus slippage, a grid is a fee generator regardless of the size curve.
• The stop loss is the only bound on the tail. Without it, the curve's worst case is whatever the market does, not what you planned.

1. 1
   Why does level 5 show 5 orders instead of one order of 5 lots?

   Because the engine places i unit-sized orders so each can carry its own take-profit. Five separate exits at five separate prices is the entire point of the variant; a single 5-lot order would collapse them into one.
2. 2
   How do I estimate the worst case?

   Take the ladder cost from the capital table, multiply by your grid size, divide by leverage, then assume price sits at the deepest rung. The backtest section below will show you a real instance of it.

• Sizes and capital: levelMultiplier / gridModeCurve in lib/grid/gridModes.ts, mirrored from grid_modes.hpp and the Python engine's lot calculator.
• Rung and exit prices, capital ramp, init targets and the stop line: buildLadderPlan — the same builder the wizard and grid designer use.
• Backtest fills, cycles and P&L: runBacktest / runBacktestSweep over public broker candles, applying the engine's fill, exit, refill and stop rules.
• Price charts: the trading terminal's chart engine, with the ladder drawn through its own price-line API.

• 1.Grid Modes — Overview — The full taxonomy and how to choose
• 2.Martingale family — What every curve in this family has in common
• 3.Capital Allocation — Sizing an account to a Linear Martingale ladder
• 4.Stop Loss — Bounding this curve's tail
• 5.Reading the Ladder Plan — Verifying the curve before deploying
• 6.Grid Structure — Levels, init batch and base size