Precious Lyna Anusiem

Posted on Apr 21

Automating Trades on Deriv Without Writing a Single Line of Code

Before you scroll past — this isn't about algorithmic trading requiring a Bloomberg terminal and a computer science degree. This is about a free, browser-based tool that Deriv (one of the world's largest online trading platforms, 3M+ users) gives every account holder, and that almost nobody actually uses.

It's called DBot. And once it clicked for me, I couldn't believe I'd been clicking trades manually for months.

Quick context: what even is Deriv?

Deriv is a regulated online trading platform that offers binary options, multipliers, accumulators, and a category of instruments called Synthetic Indices — simulated assets that run 24/7 including weekends, modelled on real market volatility without being tied to actual underlying assets.

The Synthetic Indices part is relevant because they're what make DBot practical for most beginners. You're not fighting forex news events at 2am. The market just... runs. Constantly. Which means your bot can too.

So what is DBot exactly?

DBot is Deriv's visual, drag-and-drop strategy builder. Think Blockly (the open-source visual programming tool — because it's literally built on top of Blockly). You construct trading logic by connecting blocks that represent actions, conditions, and data.

No IDE. No dependencies. No environment setup. Just blocks.

Here's what the core execution structure looks like conceptually:

[Initialization]
  set stake = 1.00
  set loss_count = 0

[Loop]
  check_stop_conditions()
  → if conditions met: stop()
  → else: execute_trade()

[On Win]
  reset_stake()
  reset_loss_count()
  loop()

[On Loss]  
  increment_loss_count()
  update_stake()  // e.g., multiply by 2.2 for Martingale
  loop()

That's the mental model. Everything else — conditions, tick analysis, variable management — is detail layered on top of this loop.

The blocks that matter

DBot has a lot of block categories. Here's the honest breakdown of what beginners actually need:

Trade Definition — Defines the instrument (market, contract type, duration, stake). The skeleton every bot is built on.

Purchase — Executes a trade. Dead simple, but it must be connected correctly inside your result handlers or nothing happens.

On Finish — Two versions: On Win and On Loss. These are event handlers that fire after each trade resolves. All your strategy logic lives in here.

Logic / If-Else — Your conditionals. "If total profit >= 5, stop. Else, purchase." Straightforward.

Math — Arithmetic blocks. Multiply stake by 2.2, add 0.50, subtract 1.00. Used for stake progression calculations.

Variables — Named storage. Create variables for things like current_stake, consecutive_losses, session_profit. Initialize them at bot start. Read and write them throughout.

Tick Analysis — Read market data. Last tick price, last digit (0–9), whether last n ticks were rising or falling. This is how you build condition-based entries instead of blind-firing every tick.

Building the loop correctly

The most common beginner mistake is building a bot that executes one trade and stops. It looks right — Trade Definition block, Purchase block, done. But that bot doesn't loop. You press Run, one trade executes, and then silence.

The correct pattern:

Run Once at Start
└── Purchase(initial_stake)

On Finish (Win)
├── Reset stake and loss count
├── IF stop condition met → Stop Bot
└── ELSE → Purchase(current_stake)

On Finish (Loss)
├── Increment loss count
├── Update stake
├── IF stop condition met → Stop Bot
└── ELSE → Purchase(current_stake)

The Purchase blocks inside On Finish are what create the loop. Each trade result triggers the handler, the handler evaluates conditions, and then either stops or buys again.

Every Purchase must be preceded by stop condition checks. If you forget this, the bot runs until one of three things happens: your account empties, the browser crashes, or you manually hit Stop. None of these are the conditions you want controlling your session.

Stop conditions — the part everyone treats as optional

They're not optional. Here's the template I use before every Purchase call:

IF (total_profit >= take_profit_target
    OR total_profit <= stop_loss_limit
    OR consecutive_losses >= max_streak
    OR current_stake > max_stake_cap)
THEN
    Stop Bot
ELSE
    Purchase(current_stake)

Four conditions. Each one independently capable of saving your session. Together they form a circuit breaker that no losing streak can bypass.

