Precious Lyna Anusiem

Posted on Apr 21

Building a Profitable Deriv Bot Without Writing a Single Line of Code

What I actually learned after testing 200+ trades on Volatility 25

Quick context before we get into this: I am primarily a software developer and AI engineer. I build production systems for a living. When I started exploring Deriv bots I approached it the way I approach every system — figure out the architecture first, implement second, test thoroughly before trusting it with real resources.

That approach saved me from a lot of the mistakes I see beginners make. Not all of them. But most.

This article is the technical breakdown I wish had existed when I started. It covers the architecture of a working bot, the logic behind every major decision, and how to avoid the traps that waste most beginners' time and money.

I am also going to be honest about what the win rate numbers mean and what they do not — because I think the trading content space has a serious problem with people presenting cherry-picked results as if they are guarantees.

The Architecture Problem

Most Deriv bot tutorials show you what to click. Very few explain why, or what the underlying computational model actually looks like.

Here is the model:

STATE MACHINE
├── Initial State
│   ├── current_stake    = BASE_STAKE
│   ├── total_profit     = 0
│   ├── consecutive_loss = 0
│   └── is_active        = true
│
├── Loop (while is_active == true)
│   ├── Safety Guard
│   │   ├── if profit >= TARGET → is_active = false
│   │   └── if consecutive_loss >= MAX_STREAK → is_active = false
│   │
│   ├── Signal Evaluation
│   │   ├── Fetch: last_tick, prev_tick
│   │   ├── Compute: direction (UP or DOWN)
│   │   └── Optional: RSI filter check
│   │
│   ├── Trade Execution
│   │   └── Place CALL (UP) or PUT (DOWN) on R_25, 5t duration
│   │
│   └── Result Handler
│       ├── WIN  → stake = BASE_STAKE, consecutive_loss = 0
│       └── LOSS → stake *= RECOVERY_MULT, consecutive_loss += 1
│
└── Terminal State
    └── Bot stopped (profit target or loss limit hit)

Every profitable Deriv bot I have built or analysed maps to this state machine. The differences between strategies live inside the Signal Evaluation node. The skeleton is constant.

Understanding this up front means you are not staring at a blank DBot canvas wondering where to begin. You are translating a known data structure into visual blocks.

Why V25 and 5-Tick Duration: The Actual Reasoning

I see a lot of bot content that recommends V75 or V100 because the dramatic price action looks impressive in short demo sessions. Let me explain why this is usually a mistake for systematic strategies.

Volatility in synthetic indices is controlled by Deriv's pricing engine. V25 has a 25% volatility parameter. V100 has a 100% volatility parameter. Higher volatility means larger per-tick price movements and less predictable direction.

For a tick-direction entry signal — which is what we are building here — higher volatility means more noise relative to signal. The tick comparison that gives you a meaningful 52-56% edge on V25 becomes much closer to 50% on V75 because the signal is getting drowned in randomness.

5-tick duration is chosen for similar reasons. Below 5 ticks, the contract expires before the signal has time to resolve. Above 10 ticks, holding time is long enough that mean reversion starts to work against trend-following logic.

These are not arbitrary choices. They are the result of running the same strategy across multiple markets and durations and measuring which combination produces the most stable signal-to-noise ratio.

The Entry Signal: What It Does and What It Does Not Do

The entry signal in this guide is a tick direction confirmation. Conceptually:

signal = last_tick > prev_tick ? CALL : PUT

This is the simplest possible entry signal. On its own it generates roughly 50-55% win rate on V25 — barely above chance. The reason it works at all is that Deriv's synthetic indices do exhibit short-term autocorrelation (the tendency for a tick moving in a direction to be slightly more likely to continue in that direction on the next tick). This is not a large edge, but it is measurable and consistent.

The basic signal alone is not what makes the strategy worth running. The risk management structure is what converts a slim edge into consistent profitability over time.

On the RSI filter:

Adding a simplified RSI calculation over the last 14 ticks as a second confirmation condition filters out a significant portion of entries that would be caught by tick direction but are entering into an exhausted move. In my testing this raises the win rate to 68-72% on V25.

I am not including the full RSI implementation in this article because it requires array variables, loop calculations, and conditional logic that goes beyond beginner level. I cover it in complete detail in the guide I linked at the end.

The Risk Management Mathematics

This is where I want to be precise because the numbers matter.

Base stake: 0.35% of account balance.

The choice of 0.35% is not random. I ran the loss streak probability calculations for a strategy with a 55% win rate (conservative baseline) and determined the maximum consecutive loss streak I needed to survive without breaching 20% account drawdown.

Consecutive loss probability for a 55% win rate strategy:

