Process & Discipline

A Pre-Live Checklist for Deploying Deriv Bots

· 7 min read

Moving a Deriv bot from backtest to live trading is not a single decision but a sequence of gates, each with explicit pass criteria and a documented abort path. This article describes a staged verification procedure — recorded dry run, small-size canary, and controlled scale-up — with the arithmetic for sizing and the conditions that force a rollback. The goal is not to prove a strategy will be profitable; it is to prove that the implementation behaves as specified, that the risk limits actually fire, and that the operator can stop the bot under pressure.

Trading involves significant risk and you can lose your entire stake. Test every strategy on a demo account first.

Stage 0: Written Rules and a Backtest Filter

Before any demo run, write the rules down: contract type, market, stake, duration, entry and exit logic, session limits, and the maximum acceptable loss. The ORSTAC premises require the maximum loss to be defined before the expected gain, and per-contract risk capped at 1% of balance (ceiling 2%). On fixed-stake contracts such as Rise/Fall and Digits, the stake is the maximum loss, so the 1% rule is a stake cap, not a stop-loss setting. Stop loss and take profit by price exist only for Multipliers; for fixed-stake contracts, risk is controlled by stake, duration and session limits.

The backtest is a filter, not proof. Use a large sample, hold out an out-of-sample period, and record how many configurations you tried — a strategy selected from many variants is partly a product of selection, and the report should say so. Judge results by expectancy, break-even rate and drawdown, not win rate alone. Win rate without the payout is meaningless: on a Rise/Fall contract paying 95% profit on a win, the break-even win rate is 1 / (1 + 0.95) = 0.5128, i.e. 51.28%. A bot winning 55% of contracts has a positive gross expectancy per unit staked of (0.55 × 0.95) − (0.45 × 1) = 0.5225 − 0.45 = 0.0725, or 7.25% of stake per contract before fees and slippage assumptions; a bot winning 50% has (0.50 × 0.95) − (0.50 × 1) = −0.025, a loss of 2.5% of stake per contract. Both figures are illustrative examples computed from the stated payout assumption, not predictions.

If the strategy uses any stake progression — and ORSTAC recommends against martingale, which many community bots still use — the progression needs a hard cap on steps and stake, plus a ruin test before going live. The risk is structural: doubling after each loss means the stake, and therefore the maximum loss per contract, grows geometrically while the balance does not.

Stage 1: Recorded Demo Run (Dry Run)

Run the bot on a Deriv demo account with the exact configuration intended for live: same stake logic, same limits, same market. “Dry run” here means demo execution, not a simulator — it exercises the real API path, order placement, and the bot’s own limit logic. Demo trading removes financial risk but not behavioural or execution differences: fills, latency, and the operator’s own reactions to a losing sequence are not the same as in a simulator, and they are not the same as live either.

During this stage, verify that the hard, automatic limits in the bot actually fire: daily loss, maximum drawdown, and consecutive-loss cutoff. The bot must stop by itself, without operator intervention. Record the demo sample — duration, number of contracts, stake sizes, outcomes, and every limit event — because the transition to real money requires a recorded demo sample and minimum stake.

A minimal DBot rule set for the limit logic looks like this:

  1. On start, read balance and set daily loss limit = 1% of starting balance.
  2. Before each purchase, check cumulative session loss against the daily limit; if breached, stop the bot.
  3. Track consecutive losses; at the configured count, stop the bot.
  4. Track peak balance; if drawdown from peak exceeds the configured maximum, stop the bot.
  5. Log every purchase, result, and stop event with a timestamp.

Keep the block logic minimal and auditable. A bot whose stop conditions cannot be read in under a minute is a bot whose stop conditions will not be trusted in a drawdown.

Stage 2: Small-Size Canary

The canary stage uses real money at the minimum stake, with the same limits as the demo run. Its purpose is to confirm that live execution matches the demo sample in the dimensions you can observe: order acceptance, contract durations, and limit behaviour. It is not a profitability test; the sample is far too small to distinguish skill from variance.