Set these values before you run. Not during. Not after three losses when your judgment is compromised. Before.

Martingale — the honest explanation

Martingale is the most talked-about DBot strategy and also the most misunderstood.

The mechanic: after each loss, multiply your stake by approximately 2.2. The first win recovers all previous losses plus a small profit. On win, reset to initial stake.

The math works cleanly in theory. In practice, the failure mode is consecutive losses. Here's what happens at a starting stake of $1 with a 2.2 multiplier:

Trade 1: $1.00 stake  → Loss → Running total lost: $1.00
Trade 2: $2.20 stake  → Loss → Running total lost: $3.20
Trade 3: $4.84 stake  → Loss → Running total lost: $8.04
Trade 4: $10.65 stake → Loss → Running total lost: $18.69
Trade 5: $23.43 stake → Loss → Running total lost: $42.12
Trade 6: $51.54 stake → WIN  → Net profit: ~$1.19

Six trades. $51 stake on trade six. ~$1.19 net profit.

Five consecutive losses is not a rare event. On Volatility 75 Index it happens regularly enough that an uncapped Martingale without a loss streak limit will blow your account in a matter of sessions.

The fix is simple: cap consecutive losses at 4 or 5. When the cap hits, stop the bot entirely. Accept the session loss. Return another day. Don't try to chase with a larger stake — that's exactly the spiral Martingale bots fall into without hard limits.

The market I'd recommend starting on

Volatility 25 Index (V25). Here's why:

Runs 24/7 — build and test any time
Lower volatility means smaller, more predictable tick movements
Less likely to trigger long loss streaks on Rise/Fall contracts vs V75
Minimum stakes work fine — you can test with $0.35 per trade
The 5-tick contract duration gives enough time for movement without excessive exposure

Once you understand your bot's behaviour on V25, you can migrate to faster or more volatile instruments if your strategy warrants it. Start where the risk is lowest.

Testing before you go live

DBot doesn't have a native historical backtester. Testing means running on Demo, and running enough trades to see your strategy across different market conditions — not just cherry-picked favourable ones.

My minimum: 500 Demo trades before any live consideration. 200 is not enough. You'll hit a favourable patch of 200 trades that makes any strategy look profitable.

Things to track during Demo testing:

Win rate % — for Rise/Fall on V25, expect 48–52% on a strategy with no conditions
Maximum consecutive losses — what's the worst streak you observed?
Maximum drawdown — what's the largest drop in account balance from peak?
Stop loss trigger frequency — how often does your daily stop loss activate?
Session consistency — do 10 consecutive sessions all end in similar ranges?

If your bot can't produce consistent Demo results over 500+ trades, it won't produce consistent live results either. No amount of "maybe it'll be different with real money" makes that math work out.

What this actually looks like in production

A well-configured bot session on V25 with a $100 Demo account might look like:

Starting stake: $0.50
Target: +$5 for the session, then stop
Hard stop: -$10 for the session, then stop
Max consecutive losses before stopping: 4
Max single stake: $10

At those parameters, the bot typically reaches its take profit target before the stop loss on sessions with average variance. When stop loss triggers, it's a contained loss. No single session can cause a cascading wipeout.

That's the goal. Not maximum profit. Consistent, contained, repeatable sessions.

Where to learn more / go deeper

I put together a complete walkthrough guide — 9 chapters covering DBot from account setup through live deployment, including block-by-block build instructions, five strategy templates, Martingale configured safely, risk management tables by account size, and a troubleshooting reference.

If you're building on Deriv and want a proper foundation rather than piecing it together from forum posts: https://anusiempreciouso.gumroad.com/l/deriv-bot-guide

It's aimed at beginners but detailed enough that intermediate traders have found the strategy templates and risk frameworks useful.

Questions? Drop them in the comments. Happy to dig into specific block configurations, strategy mechanics, or anything else DBot-related.

Standard disclaimer: trading involves risk, this is not financial advice, always use Demo before real funds, etc. — but also: actually read the risk warnings in that guide. The Martingale section in particular.