3 losses in a row: (0.45)^3 = 9.1% per session
4 losses in a row: (0.45)^4 = 4.1% per session
5 losses in a row: (0.45)^5 = 1.8% per session
6 losses in a row: (0.45)^6 = 0.8% per session

A 4-loss hard stop with 1.8x recovery multiplier means the worst-case sequence is:

Trade 1: 0.35  (loss)
Trade 2: 0.63  (loss)
Trade 3: 1.13  (loss)
Trade 4: 2.04  (loss — bot stops)
Total exposure: 4.15 units on 0.35 base = ~4.2% of account

That is survivable. With standard 2x martingale the same 4-loss sequence exposes 5.25 units — and if you do not have a hard stop, 6 losses exposes 22.05 units. That destroys accounts.

Why 1.8x not 2x:

2x martingale is theoretically elegant — one win recovers all previous losses exactly. In practice the growth rate of the stake sequence becomes dangerous faster than a 55-70% win rate can compensate for in bad sessions.

1.8x gives you slightly incomplete single-win recovery (you need approximately 1.1 wins to fully recover after 4 losses) but the stake sequence stays within manageable bounds significantly longer. The tradeoff is worth it.

My Live Results — The Numbers and The Context

17 wins. 7 losses. 71% win rate. 24 trades. Live account.

I want to give you both the honest positive interpretation and the honest skeptical one.

Positive: The win rate is tracking above the theoretical baseline of the strategy (which I model at 65-72% with the RSI filter). No session ended in net loss. Maximum consecutive loss streak was 3, well within the hard stop limit. The risk management worked exactly as designed.

Skeptical: 24 trades is a small sample. In any strategy with a genuine 65% win rate, you would expect the observed win rate across 24 trades to vary widely — somewhere between 45% and 85% would not be statistically surprising. I cannot prove from 24 trades that the underlying win rate is not 55% or 75%.

What I can say is that the results are consistent with the theoretical model, they were achieved on a live account, and the risk management structure ensured no individual session was damaging regardless of outcome.

I have run a much larger number of demo trades over multiple sessions. The win rate in extended demo testing sits in the 62-68% range. Live conditions introduce some variation.

Run your own 200-trade demo sequence before drawing conclusions. Treat anything less than that as preliminary data.

What the DBot Build Actually Looks Like

The guide I am linking below covers the complete build in 8 steps:

Step 1: Access DBot at app.deriv.com/dbot — confirm demo account selected

Step 2: Understand the four workspace areas before placing any blocks

Step 3: The universal bot structure — map the state machine to blocks

Step 4: Build step by step

4.1: Run-once block and variable initialisation
4.2: Main trading loop (Repeat while is_active = true)
4.3: Safety guard as first block inside loop
4.4: Entry signal — tick comparison logic
4.5: Trade placement for CALL and PUT
4.6: Result handler — win and loss branches
4.7: Wait block to prevent API rate errors

Step 5: Visual map of complete structure

Step 6: Save and export as XML backup

Step 7: Demo run — what to watch for

Step 8: Reading results — the metrics that matter

It also covers the five most common DBot errors I see beginners hit, and a troubleshooting section for each one.

The Guide

I put everything above into a structured PDF that walks through the complete build. It is aimed at someone who has never opened DBot before but can follow logical instructions.

How to Build Your First Deriv DBot From Scratch — $27

What is inside:

The complete step-by-step build process with every block explained
Risk management framework with the actual mathematics
Complete bot structure visual map
Demo testing guide and results interpretation
Five most common mistakes and how to avoid them
Introduction to the RSI filter for advanced win rates
Troubleshooting guide for common DBot errors

30-day refund policy. Instant download.

If you have questions after going through it, you can reach me at preciousanusiem.o.1@gmail.com.

A Note on Algorithmic Trading Honestly

I want to end with something that does not get said enough in this space.

Algorithmic trading is not a reliable income replacement. It is a tool that, used correctly by someone who understands it, can generate consistent returns in a specific niche. Used incorrectly by someone who does not understand it, it loses money systematically.

The difference between those two outcomes is almost entirely about understanding your system. Not about having the best signal. Not about the most sophisticated strategy. About genuinely knowing what your bot is doing and why, so you can recognise when it is working correctly versus when something is wrong.

This guide is designed to give you that understanding from scratch. Everything else can be improved over time once the foundation is solid.

Precious Anusiem — AI/ML Engineer, SaaS Founder, MQL5 Published Developer. Stanford ML certified. Google certified in Cybersecurity (93.71%) and Data Analytics (98.3%). IBM Generative AI Engineering certified. Builder of Dr. Choice, GlimTalk, InvestPropty, MeqxAI.

preciousanusiem.o.1@gmail.com*

⚠ Risk disclaimer: Trading synthetic indices involves substantial risk of loss. This content is educational only. Past performance does not guarantee future results. Not financial advice.