Worked example. Suppose a balance of 500 USD. The 1% per-contract cap is 0.01 × 500 = 5 USD, so the maximum stake per contract is 5 USD; the 2% ceiling would be 10 USD but is not used at this stage. Set the daily loss limit at 2% of balance: 0.02 × 500 = 10 USD. Set the maximum drawdown limit at 5%: 0.05 × 500 = 25 USD. Run the canary for 100 contracts at 1 USD stake. The worst case if every contract loses is 100 × 1 = 100 USD, which exceeds the daily loss limit of 10 USD — so the daily limit must stop the bot after 10 consecutive losses at 1 USD, not after 100. This is the point of the exercise: the limit, not the stake size, is what bounds the session. If the bot does not stop at 10 USD of session loss, the canary has failed regardless of its profit and loss.

Pass criteria for the canary are behavioural, not financial: limits fire at the specified thresholds, no orders are rejected for configuration reasons, and the operator can stop the bot manually and confirm it is flat. If any criterion fails, return to Stage 1; do not adjust limits mid-canary.

Stage 3: Controlled Scale-Up and Rollback Criteria

Scale-up is incremental and conditional. Increase stake only after a recorded live sample at the current size, and only within the 1% cap. Write the rollback criteria before scaling, not after a loss — rules are written before trading, and changes follow a process of hypothesis, test, and version, never an immediate reaction to a loss.

A workable rollback rule set:

  • Limit breach: any session in which a hard limit fires is reviewed before the next run; two limit breaches in the same version trigger rollback to the previous version.
  • Behavioural divergence: if live limit behaviour differs from the recorded demo sample (for example, the bot does not stop at the configured loss), stop and roll back immediately.
  • Drawdown threshold: if drawdown from peak exceeds the pre-written maximum, the bot stops and the version is retired pending review.
  • Version discipline: every change gets a new version number and a new demo sample; no silent edits to a live bot.

Rollback means restoring the last verified version and configuration, not tuning parameters until the losses reverse. If the strategy’s expectancy is negative, no amount of scaling fixes it.

Limitations

This procedure verifies implementation and discipline; it does not validate the strategy’s edge. A bot can pass every gate and still lose money, because past results do not predict future results. The demo sample is not live execution: latency, order handling, and the operator’s behaviour differ, and the canary is too small to separate edge from variance. The procedure does not model platform-side changes to contract specifications or payouts, and it does not protect against errors in the written rules themselves. It also does not make a martingale progression safe; a hard cap limits the damage but does not remove the ruin risk, which is why ORSTAC recommends against it.

Frequently Asked Questions

Does a demo run prove the bot is ready for live trading? No — a demo run proves the implementation and limits behave as specified, but it removes financial risk without reproducing live execution or behavioural differences, so it is one gate, not the final one.

How large should the canary sample be? Large enough to observe the limit logic fire at least once under controlled conditions, which is a behavioural criterion rather than a statistical one; the sample is too small to establish profitability.

What should trigger an immediate rollback? Any divergence between live and recorded demo limit behaviour, or any hard-limit breach that the bot fails to enforce, triggers an immediate stop and rollback to the last verified version.

Key Takeaways

  • Stage the transition: written rules and backtest filter, recorded demo run, minimum-stake canary, then controlled scale-up.
  • On fixed-stake contracts the stake is the maximum loss; cap it at 1% of balance (ceiling 2%) and let session limits bound the day.
  • Verify that the bot’s automatic limits fire before trusting any result; a bot that does not stop itself has failed the gate.
  • Write rollback criteria before scaling, and treat every change as a new version with a new demo sample.
  • Demo trading removes financial risk but not behavioural or execution differences; it is a gate, not proof.

The full procedure, including limit templates and versioning conventions, is maintained in the ORSTAC repository for open-source bots. The bots run on Deriv, where a free demo account is available to test them; the Deriv API documentation and the official Deriv API libraries cover the execution details, and Deriv Bot is the visual builder for DBot strategies. For discussion of the procedure and the bots, join the ORSTAC Telegram group.

Trading involves significant risk and you can lose your entire stake. Test every strategy on a demo account first.