DEV Community: Precious Lyna Anusiem

I was building my own tools" energy, since that audience responds to maker/builder framing

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:44:33 +0000

I blew a $3,000 account in six weeks.

Not because I didn't know what I was doing. I'd watched hundreds of hours of content, I understood support and resistance, I could explain R:R ratios in my sleep. The problem was simpler and more embarrassing than that: I had absolutely no idea what my actual numbers were.

I thought my win rate was around 60%. It was 41%.

I thought my average winner was bigger than my average loser. It wasn't — I was cutting winners short and letting losers run, classic textbook mistake, and I couldn't see it because I never actually looked.

That's the thing nobody tells you when you start trading: the market doesn't care how good your strategy looks on paper. What matters is whether your strategy, as you actually execute it, has positive expectancy. And the only way to know that is to track every single trade with enough detail to do the math.

The tracking problem

Most traders track trades in one of three ways:

They don't track at all (the majority)

They screenshot good trades for social media and quietly forget the bad ones

They use a broker's built-in history export, which gives you raw P&L but nothing about the quality of your trades

None of these tell you what you actually need to know. What's my profit factor? What's my expectancy in R? Which session am I most profitable in — London open or New York? Am I better on trend days or ranging markets? Is my win rate consistent, or did I just get lucky for three weeks?

These questions are what separate traders who survive from traders who blow up and quit.

What I built instead

After my second blown account I stopped trading live for two months and focused on one thing: understanding my own data. I built a backtesting spreadsheet in Excel that would do all the math automatically. I wanted to log a trade in 30 seconds and immediately see how it affected every key metric.

The result is something I've been refining for over a year. It has seven sheets:

The Trade Log is where everything starts. You fill in the blue cells — date, pair, direction, entry, stop loss, take profit, result, and P&L. That's it. Every other column calculates itself: your R:R ratio, your R multiple, your running equity, your drawdown percentage, consecutive wins and losses.

The Dashboard pulls everything together. Win rate, profit factor, expectancy, max drawdown, Sharpe ratio, average R:R — all live, all updated the moment you add a trade. There's a pass/fail benchmark system so you can see at a glance if your numbers meet the minimums a funded trader or prop firm would expect.

The Strategy Analyzer is where things get interesting. It breaks your performance down by strategy, by pair, by session, and by day of the week. When I first ran my own numbers through this, I discovered I was profitable on London session trades and consistently losing on Asian session trades. I stopped trading Asian session. My overall performance improved immediately.

The Equity Curve gives you a visual chart of your cumulative P&L so you can see the shape of your trading — smooth and consistent, or spikey and lucky. These look very different and they matter.

The R:R Calculator works out your ideal position size based on your account balance and your risk percentage per trade. It also shows you the minimum win rate required to be profitable at any given R:R ratio. (At 1:1, you need to win more than 50% of trades. At 2:1, you only need to win 34%. This is not a small difference.)

The Monthly Summary breaks everything down month by month, which is essential if you're trading a prop firm challenge or keeping a trading journal for tax purposes.

Settings is where you configure your account size, your risk percentage, and your performance benchmarks — then everything across the entire spreadsheet updates automatically.

The numbers that changed how I trade

Here's what I mean when I say this changed things concretely.

After three months of logging with this system, I knew:

My win rate was 54%, not the 60% I'd assumed

My profit factor was 1.3 — technically profitable, but fragile

My expectancy was 0.21R per trade — low, but positive

My max drawdown was 14% — acceptable

I won 68% of trades I took on Tuesday and Wednesday. I lost money net on Mondays and Fridays.

Monday and Friday trades disappeared from my plan. My profit factor went from 1.3 to 1.7 in the following two months without changing anything else about my strategy.

That's what data does. It removes the guesswork and the ego. You can't argue with your own numbers.

Who actually needs this

If you're a complete beginner who just opened a demo account last week, you probably don't need this yet. Come back when you have 50 trades to analyse.

But if you've been trading for three months or more — live or demo — and you can't immediately answer the following questions from memory, you need a proper tracking system:

What is your current win rate?

What is your profit factor over your last 100 trades?

What is your expectancy in R?

Which pair or asset are you most profitable on?

What is your maximum historical drawdown?

Most traders can't answer more than one of these. If that's you, you're trading blind. You might be profitable right now for reasons that have nothing to do with your edge, and you won't know until the market shifts.

One last thing

The spreadsheet is available for instant download. It works in Microsoft Excel and Google Sheets, costs less than a trading book, and you'll have data on your own performance within the first week of using it.

If you're serious about trading — not serious about watching trading content, but serious about actually improving — tracking your trades properly is the single highest-leverage thing you can do. Everything else is noise until you know your numbers.

→ Download Trade Backtest Pro here

Automating Trades on Deriv Without Writing a Single Line of Code

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:36:31 +0000

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.

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

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:29:16 +0000

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.

I Spent 6 Months Building a News Trading EA That Doesn't Suck (Here's What I Learned)

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:15:41 +0000

Originally posted by a forex trader who got tired of losing money to bad EAs

Look, I'm just going to be honest with you right from the start. I've probably bought and tested at least 20 different forex EAs over the past 3 years. Most of them were garbage. Some worked for a week, then blew my account. Others never even opened a single trade. And the few that actually made money? They'd get absolutely destroyed during news events.

So about 6 months ago, I decided to stop buying other people's junk and build something myself. This is the story of how I went from complete MQL5 noob to building an EA that's actually profitable (and yes, I'm sharing the code at the end).

The Problem With Most Trading Bots

Here's the thing nobody talks about: most forex EAs are designed to pass backtests, not to actually trade profitably. They're optimized on historical data until they look amazing, then they fall apart on live markets.

I realized this after my third blown account. The EA that looked perfect in backtesting (78% win rate! 3:1 R:R!) lasted exactly 11 days live before hitting my 20% drawdown limit. The issue? Fixed stop losses.

During the UK inflation report (which I forgot was happening), volatility spiked. My EA opened a trade with its usual 30-pip stop loss. The market moved 80 pips in 4 minutes. I got stopped out at -30 pips, then it reversed and would've hit my +60 pip TP. This happened THREE TIMES that day.

That's when I understood: fixed stops are broken.

Starting From Scratch (Sort Of)

I'm primarily a Python guy. I've built ML models for sentiment analysis, written scrapers, done the usual data science stuff. But MQL5? That was new territory.

First attempt: I tried to build everything from scratch. News detection via web scraping, custom indicators, the whole nine yards. Spent 3 weeks on it. It compiled with 47 errors. I gave up.

Second attempt: I looked at how other people structure their EAs. Turns out the MQL5 community has some really solid standard libraries (Trade.mqh, SymbolInfo.mqh, etc.). Started using those. Much better.

Third attempt: I focused on solving ONE problem first - the fixed stop loss issue. Everything else could come later.

The ATR Breakthrough

I'd read about ATR (Average True Range) before but never really understood WHY it mattered. Then I ran this simple test:

// Measure volatility on EURUSD for 1 month
double atr_values[];
for(int i = 0; i < 30; i++) {
    double atr = iATR(_Symbol, PERIOD_H1, 14);
    Print("Day ", i, " ATR: ", atr);
}

The results were eye-opening. During low volatility periods, ATR was around 0.0010 (10 pips). During news events, it jumped to 0.0035 (35 pips). That's 3.5x difference.

So if I'm using a fixed 30-pip stop loss:

Low volatility: 30 pips is probably fine
High volatility: 30 pips gets hit immediately, then the trade works

The solution was obvious: multiply stop loss by current ATR.

double atr = iATR(_Symbol, PERIOD_H1, 14);
double dynamic_sl = atr * 2.0;  // 2x ATR for stop loss
double dynamic_tp = atr * 4.0;  // 4x ATR for take profit (2:1 R:R)

Ran this in strategy tester. Win rate dropped from 78% to 62%, but the profit factor went from 1.2 to 2.4. The EA was finally adapting to market conditions instead of fighting them.

But Wait, There's More (The Partial Close Secret)

Even with dynamic stops, I still had a problem: I'd be up +50 pips, then market would reverse and I'd close at +10 pips. Felt like I was constantly giving back profits.

One day I was reading about professional traders' tactics and came across this idea: partial position closing. The concept is simple:

Hit first profit target
Close 50% of the position
Let the other 50% run to full TP

This does something psychologically important: it guarantees you bank some profit, even if the market reverses. You're never in a situation where a +50 pip trade becomes a +5 pip trade.

Implementing this in MQL5 was actually pretty straightforward:

if(current_profit >= partial_target) {
    double close_volume = position_volume * 0.5;
    trade.PositionClosePartial(ticket, close_volume);
    // Remaining 50% stays open to full TP
}

Backtested this addition. Win rate stayed at 62%, but average win increased by 40%. Now when trades worked, they REALLY worked.

The News Trading Problem (And Solution)

News trading is weird. Everyone knows high-impact news creates volatility and big moves. But most EAs either:

Turn off completely during news (miss opportunities)
Trade through news with no adjustment (get destroyed)

I wanted something smarter. The MQL5 calendar API actually makes this possible:

MqlCalendarValue values[];
int count = CalendarValueHistory(values, start_time, end_time);

for(int i = 0; i < count; i++) {
    MqlCalendarEvent event;
    CalendarEventById(values[i].event_id, event);

    if(event.importance == CALENDAR_IMPORTANCE_HIGH) {
        // We have a high impact event
        // Measure pre-news range and trade the breakout
    }
}

My approach: during the 30 minutes before high-impact news, measure the price range. Then wait for a breakout of 150% of that range. This filters out fake moves and only catches the real explosive breakouts.

The results in backtesting were honestly surprising. News strategy alone had:

Win rate: 58%
Avg win: 2.1x avg loss
Profit factor: 1.8

Not amazing, but consistent. Combined with the trend-following strategy (EMA + RSI + ADX), the overall system became much more robust.

What About Breakeven?

This one's personal preference, but I found it helps psychologically. Once a trade is up +20 pips, I move the stop loss to breakeven +2 pips.

Why +2 and not exactly breakeven? Spreads. If you move to exact breakeven, you can get stopped out by spread widening. The +2 pip buffer prevents that.

if(profit_pips >= 20 && current_sl < open_price) {
    double new_sl = open_price + (2 * pip_size);
    trade.PositionModify(ticket, new_sl, current_tp);
}

The psychological benefit is huge: once you hit +20 pips, the trade is "free." Even if it reverses, you can't lose. This lets you be more patient with winners.

Lessons I Learned The Hard Way

1. Don't optimize on training data

I made this classic ML mistake with my EA. Optimized parameters on 2023 data, got 85% win rate. Tested on 2024 data, got 42% win rate. Oops. Overfitting isn't just a machine learning problem.

Solution: Use walk-forward analysis. Optimize on 3 months, test on next month, repeat.

2. Broker differences matter

My EA worked great on my demo account (IC Markets). Moved to live with a different broker (won't name them), and suddenly spreads were 2-3x higher. Many trades that were profitable on demo became losers because of spread.

Solution: Always backtest with realistic spreads for YOUR broker.

3. Trailing stops are tricky

First implementation of trailing stop: moved SL every tick. Result: EA tried to modify position 47 times in one minute. Broker got annoyed, I got errors.

Better implementation: only move SL if price moved at least 5 pips (the trailing step) AND the new SL is more favorable than current.

double new_sl = bid - trail_distance;
if(new_sl > current_sl + trail_step) {
    // OK to modify
}

4. Test with small position sizes first

When I finally went live, I started with 0.01 lots even though my account could handle 0.1. Good thing too, because I discovered a bug in my lot size calculation that only showed up with certain account balances. Would've cost me real money.

5. Keep detailed logs

The MQL5 Print() function is your best friend:

Print("Opening BUY trade: Lot=", lot, " SL=", sl, " TP=", tp, " ATR=", atr);

When something goes wrong (and it will), these logs are the only way to figure out what happened. Save them. Review them weekly.

The Final Result

After 6 months of development, testing, and iteration, here's what I ended up with:

Features:

ATR-based dynamic stops and targets
Partial profit taking (50% at +25 pips)
Automatic breakeven management
Three strategies: news breakout, trend following, scalping
Multi-indicator filters (EMA, RSI, ADX)
Session-based trading (London/NY preferred)
Full risk management (daily limits, margin checks)

Performance (last 3 months live):

Win rate: 61%
Average R:R: 1.9:1
Monthly return: 12-18% (on 1% risk per trade)
Max drawdown: 14%
Trades: 150 total

Is it perfect? No. Does it make consistent money? Yeah, actually it does.

What's Different About This EA

Look, I'm not trying to sell you some magic money printer. This isn't going to make you rich overnight. But here's what makes it different from the 20 other EAs I've tested:

It adapts to volatility - No more getting stopped out during news because the EA uses last century's fixed stops
It protects profit - Partial closes and breakeven management mean you actually keep money when trades work
It's transparent - Full source code. You can see exactly what it's doing, modify it, learn from it
It's been tested properly - Walk-forward analysis, multiple market conditions, real broker spreads
It's still evolving - I use this EA with my own money. When I improve it, you get the updates free

You Can Check It Out (If You Want)

I put the whole thing (source code + documentation) on Gumroad. It's $97 right now as a launch price. Honestly, I priced it there because I figure if you're serious about algo trading, $97 is nothing - that's like two losing trades. But if you're just curious and not committed, $97 is enough to make you think twice.

What you get:

Full MQL5 source code (NewsFilterEA v2.0 PRO)
150+ page documentation (I may have gone overboard here)
Quick start guide for the "just let me use it" crowd
Optimized settings for EURUSD, GBPUSD, XAUUSD
All my testing notes and optimization tips

Link: https://anusiempreciouso.gumroad.com/l/Advanced_News_Trend_Robot

But honestly? Even if you don't buy it, I hope this article helps you think differently about building trading systems. The key insights:

Dynamic stops > fixed stops
Partial profit taking > holding full position
Multiple strategies > single strategy
Adaptation > optimization

Questions I Know You're Going to Ask

Q: Is this going to make me rich?

No. It's a tool. A good tool, but still a tool. You need proper risk management, the right broker, realistic expectations. This isn't a lottery ticket.

Q: Why are you selling it if it works?

Because I'm one person with limited capital. I can make maybe $1-2K/month with my account size. Selling the EA for $97 to 100 people = $9,700. That's more than I'd make in 6 months of trading. Plus, I enjoy building this stuff.

Q: Can I use it on MT4?

No, it's MT5 only. I'm not going backward to a platform that's been outdated for years.

Q: Will it work on [exotic currency pair]?

Tested on majors: EURUSD, GBPUSD, USDJPY, XAUUSD. Should work on other pairs but you'll need to optimize settings. Not recommended for exotics with huge spreads.

Q: What if I can't get it working?

Email me: lynaplaodi@gmail.com. I actually respond. Usually within 24 hours. I built this thing, I can help you set it up.

Final Thoughts

Building this EA taught me more about trading than the previous 3 years of manual trading. There's something about having to codify your strategy that forces you to think clearly about what actually works vs. what you THINK works.

If you're a developer who trades (or a trader who codes), I highly recommend going through this exercise. Build something. It doesn't have to be complex. Just make it adaptive, make it protect profit, and test it properly.

And if you want to start with what I built, you know where to find it.

Happy trading, and may your stops never get hunted.

P.S. - I'm working on adding a feature for multi-timeframe confirmation. If you grab the EA, you'll get that update free when it's ready. Probably in the next month or so.

P.P.S. - Yes, I know some of you are going to ask "why not use machine learning?" I tried. Twice. Both times I ended up with overfit models that looked amazing in training and awful in practice. Sometimes simpler is better.

Tags: #forex #algotrading #metatrader5 #mql5 #trading #automation #fintech #programming

Connect: Found this useful? I occasionally write about trading and code. Drop your email if you want updates.

I Spent a Weekend Building Python Scrapers for 10 Websites. Here's Everything I Learned.

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:05:05 +0000

There's a shortcut at the end — but the lessons in between are genuinely worth reading.

Last spring, I needed eBay sold price data for about 200 items I was researching before an estate sale. Nothing complicated — just what did this thing actually sell for, recently, in used condition.

I figured it would take an hour. Maybe two.

Three hours later I had data on maybe 40 items, a stiff neck, and the particular kind of frustration that only comes from doing the same repetitive action several hundred times. Open tab. Search. Filter to sold listings. Scan prices. Write down number. Close tab. Repeat.

There had to be a better way.

So I did what any mildly annoyed person with a Python tutorial under their belt does: I automated it.

That one scraper turned into a weekend project. That weekend project turned into ten scrapers — covering Amazon, eBay, Indeed, LinkedIn, Zillow, Twitter, Reddit, Yelp, Google News, and a price tracker that emails me alerts when something drops below my target price.

Here's everything I learned along the way.

The Stack I Used (Deliberately Boring)

requests — HTTP calls
BeautifulSoup — HTML parsing
fake-useragent — rotating user-agent strings
tweepy and praw — for the two sites with decent free APIs (Twitter and Reddit)
csv — built-in, no install needed

No Selenium. No Playwright. No headless Chrome running in the background eating RAM. I made a deliberate choice to keep everything as simple as possible, and I'll explain why that was the right call.

The Most Useful Thing I Learned: Look for JSON Before You Scrape HTML

There's a pattern that almost no scraping tutorial covers, and it saved me hours.

Modern websites built on React or Next.js often embed the initial page data as a JSON blob inside a <script> tag. This is the data the frontend uses to render what you see. And it's sitting right there in the page source — structured, predictable, and usually more complete than what ends up in the rendered HTML.

for script in soup.find_all("script", {"type": "application/ld+json"}):
    try:
        data = json.loads(script.string or "")
        # Your data is in here more often than you'd expect
    except json.JSONDecodeError:
        continue

Zillow uses this pattern heavily. So does Yelp. Parsing JSON is infinitely more reliable than chasing CSS class names that change whenever someone on the frontend team refactors a component. I build JSON-first parsing with an HTML fallback in every scraper where this is available.

The Delay Is Not Optional (And It Has to Be Random)

Every scraper I built has a randomized delay between requests. Not fixed — random. This distinction matters more than most people realize.

A fixed time.sleep(2) is a fingerprint. Every request spaced exactly two seconds apart is a signal. time.sleep(random.uniform(2, 5)) looks like a human who gets distracted between clicks.

I also found that slightly longer delays on the first request — simulating someone waiting for a page to load and actually reading it — helped on sites with more aggressive rate limiting.

Is any of this foolproof? No. But it's the difference between scraping 500 results cleanly and getting blocked on page three.

Two Sites Have Good Free APIs — Use Them Instead of Scraping

Reddit and Twitter both offer free developer API access that most people don't bother with because they assume it's complicated or expensive. It's neither.

Reddit's API (via the praw library) is excellent. Upvote ratios, comment trees, post metadata — all clean, structured, and reliable. Setup takes about five minutes at reddit.com/prefs/apps.

Twitter's free tier is more restricted than it used to be, but for pulling public profile data and recent tweets it's still perfectly usable. The alternative — scraping Twitter's frontend — is a much harder problem. The API route is just better.

import praw

reddit = praw.Reddit(
    client_id="YOUR_ID",
    client_secret="YOUR_SECRET", 
    user_agent="MyBot/1.0"
)

for post in reddit.subreddit("entrepreneur").hot(limit=50):
    print(post.title, post.score, post.upvote_ratio)

Thirty lines of code. Real data. No parsing, no fragile selectors.

The eBay Sold Listings Scraper Is the One People Don't Know They Need

This was the scraper that started everything, and it remains the one I use most regularly.

The key insight: eBay separates completed listings (things that actually sold) from active listings. Most people browse active listings and assume those prices reflect reality. They don't. The completed listings show you what real buyers actually paid — which is often meaningfully different.

The URL parameter that unlocks this: LH_Sold=1&LH_Complete=1. Once you have that, you're pulling real transaction data.

I also added automatic price statistics at the end of each run:

📈 PRICE SUMMARY (147 sold listings):
   Minimum:  $23.00
   Maximum:  $312.00
   Average:  $87.43
   Median:   $74.00

The median versus average comparison is more useful than it might seem. A few high-priced outlier sales can pull the average up significantly. Median tells you what you'll realistically see.

The Price Tracker Changed My Daily Behavior

Of the ten scripts, the price tracker is the one that earns its keep most consistently.

You give it a list of product URLs and target prices. It checks prices on a schedule, logs everything to CSV, and sends an email when something drops below your threshold. I run it every morning via a cron job:

0 9 * * * python /path/to/05_price_tracker.py

What surprised me was how quickly I stopped thinking about it. It just runs. It shows up in your inbox when something matters. That's the ideal version of automation — invisible until it's useful.

I've used it to catch drops on headphones, a camera lens that almost never goes on sale, and a mechanical keyboard I'd been watching for months. None of those would have happened if I'd had to remember to check manually.

Yelp Is an Underrated Lead Generation Tool

I built the Yelp scraper mostly as an afterthought. It turned out to be one of the most immediately practical ones.

Pull every business in a category and city — with name, rating, review count, phone number, address, and website. Ten minutes of runtime gets you a spreadsheet that a data broker would charge hundreds of dollars for.

The angle I find most useful: filter for businesses with no website listed. Those are your warm prospects — established enough to have a Yelp presence, but clearly not prioritizing their online presence. If you sell any kind of digital service, that's your list.

What I Packaged Up

After cleaning everything up, commenting every non-obvious line, and adding a CONFIGURE HERE block at the top of each script so non-developers can use them without reading the whole thing, I put the pack together.

Ten scripts total:

Amazon product search results
Indeed job listings
Zillow for-sale and rental listings
Twitter/X public profiles and recent tweets
Cross-site price tracker with email alerts
LinkedIn public job board (no login needed)
eBay sold listings with automatic price statistics
Google News for any topic
Yelp business listings
Reddit posts and comments

Every script outputs a clean CSV. Every one has random delays and rotating user-agents built in. Every one is commented well enough to modify without deep Python knowledge. There's a full README with setup instructions.

The full pack is $19 → anusiempreciouso.gumroad.com/l/Python_WebScraping_Templates_Pack

If any script doesn't work as described, I'll fix it or refund you — no back-and-forth.

One Honest Note on Legality

Web scraping public data sits in a legal grey area, and I'd rather address that directly than bury a disclaimer.

US courts have generally upheld the legality of scraping publicly visible data — the hiQ v. LinkedIn ruling being the most significant example. But "generally legal" is not the same as universally fine, and each site has its own Terms of Service.

My personal guidelines: don't hammer servers (the built-in delays handle this), don't scrape behind authentication, don't republish scraped data as your own product. The scripts are built with these principles as defaults.

Going Further

A few things worth knowing if you want to extend any of these:

Proxies — For high-volume scraping, rotating residential proxies reduce blocking significantly. For the casual research use cases these scripts are built for, you probably don't need them.

Playwright/Selenium — For sites that render content entirely client-side via JavaScript, you'll eventually need a headless browser. Playwright is the current best option. None of the ten sites I targeted required this.

SQLite — CSV is fine for one-off pulls. If you're running scrapers on a schedule and want queryable historical data, sqlite3 is built into Python and requires no configuration.

Questions on any of the techniques? Drop them in the comments.

Tags: python, webdev, automation, tutorial, beginners

I Got Tired of Checking 4 Websites Before Every Trading Session, So I Automated All of It

Precious Lyna Anusiem — Tue, 21 Apr 2026 04:00:08 +0000

Every Sunday evening I'd do the same ritual.

Open Investing.com for the economic calendar. Check what's dropping Monday morning — NFP, CPI, a Fed speech. Then over to Yahoo Finance to see which earnings reports were coming up that week. Then a crypto tracker to get a feel for where Bitcoin sentiment was sitting. Then back to my notes app to paste everything together so I could actually look at it in one place.

Forty minutes. Every single week. Just copying data into a doc so I could see the full picture before markets opened.

I'm a developer. I build things for a living. Why was I doing this manually?

The actual problem

The issue isn't that the data doesn't exist. It's everywhere. Investing.com has a great economic calendar. Yahoo Finance has earnings dates. CoinGecko has solid crypto data. The Fear & Greed index from alternative.me is surprisingly useful as a sentiment proxy.

But each source speaks a different language, has a different layout, and wants you to stay on their site. None of them talk to each other. You can't go to one place and say "show me every high-impact thing happening in markets this week."

So you end up doing it manually. And if you're trading (even casually), that manual effort is death by a thousand paper cuts.

What I built

I wrote a Python scraper that handles all three in one shot. Run one command, get everything.

Here's what it pulls:

Economic Calendar — upcoming events with impact level (1–3), forecast, previous value, and actual once it's released. You can filter by --min-impact 3 to only see the high-impact stuff (NFP, CPI, Fed decisions, etc.)

Earnings Calendar — upcoming earnings report dates, whether they're BMO (before market open) or AMC (after market close), EPS estimates, revenue estimates, market cap. Works for any ticker or does a broad scan.

Crypto Sentiment — current price, 24h/7d/30d % change, market cap, volume, and a computed sentiment signal that blends price action with the Fear & Greed index.

The whole thing exports to CSV, JSON, or Excel. Run it once or schedule it to auto-refresh every hour while you sleep.

# Install
pip install -r requirements.txt

# Run everything
python src/trading_scraper.py --mode all

# Just high-impact economic events, next 2 weeks
python src/trading_scraper.py --mode economic --days 14 --min-impact 3 --output csv

# Earnings for specific tickers
python src/trading_scraper.py --mode earnings --ticker AAPL MSFT NVDA GOOGL

# Auto-refresh every hour, save everything
python src/trading_scraper.py --mode all --output all --schedule 3600

The terminal output looks like this (Rich tables with color-coded impact levels and sentiment):

                    📅  Economic Calendar
 ──────────────────────────────────────────────────────────
  Date / Time         Country         Event            Impact
  2024-04-19 12:30    United States   CPI m/m          ●●●
  2024-04-19 18:00    European Union  ECB Rate Decision ●●●
  2024-04-22 12:30    United States   Non-Farm Payrolls ●●●

The engineering stuff that matters

The first version I wrote was brittle. It worked on my machine on a Tuesday afternoon, and broke the next morning because Investing.com returned a 429 and the whole script died.

So I rebuilt it properly:

Rate limiting per domain — each source has its own rate limiter with a configurable delay. Hit the limit and it backs off cleanly rather than hammering the endpoint.

Exponential back-off retry — three attempts by default, with increasing wait times between them. Transient network errors don't kill your run.

Multi-source fallback — if the primary source for economic data (FinancialModelingPrep) fails, it falls back to Investing.com. If that fails too, you get demonstration data with a clear warning. The script never just crashes and leaves you with nothing.

Structured logging — daily log files in a logs/ directory. When something goes wrong at 3am during your overnight run, you have something to debug.

.env config — all tunable settings (request delay, timeout, max retries, API keys) live in a .env file. No hardcoded values you have to hunt through the code to change.

The source data is all free. The main optional upgrade is a FinancialModelingPrep API key (free tier, 250 requests/day) which enriches the economic calendar data. Everything else — Yahoo Finance, CoinGecko, alternative.me — works without any key at all.

Why not just use a financial data API?

Fair question. Services like Polygon.io, Quandl, or Alpha Vantage exist. But they're either paid, rate-limited to the point of uselessness on free tiers, or they don't cover all three categories I cared about (macro events + earnings + crypto sentiment in one place).

Building the scraper took longer upfront, but now I have exactly the data I want, in the exact format I want, available whenever I want it. No per-call billing, no dependency on someone else's pricing decisions.

What I use it for now

Before I built this, I was checking 4 tabs. Now my Sunday evening routine is:

python src/trading_scraper.py --mode all --output all

Open the Excel file. Three sheets — Economic, Earnings, Crypto. Ten minutes to review, close the laptop, done.

During the week, I have a cron job that runs it every morning at 7am and drops the fresh data into a folder my Notion integration picks up. Fully hands-off.

If you trade options, knowing which earnings are BMO vs AMC that week is actually critical — it changes your IV crush timing completely. And having high-impact economic events pre-loaded means you're not caught off guard by a surprise CPI print when you're sitting in a delta-sensitive position.

The code + packaged version

I've cleaned this up, added a full test suite (17 tests, all passing), and packaged it with documentation. If you want to use it as-is without digging through the source, I put it on Gumroad: https://anusiempreciouso.gumroad.com/l/Trading-Data-Scraper-Pro.

If you'd rather build something similar yourself, the approach is pretty standard: requests + BeautifulSoup + rich for the terminal UI. The CoinGecko and alternative.me APIs are both free and well-documented. The trickiest part is the rate limiting — if you skip that, you'll get banned from sources within a few runs.

Happy to answer questions about the implementation. Specifically around the FMP vs Investing.com source strategy, the rate limiter design, or the scheduler — those were the parts that took the most iteration to get right.

The packaged version includes the scraper, full CLI reference, .env config, unit tests, and a README. No mandatory API key required to start running.

The Maths Behind Prop Firm Challenge Failures (And How to Fix It With Code)

Precious Lyna Anusiem — Tue, 21 Apr 2026 03:48:52 +0000

Most prop firm challenge post-mortems I've read online are vague. "I overtraded." "I didn't respect my drawdown." "I was emotional."

Helpful. Thanks.

This post is going to be specific. I want to walk through the actual numbers behind why challenges fail, show you the formulas that fix the most common problems, and share how an MT5 expert advisor can enforce the rules you already know but consistently break under pressure.

If you trade or are thinking about attempting a prop firm challenge, this is the quantitative breakdown nobody writes.

First: What the Challenge Structure Actually Optimises For

A standard two-phase prop firm challenge looks like this:

Phase	Profit Target	Max Daily Loss	Max Total Drawdown	Min Trading Days
Phase 1	8–10%	4–5%	8–10%	4–10
Phase 2	4–5%	4–5%	8–10%	4–10
Funded	None	4–5%	8–10%	Ongoing

The asymmetry here is worth noticing. The profit target is fixed and achievable. The drawdown limits are permanent (total DD doesn't reset) and zero-tolerance (one breach and it's over).

This structure rewards consistency over aggression. The optimal play is not to maximise profit per unit time — it's to maximise the probability of staying within the loss boundaries while accumulating gains.

Which means it's fundamentally an optimisation problem, not a prediction problem.

The Position Sizing Formula (And Why Most Traders Get It Wrong)

The most common quantitative mistake I see in challenge attempts is fixed lot sizing. "I trade 0.1 lots on EUR/USD" — regardless of what the market is doing.

The correct formula:

Position Size (lots) = (Account Balance × Risk %) ÷ (Stop Loss in pips × Pip Value per lot)

Let's run this properly for a few scenarios on a $10,000 account at 1% risk:

EUR/USD — Low Volatility Day (ATR: 35 pips)

Stop Loss = 1.5 × 35 = 52.5 pips
Position Size = $100 ÷ (52.5 × $10) = 0.19 lots

EUR/USD — High Volatility Day (ATR: 80 pips)

Stop Loss = 1.5 × 80 = 120 pips
Position Size = $100 ÷ (120 × $10) = 0.08 lots

Same instrument, same 1% risk, same entry logic — and the position size varies by more than 2×. If you're using a fixed 0.1 lot size, on high-volatility days you're actually risking ~1.9%, and on low-volatility days you're leaving risk on the table or being stopped out by normal noise.

This is why ATR-based stop losses matter so much in a challenge context. Your risk per trade needs to be real, not nominal.

Simulating the Drawdown Risk at Different Position Sizes

Let's model what consecutive losing trades look like at different risk percentages on a $10,000 challenge account with a 10% total drawdown limit ($1,000 max loss):

def simulate_drawdown(balance, risk_pct, n_losses, max_dd_pct):
    max_dd = balance * (max_dd_pct / 100)
    current_balance = balance
    total_loss = 0

    for i in range(1, n_losses + 1):
        loss = current_balance * (risk_pct / 100)
        current_balance -= loss
        total_loss += loss
        remaining_buffer = max_dd - total_loss
        print(f"Loss {i}: Balance ${current_balance:.2f} | "
              f"Total DD: ${total_loss:.2f} | Buffer left: ${remaining_buffer:.2f}")
        if total_loss >= max_dd:
            print(f"CHALLENGE FAILED at loss {i}")
            break

# At 1% risk
print("=== 1% Risk per Trade ===")
simulate_drawdown(10000, 1.0, 10, 10)

print("\n=== 2% Risk per Trade ===")
simulate_drawdown(10000, 2.0, 10, 10)

Output:

=== 1% Risk per Trade ===
Loss 1: Balance $9900.00 | Total DD: $100.00 | Buffer left: $900.00
Loss 2: Balance $9801.00 | Total DD: $199.00 | Buffer left: $801.00
...
Loss 10: Balance $9043.82 | Total DD: $956.18 | Buffer left: $43.82
(Still alive after 10 consecutive losses)

=== 2% Risk per Trade ===
Loss 1: Balance $9800.00 | Total DD: $200.00 | Buffer left: $800.00
...
Loss 5: Balance $9039.21 | Total DD: $960.79 | Buffer left: $39.21
Loss 6: ...
CHALLENGE FAILED at loss 6

The difference between 1% and 2% risk isn't 2× the danger — it's the difference between surviving 10 consecutive losses and failing on the 6th. In a challenge context, those six losses can happen in two bad trading days.

The Daily Drawdown Problem Is More Subtle Than People Think

Most traders focus on total drawdown but the daily limit is what ends the majority of challenges. Here's why:

Suppose you're at a $10,000 account and you've had three moderately bad days — down 2.5% total, sitting at $9,750. You now have $750 of total DD buffer remaining.

Your firm's daily loss limit is 5% of the day's opening balance. But your personal available daily budget is now constrained by two things simultaneously:

The firm's daily limit: $10,000 × 5% = $500
Your remaining total DD buffer: $750

If you lose more than $500 today, you breach the daily limit regardless of total DD. If you've had one particularly bad day earlier in the challenge and you're at $9,300, your total buffer ($700) is actually tighter than the daily limit on some days.

The correct daily maximum loss to trade to is: min(firm_daily_limit, remaining_total_dd_buffer × 0.5)

Never put more than half your remaining total buffer at risk in a single day. This gives you at least two more bad days before failure, rather than one.

How GlimTrader Pro Handles This Automatically

After working through all of this manually for a while, I started using GlimTrader Pro — an MT5 expert advisor specifically built for prop firm challenges. I want to be specific about how it solves the problems above rather than just saying "it does risk management."

ATR-based position sizing:

// Pseudocode of the sizing logic
atr = iATR(symbol, timeframe, 14)
stop_distance = atr * ATR_SL_Multiplier  // default 1.5
pip_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE)
risk_amount = AccountBalance() * (RiskPercentage / 100)
lot_size = risk_amount / (stop_distance * pip_value)
lot_size = MathMin(lot_size, MaxLotSize)
lot_size = MathMax(lot_size, MinLotSize)

This runs on every entry signal. You never manually set the lot size.

Daily loss enforcement:
The EA tracks g_dailyLoss against MaxDailyLossPercent. When the threshold is crossed, CheckDailyLimits() returns true and the entry logic is blocked for the rest of the day. There's no override because there's no UI element to override it with — the decision is made before the session starts via the parameter, not in the moment.

The 6-factor signal confluence system:
The EA only opens trades when all of the following align:

EMA stack: Fast(8) > Slow(21) > Trend(50) for longs
H4 timeframe EMA(50) in agreement (when UseMultiTimeframeConfirm = true)
MACD histogram showing momentum in signal direction
RSI not in overbought/oversold zone
Price within Bollinger Bands (20, 2.0)
Previous candle confirms direction (when RequireCandleConfirmation = true)

The multi-factor requirement naturally reduces trade frequency, which in a challenge context is usually a feature not a bug. Fewer trades means fewer opportunities to breach the daily limit.

Optimal Parameters for Each Challenge Phase

This is what I run — and what I include in the configuration guide bundled with the EA:

// Phase 1 & 2 — Conservative
RiskPercentage = 0.75
MaxDailyLossPercent = 3.0       // buffer below firm's 4-5%
MaxDailyProfitPercent = 5.0     // stop trading after good days
MaxConcurrentTrades = 1
UseMultiTimeframeConfirm = true
RequireCandleConfirmation = true
ATR_SL_Multiplier = 1.5
ATR_TP_Multiplier = 3.0         // enforces minimum 2:1 R:R
UseBreakeven = true
BreakevenTriggerATR = 1.0
UseTrailingStop = true
TradeLondonSession = true
TradeNewYorkSession = true
TradeAsiaSession = false
MaxSpreadPoints = 30

The key ones most people configure wrong:

MaxDailyProfitPercent — stopping after a profitable day sounds counterintuitive but it prevents the single most common way traders give back gains: continuing to trade an already-volatile session after a strong run, often in worse conditions.

TradeAsiaSession = false — the Asia session has lower volume and more erratic price action for EUR/USD and major pairs. The signal quality drops and spread quality worsens. Turning this off removes a category of trades that have worse expected value.

MaxConcurrentTrades = 1 — stacking two 1% positions is a 2% position. This one line prevents silent leverage creep.

The Firm-Specific Settings That Matter

Not all firms have identical rules. Here's what changes by platform:

Firm	Daily DD	Max DD	Trailing DD	MaxDailyLossPercent Setting
FTMO	5%	10%	No	3.5%
The Funded Trader	5%	10%	Yes (from equity high)	3.0%
E8 Funding	5%	8%	No	3.0%
Apex Trader	3%	6%	No	1.5%
Topstep FX	2%	6%	No	1.5%

The trailing drawdown at The Funded Trader is the one that catches people most often. If your equity reaches $10,800 and then pulls back to $10,000, you've used $800 of your $1,000 trailing DD limit — even though you're still above your starting balance. The practical adjustment is to treat +3% days as a signal to stop trading, not to continue pushing.

If You Want the Full System

I put together a detailed guide covering all of this — the drawdown maths, position sizing formulas, firm-specific settings, a printable daily tracker, and full GlimTrader Pro configuration for each phase and each major firm. It's available on Gumroad at a flat rate, bundled with the EA.

Not trying to upsell — I'm sharing it because working through this stuff analytically (the way this post tries to) is what finally made the difference after three failed challenges. The guide documents all of it in one place.

GlimTrader Pro — Pass Prop Firm Challenges Faster →

If you're working through the maths on your own challenge setup and have questions, drop them in the comments. Happy to go deeper on any of the formulas or the EA configuration logic.

How I Turned ChatGPT Into a Brutally Honest Trading Coach (The Prompts That Actually Work)

Precious Lyna Anusiem — Tue, 21 Apr 2026 03:35:34 +0000

I trade stocks and forex alongside a day job. Been doing it a few years. For the past several months I've been using ChatGPT and Claude as a structured part of my daily trading routine — not to get signals, not to predict prices, but as a thinking partner with specific, repeatable workflows.

There's a way to do this that actually works, and a way that wastes your time. Here's the difference.

Why most traders get nothing useful from AI

Ask ChatGPT "should I buy AAPL?" and you'll get something like:

"AAPL has strong fundamentals, but as with any investment, you should consider your personal risk tolerance and consult a qualified financial advisor."

Useless. But it's not the AI's fault — it's the prompt's fault.

Trading decisions require context the AI doesn't have unless you give it: your entry and stop prices, your account size, your timeframe, the current chart structure, and your emotional state. Feed it those inputs with a structured request and a defined output format, and you get a completely different quality of response.

The pattern I use for every prompt I build:

1. Context block — everything the AI needs to know
2. Specific request — exactly what I want analysed
3. Output format — exactly how I want it structured
4. Constraint — "be direct, no hedging, no flattery"

Here are the prompts that made it into my permanent rotation.

The Pre-Market Plan

Every morning before open. Fill in the variables, run it, print the output:

Build my pre-market plan for today, [DATE].

Watchlist: [TICKERS]
Market context: [overnight moves, macro events, VIX level]
My strategy: [your approach in plain English]
Account status: [e.g. up 2R this week / at daily loss limit / fresh]

Structure the plan as:
1. MARKET BIAS — overall tone and what it means for my tickers
2. PER-TICKER LEVELS — key S/R zones, what I need to see to trade
3. SCENARIOS — bull case and bear case for today's session
4. TODAY'S RULES — specific rules given current conditions
5. PASS/TRADE DECISION TREE — criteria for trading vs sitting on hands

Concise. Actionable. Printable.

Takes four minutes. The output is a written session plan I trade from. Before this habit I was opening my platform cold and reacting to whatever moved. Now I have a plan before the open, and the number of impulsive trades I take has dropped measurably.

The Post-Trade Journal Entry

This one changed my journaling consistency more than anything else:

I just closed a trade. Raw details:

Ticker: [TICKER] | Direction: [LONG/SHORT] | Timeframe: [TF]
Entry: [PRICE] | Exit: [PRICE] | Stop: [PRICE] | TP: [PRICE]
P&L: [$X] | R-Multiple: [e.g. +1.8R or -1R]
Emotional state during the trade: [honest — e.g. "anxious, wanted to exit early at +1R"]

Generate a structured journal entry:
1. TRADE SUMMARY (2–3 factual sentences)
2. SETUP QUALITY SCORE (1–10 with explanation)
3. EXECUTION QUALITY SCORE (did I follow my plan?)
4. PSYCHOLOGICAL AUDIT (what emotions influenced my decisions?)
5. KEY LESSON (one specific, actionable takeaway)
6. REPLICATE / AVOID

Write as a direct trading coach. No flattery.

That last line — "No flattery" — is doing a lot of heavy lifting. Without it, AI finds the silver lining in every bad trade. With it, you get the honest post-mortem you actually need.

I've journaled every trade for four months straight because this prompt removed all the friction. Consistency has compounded.

Position Size Calculator

Before every trade, without exception:

Calculate my exact position size and give me a full risk summary.

Account balance: $[BALANCE]
Risk per trade: [RISK %]% of account
Entry: $[ENTRY] | Stop: $[STOP] | Target: $[TARGET]
Instrument type: [STOCKS / FOREX / CRYPTO / FUTURES]

Calculate and return:
1. Dollar amount at risk: $X
2. Correct position size (shares/units/contracts): X
3. R:R ratio: X:1
4. Break-even win rate required at this R:R: X%
5. Portfolio heat (% of total account in this position): X%

Flag any concerns. Is this sizing appropriate for the setup?

The math is simple enough to do mentally. The point is being forced to read the numbers back as a structured output before you enter. How often do you think you know your R:R without actually calculating it? More often than you'd admit.

The Stop Loss Placement Prompt

When you're unsure exactly where to put your stop:

Help me place my stop loss for this trade.

Ticker: [TICKER] | Direction: [LONG/SHORT] | Timeframe: [TF]
Entry: [PRICE] | Setup type: [e.g. breakout retest, support bounce]
Nearest support below entry: [LEVEL]
Nearest resistance above entry: [LEVEL]
My target: [PRICE] | Risk per trade: [%]%

Give me:
1. Logical stop loss price with reasoning
2. Why this is the structural invalidation level (not arbitrary)
3. The R:R this placement gives me
4. Whether R:R is worth taking or I should skip this trade
5. The most common stop placement mistake for this setup type

The key thing this prompt does: forces you to think about the stop as a structural invalidation level, not a random number below entry. That shift in framing alone is worth running it.

The Revenge Trading Circuit Breaker

The one I use most but talk about least:

I just took a [R-MULTIPLE] loss on [TICKER].
I'm feeling [HONEST EMOTIONAL STATE — e.g. "frustrated, want to get it back"].
I have the urge to re-enter immediately or find another trade.

1. IMMEDIATE INTERVENTION — what do I do in the next 10 minutes?
2. PHYSIOLOGICAL RESET — a specific 3-step process to calm my system
3. RATIONAL REALITY CHECK — reframe this loss in context of my account and stats
4. DECISION GATE — 5 questions I must answer YES to before trading again today
5. HONEST RECOMMENDATION — should I close the platform for today?

Be direct. My capital is at stake.

Impulsive trades after losses are one of the most common ways retail traders turn a manageable bad day into a blown week. Having something that interrupts that loop — even just 60 seconds of reading a structured response — has stopped enough bad decisions that it's earned a permanent spot in my workflow.

The Monthly Bias Audit

Run this once a month. Describe your own behaviour honestly:

Act as a professional trading psychologist.

I will describe my recent trading behaviour. Identify my top 3
cognitive biases with specific evidence from my descriptions.

My recent behaviour:
[DESCRIBE IN DETAIL — be specific and honest. Examples:
 "I move my stop when price gets close to it."
 "I exit winners before target when I'm up 1R."
 "I hold losing trades far longer than my rules allow."]

For each bias:
1. Name it precisely
2. Show the specific evidence from my description
3. The psychological root cause
4. One countermeasure I can implement this week
5. A self-check question to ask before each trade

Then create a BIAS WATCHLIST — 3 items I can print and keep at my desk.

The output is uncomfortable to read. That's the point. You already know your patterns. This makes you write them down, name them, and get a specific plan to address each one.

What this won't do

Worth being clear:

AI cannot read your charts — only what you describe to it
It won't create an edge where none exists
It can be wrong, especially on calculations — always verify
It's a thinking tool, not an authority

The value is in consistency, structure, and honest self-assessment — not signals.

The Pack

I built 15 of these prompts — refined over months of actual daily use — into a PDF. Fully selectable text, copy-paste ready, each one with a real example output so you know what a useful response looks like.

Covers: price action analysis, trade journaling, risk management, psychology, and strategy validation.

→ https://anusiempreciouso.gumroad.com/l/TraderMind_AI_Prompt — $17 one-time

Or use the prompts above and build your own. The pattern is the same throughout: context + specific request + output format + no-hedging constraint.

Not financial advice. These are process and thinking tools — not signals or trading recommendations.

I Build Custom Trading Bots for Deriv and MT4/MT5 — Here's What That Actually Looks Like

Precious Lyna Anusiem — Tue, 21 Apr 2026 03:17:49 +0000

Let me tell you about an order I completed two weeks ago because it's a good illustration of what this work actually involves.

A trader in South Africa — manual EUR/USD strategy, 15-minute chart, EMA crossover with RSI confirmation — needed his system running during London open. He works days. London open is 9 AM GMT, which means he's already two hours into his workday by the time the best setups show up. Two years of solid manual results, locked behind a scheduling problem.

He sent me his rules. I built it. Eight days later he had a Python bot running his exact strategy, logging every trade to SQLite, firing Telegram alerts to his phone, with a full risk management module that mirrors how he trades manually: 1% per trade, 2.5% daily loss ceiling, hard stop.

That's the job. Here's everything else worth knowing about it.

The technical stack I work with

For Deriv (binary options + synthetic indices):

Python 3.11 over the Deriv WebSocket API (wss://ws.binaryws.com/websockets/v3). Async tick subscriptions, rolling buffer for indicator calculation, SQLite for trade and P&L persistence, Telegram Bot API for alerts. Deployed on Render's free tier for 24/7 operation.

The architecture I've settled on after building several of these:

# Simplified core loop structure
async def on_tick(tick_data):
    symbol = tick_data['symbol']
    price  = tick_data['quote']

    buffers[symbol].append(price)

    if len(buffers[symbol]) < MIN_BUFFER:
        return  # Not enough data yet

    if not safety_checks_pass(symbol):
        return  # Daily limits, cooldown, concurrent cap

    signal = score_signal(buffers[symbol], symbol)

    if signal:
        await execute_layered_entry(symbol, signal)
        await notify_telegram(symbol, signal)
        log_to_db(symbol, signal)

Everything safety-critical — daily P&L, drawdown tracking, signal count — goes to SQLite, not memory. A bot that resets its daily loss counter on crash is a bot that will eventually blow an account.

For MT4/MT5:

MQL4 or MQL5 depending on the client's platform. I have 5 EAs published on the MQL5 Marketplace so this is well-trodden territory. The delivery is a compiled .ex4 or .ex5 file plus the source .mq4/.mq5. Clients who want to see under the hood get the source. Clients who just want it running get the compiled file plus the parameter documentation.

The signal architecture I apply across most builds

Most bots I'm asked to build fall into one of two categories:

Mean reversion (typical for synthetic indices — Deriv's Volatility 10, Volatility 25):
Price oscillates. You detect overextension and bet on the return to mean. The indicators that matter here: RSI at extremes, Bollinger Band touches, Rate of Change fading at a peak. Weighted scoring so no single indicator fires a trade alone.

Trend following (typical for real forex pairs — EUR/USD, GBP/USD, XAU/USD):
Price trends directionally. You identify the trend, wait for a pullback, enter in the trend direction. EMA crossovers for trend identification, RSI for momentum confirmation, direction flip detection for pullback entry.

The scoring system I built for my own Deriv bot (the one that hit 71% live) works like this:

fall_score = 0
rise_score = 0

# RSI scoring
if rsi > 78:             fall_score += 3
elif rsi > 70:           fall_score += 2
if rsi < 22:             rise_score += 3
elif rsi < 30:           rise_score += 2

# Bollinger Bands
if price >= upper_bb * 0.999:   fall_score += 3
if price <= lower_bb * 1.001:   rise_score += 3

# Rate of Change momentum
if roc < -0.02:   fall_score += 2
if roc > 0.02:    rise_score += 2

# Direction flip (pullback detection)
if flipped_to_down:   fall_score += 2
if flipped_to_up:     rise_score += 2

# Only fire on unambiguous signals
if fall_score >= 6 and fall_score > rise_score:
    fire_trade("FALL")
elif rise_score >= 6 and rise_score > fall_score:
    fire_trade("RISE")

I adapt this framework to each client's specific logic. The scoring threshold and weights change. The indicators change. The underlying architecture — requiring convergence before firing, never a single trigger — stays.

What the risk module always includes

Non-negotiable on every build, regardless of tier:

def pre_trade_safety_check(symbol, state):
    if state.daily_pnl <= -state.daily_loss_limit:
        return False, "Daily loss limit reached"

    if state.daily_pnl >= state.daily_profit_target:
        return False, "Daily profit target reached"

    if state.concurrent_signals >= state.max_concurrent:
        return False, "Max concurrent positions"

    elapsed = time.time() - state.last_signal_time.get(symbol, 0)
    if elapsed < state.cooldown_seconds:
        return False, f"Cooldown active ({elapsed:.0f}s elapsed)"

    if state.daily_signal_count >= state.max_daily_signals:
        return False, "Daily signal cap reached"

    return True, "OK"

Daily loss limit, daily profit target, concurrent position cap, per-symbol cooldown, daily signal cap. These are all configurable by client parameters. The structure itself is fixed.

The persistence layer:

def update_daily_pnl(conn, date, pnl_delta):
    conn.execute("""
        INSERT INTO daily_pnl (date, pnl)
        VALUES (?, ?)
        ON CONFLICT(date) DO UPDATE SET pnl = pnl + excluded.pnl
    """, (date, pnl_delta))
    conn.commit()

def get_daily_pnl(conn, date):
    row = conn.execute(
        "SELECT pnl FROM daily_pnl WHERE date = ?", (date,)
    ).fetchone()
    return row[0] if row else 0.0

SQLite upsert on every trade close. If the process restarts at any point during the day, the daily P&L is accurate. Risk limits are never bypassed by a crash.

The three-tier service

I run this as a custom development service on Gumroad. Three tiers:

Starter — $200
Single-indicator logic, one asset, basic SL/TP, 5–7 day delivery. For traders who have a simple, clearly defined system. Good entry point if you want to test the process before a larger order.

Standard — $350
Multi-indicator signal engine, up to three assets, full risk management module (daily limits, position sizing, cooldowns), Telegram integration, SQLite logging. 7–10 days. This covers 80% of what people actually need.

Premium — $500
Any complexity. No asset limit, advanced logic, video walkthrough of the full codebase, 30-day support. For traders with complex multi-market systems who want everything documented thoroughly.

Every tier includes full annotated source code. Not compiled-only. You own the code, you understand the code, you can modify it yourself or bring it to any developer.

The process after purchase: you get a client intake form immediately. You describe your strategy in plain English — no coding knowledge required, just your rules. I review it within 24 hours, confirm scope in writing, and start building.

The questions I get most often from devs

"Can I just buy the code and modify it myself?"

If you want the architecture as a starting point, the Standard tier gives you a well-structured, commented codebase you can extend. A lot of developers order because they want to skip the scaffolding: the WebSocket connection handling, the indicator calculation library, the SQLite schema, the Telegram integration. All of that is already done. They add their signal logic on top.

"Can you add X feature after delivery?"

Bug fixes are covered in the support window. New features — adding an asset, adding an indicator, changing the strategy type — are new orders. I'm clear about this upfront so there are no misunderstandings at delivery.

"Do you do revenue share instead of flat fee?"

No. I charge for my time and expertise. Revenue share creates misaligned incentives — it puts me in a position of having financial exposure to a strategy's market performance, which I can't control. Flat fee, clean relationship.

One thing worth saying clearly

The 71% win rate people see on my Deriv bot article is real. It's also 24 trades, which is meaningful but not statistically conclusive. I say this in the article and I'll say it here.

What I can guarantee for custom orders is that the code is correct — it does exactly what was specified, tested, and documented. I can't guarantee that a client's strategy has a positive edge in the market. That part is on the strategy, not the implementation.

If you're not sure whether your strategy has an edge, trading it manually on demo for a few weeks before commissioning a bot is always the right call. I'd rather you have confidence in your logic before we build than discover problems post-delivery.

Where to find the service

It's on Gumroad: gumroad.com/preciousanusiem

Questions before purchasing, clarifications about whether your strategy is in scope, or anything else — I respond to everything.

📧 preciousanusiem.o.1@gmail.com
🔗 GitHub: github.com/PreciousAnusiem

If you've built something in this space — custom EAs, Python trading systems, Deriv bots — I'd genuinely like to hear about the engineering decisions you made. Drop it in the comments.

I Built a Deriv Bot That Wins 71% of the Time — Here's the Complete Strategy (With Code)

Precious Lyna Anusiem — Tue, 21 Apr 2026 02:28:29 +0000

⏱ 12 min read · 🏷 deriv bot binary options python trading bot dbot strategy algorithmic trading volatility index

Why I Built This (And Why Most Deriv Bots Fail)
The Markets: What I Trade and Why
The Signal Engine: Multi-Factor Scoring Explained
Synthetic Index Logic (V10 / V25)
Forex and Gold Logic (Higher/Lower)
The 3-Trade Layered Entry System
Risk Management: The Rules That Keep You Alive
XML / DBot Configuration Structure
Live Results and Evidence
What This Strategy Cannot Do
Get the Full $47 Guide

Why Most Deriv Bots Fail (And What I Did Differently) {#why-most-deriv-bots-fail}

I have been building automated trading systems for three years. In that time I watched hundreds of Deriv bot strategies — in Telegram groups, on YouTube, in forums — fail for the same predictable reasons.

Mistake 1 — Single-indicator trading.
Someone builds a bot that fires on RSI alone. It works for two days. Then the market spends three days ranging in a tight band and the bot destroys the account placing trades on false signals. One indicator is not a strategy. It is a coin flip with extra steps.

Mistake 2 — Martingale with no ceiling.
Martingale — doubling stake after every loss — works beautifully until you hit five or six consecutive losses. Without a hard ceiling, one bad session erases three weeks of profit. I have seen this happen to traders with otherwise solid strategies.

Mistake 3 — Wrong contract type for the market.
Deriv's synthetic indices and real forex/gold pairs behave completely differently. A Rise/Fall strategy optimised for a synthetic volatility index will underperform on EUR/USD, where trend-following Higher/Lower contracts are significantly more effective. Most bots pick one approach and apply it everywhere.

My bot solves all three. Here is how.

The Markets: What I Trade and Why {#market-selection}

The bot monitors six markets simultaneously, split into two categories with different logic for each.

Synthetic Volatility Indices — Rise/Fall

V10 (1s) — symbol: 1HZ10V

The V10 (1 second) index runs 24/7, including weekends. It has no external news risk, no liquidity gaps on market open, and no weekend gaps. The tick pattern is controlled and oscillates with a measured pace — which makes it ideal for mean-reversion signals: detecting when price has moved to an extreme and betting on its return to the mean.

I use Rise/Fall contracts on V10. Here is the key reason: V10 is not a trending asset. It reverses. Rise/Fall contracts capture peak-to-trough moves exactly as designed.

Why not V75 or V100?
V75 and V100 move too fast. Signal noise dominates. Entries get eaten by volatility before the logic resolves. V10 is the sweet spot — enough movement to generate signals, controlled enough that those signals hold.

Real Forex and Gold Pairs — Higher/Lower

EUR/USD · USD/JPY · XAU/USD · GBP/USD · AUD/USD

Real pairs trend. They have directional momentum. Higher/Lower contracts on Deriv let you define a barrier price — a level the market must reach within the contract duration. On trending assets this is more precise and typically carries a slightly better payout than plain Rise/Fall.

Using Rise/Fall on EUR/USD is like using a hammer to cut wood. The right tool changes everything.

The Signal Engine: Multi-Factor Scoring {#signal-engine}

This is the part most bots skip — and the reason most bots fail.

Instead of a single trigger, the bot runs a weighted scoring system across four independent indicators. Each condition that aligns with a direction adds points. A signal fires only when the score reaches 6 out of a possible 10–12 points, and only when that score is strictly greater than the opposing direction.

This means:

RSI extreme alone (3 points) does not fire a trade
BB touch alone (3 points) does not fire a trade
RSI extreme plus BB touch plus momentum confirmation = 8 points → trade fires

The scoring gate is what separates a 55% win rate bot from a 71% win rate bot. You are not trading more often. You are trading better.

The Four Indicators

1. RSI (14 periods)

Measures whether the market is overbought or oversold. For synthetic indices, extreme readings are the primary signal:

RSI above 78 → +3 points for FALL
RSI above 70 → +2 points for FALL
RSI below 22 → +3 points for RISE
RSI below 30 → +2 points for RISE

For real forex/gold pairs, RSI is used as a momentum confirmation, not a reversal detector. An RSI between 60–79 during a confirmed bull trend adds +2 points — it means the trend has momentum but has not yet overextended.

2. Bollinger Bands (20 periods, 2 standard deviations)

Measures how far price has deviated from its mean. For synthetics:

Price at the upper band → +3 points for FALL (overextended, likely to revert)
Price at the lower band → +3 points for RISE (underextended, likely to revert)

For forex/gold, the logic inverts: price sitting between the midline and the upper band during a bull trend is the ideal entry zone (+2 points for CALL). You want to enter while the trend is intact, not after it has overextended.

3. Rate of Change (5 ticks)

Measures momentum acceleration or deceleration. The critical use case is detecting momentum fading at a peak on synthetic indices:

ROC below -0.02 at a high = momentum is dying → +2 points for FALL
ROC above +0.02 at a low = momentum building → +2 points for RISE

4. EMA Crossover (5 / 20 period)

Used exclusively for real forex/gold pairs. This is the most powerful signal in the forex logic, carrying 4 points on its own:

EMA5 above EMA20 = confirmed bull trend → +4 points for CALL
EMA5 below EMA20 = confirmed bear trend → +4 points for PUT

Nothing else in the system matches this single piece of information for trending assets. If the EMA crossover is not confirmed, the forex signal cannot reach the minimum score threshold.

Synthetic Index Logic — Full Scoring Breakdown {#synthetic-logic}

For V10 (1s), the strategy is mean reversion. Price oscillates. We bet on the reversal.

Condition	Points	Direction
RSI above 78 (extreme overbought)	+3	FALL
RSI above 70 (overbought)	+2	FALL
Price at upper Bollinger Band	+3	FALL
Price near upper BB (70% zone)	+1	FALL
Rate of Change below -0.02	+2	FALL
Direction reversed from up to down	+2	FALL
Price is 20-tick local maximum	+1	FALL
Maximum possible	14
Minimum to fire	6

The RISE scoring is the exact mirror of this table.

The Strongest Possible Signal (Score 10–12)

When RSI is above 78 (+3) and price is touching the upper Bollinger Band (+3) and momentum is fading (-0.02 ROC, +2) and direction has just reversed from up to down (+2), the total score is 10 points.

In live testing, score-10 and score-12 signals had the highest win rate of any signal quality category. These are the trades you most want to take.

A Real Tick Walk-Through

Here is exactly what happens when the bot receives a tick:

1. Tick received → appended to 200-tick rolling buffer
2. Buffer < 30 ticks? → return (not enough data yet)
3. Last signal < 120 seconds ago? → return (cooldown active)
4. Daily loss >= $5.00? → return (daily limit hit)
5. Concurrent signals >= 2? → return (exposure limit hit)
6. Calculate: RSI(14), BB(20), ROC(5), direction track
7. Score FALL conditions, Score RISE conditions independently
8. Winning score >= 6 AND strictly greater than opposing score?
   → Fire signal → place 3 layered trades
   → Log to SQLite → send Telegram alert
9. Return (no signal this tick)

Every tick, every symbol, every second of the day.

Forex and Gold Logic — Trend Following Entries {#forex-logic}

For EUR/USD, USD/JPY, XAU/USD, GBP/USD, and AUD/USD, the strategy switches to trend identification and pullback entry.

The logic difference is critical: synthetic indices revert to the mean. Real assets follow trends. Trading them the same way is a guaranteed path to losses.

Condition	Points	Direction
EMA5 above EMA20 (bull trend confirmed)	+4	CALL
RSI 60–79 (momentum, not overextended)	+2	CALL
RSI >= 80 (overbought — risky)	-1	CALL
Price above BB midline, below upper band	+2	CALL
Price above upper BB (overextended)	-1	CALL
Positive ROC during bull trend	+1	CALL
Pullback reversal within bull trend	+2	CALL
Maximum possible	10
Minimum to fire	6

Notice the negative scores. The bot penalises entries that are technically in the trend direction but overextended. An overbought RSI during a bull trend costs -1 point — reducing conviction. This prevents chasing entries.

The Pullback Entry — The Best Trade in the System

The highest-quality entry on a trending asset is not "enter when the trend starts." By then, you have already missed the move. The best entry is the pullback:

EUR/USD is in a bull trend (EMA5 > EMA20)
Price temporarily pulls back (micro-correction)
Price reverses back upward from the pullback

This moment — direction flipping from down to up while EMA5 > EMA20 — adds +2 points and, combined with the EMA signal (+4) and RSI momentum (+2), produces a score of 8.

This is the trade. Entering after the pullback, in the direction of the trend, with multiple confirmations. It is the closest thing to a textbook trading entry that an automated system can produce.

The 3-Trade Layered Entry System {#layered-entry}

Every signal opens three trades at staggered price levels, not one single entry.

Trade	Barrier Offset	Purpose
Trade 1	0.00% (at signal price)	Immediate execution at current price
Trade 2	0.04% from signal price	Slightly more conservative barrier
Trade 3	0.08% from signal price	Best-case barrier, higher potential payout

Why three entries instead of one?

Binary options have a fixed expiry. If you place a single trade exactly at what you think is the reversal point and you are one tick early, you lose. With three layered entries, you capture the move even if your first entry is slightly premature. Trades 2 and 3 still win.

The three entries also span different payout profiles. Trade 1 with a 0% barrier is the easiest to win but lowest payout. Trade 3 with a 0.08% barrier is harder but pays more if it hits. One signal produces a range of outcomes rather than an all-or-nothing single bet.

Total exposure per signal: 3 × $1 = $3

With a daily loss limit of $5, the bot can sustain one full signal loss and part of another before shutting down for the day. That is intentional — the loss limit is tight enough to prevent destruction, wide enough to allow normal operation.

Risk Management: The Rules That Keep You Alive {#risk-management}

The entry logic gets you a 71% win rate. Risk management is what keeps you from losing everything on the 29%.

Every one of these rules runs before every trade. None can be bypassed.

Rule 1 — Daily Profit Target: $10

Once the day's cumulative P&L reaches +$10.00, the bot stops. No more signals for the rest of the day. Gains are locked. This prevents the single most common way profitable bots destroy their own returns: overtrading after a good run.

Rule 2 — Daily Loss Limit: $5

Once cumulative P&L reaches -$5.00, the bot stops for the day. With $3 total per signal, you sustain roughly 1–2 full losing signals before this trips. That is intentional.

Key detail: The P&L is tracked in a SQLite database, not memory. If the bot crashes and restarts at 2 PM, it reads the persisted daily P&L and continues enforcing limits correctly. A memory-based counter resets on crash. A database counter does not.

Rule 3 — Maximum 15 Signals Per Day

Even if conditions are perfect all day, the bot caps at 15 signals. Markets that look ideal all day are sometimes hiding a regime shift. The cap is a sanity limit.

Rule 4 — 120-Second Per-Symbol Cooldown

After each signal on a given market, that market is locked for 2 minutes. This prevents the bot from firing on the same price level repeatedly during choppy conditions — one of the most reliable ways to turn a good strategy into a losing one.

Rule 5 — Maximum 2 Concurrent Signals

At most 2 signals across all 6 markets can be open simultaneously. Maximum live exposure at any moment: $6. This is the position sizing rule that prevents correlated losses from all markets moving against you at once.

Rule 6 — Minimum Score of 6

Below 6, no trade fires. A score of 5 is a coin flip. The bot does not trade coin flips.

The Risk/Reward Picture

	Amount
Daily profit target	$10.00
Daily loss limit	$5.00
Risk/reward ratio	2:1
Max trade exposure at once	$6.00
Stake per trade	$1.00

Even at a 50% winning-day rate — which this strategy comfortably exceeds — the account grows over time because of the 2:1 daily reward/risk ratio.

XML / DBot Configuration Structure {#xml-config}

Deriv's DBot platform uses XML blocks to define bot logic. Here is the structural breakdown.

The full annotated XML is in the paid guide. This is the architecture so you understand what to build.

Block 1 — Trade Parameters

<!-- Contract type, market, duration, stake -->
<trade_parameters>
  <market>synthetic_index</market>
  <symbol>R_25</symbol>
  <contract_type>CALL</contract_type>
  <duration>5</duration>
  <duration_unit>t</duration_unit>
  <basis>stake</basis>
  <amount>[DYNAMIC_STAKE]</amount>
</trade_parameters>

Block 2 — Tick Buffer and Direction Tracking

This block reads incoming ticks from the WebSocket stream and maintains a rolling array. Direction is tracked by comparing prices[-1] vs prices[-3]. When direction flips, the previous direction is stored — this is what enables the pullback entry detection.

Block 3 — Indicator Calculation

All four indicators — RSI, Bollinger Bands, Rate of Change, and EMA 5/20 — are calculated from the tick buffer. These are not approximations. The RSI uses the standard Wilder smoothing formula applied to tick-level price data.

Block 4 — Scoring Logic

# Pseudocode — full implementation in the guide

fall_score = 0
rise_score = 0

if rsi > 78: fall_score += 3
if rsi > 70 and rsi <= 78: fall_score += 2
if price >= upper_bb * 0.999: fall_score += 3
if roc < -0.02: fall_score += 2
if direction_flipped_to_down: fall_score += 2
if price == max(prices[-20:]): fall_score += 1

# Mirror logic for rise_score

if fall_score >= 6 and fall_score > rise_score:
    fire_trade("FALL")
elif rise_score >= 6 and rise_score > fall_score:
    fire_trade("RISE")

Block 5 — Safety Limits Check

Runs before every trade. Checks: daily P&L within limits, concurrent signal count below 2, symbol cooldown elapsed, daily signal cap not reached. If any check fails, the trade is blocked. No exceptions.

Block 6 — 3-Trade Execution Loop

# Simplified from actual implementation

for i, offset_pct in enumerate([0.00, 0.04, 0.08]):
    if direction == "FALL":
        barrier = price * (1 - offset_pct / 100)
    else:
        barrier = price * (1 + offset_pct / 100)

    place_contract(
        symbol=symbol,
        contract_type=contract_type,
        barrier=barrier,
        stake=1.00,
        duration=10,
        duration_unit="m"
    )

Live Results — The Evidence {#live-results}

These are the verified results from live session testing on a real Deriv account.

Metric	Result
Total trades	24
Wins	17
Losses	7
Win rate	70.8%
Maximum consecutive losses	3
Account blown	Never
Net result	Positive across all sessions

The maximum consecutive loss streak of 3 is the most important number here. With a 1.8x recovery multiplier and a 4-loss hard stop, a streak of 3 is fully survivable. The account never came close to the loss limit from a single bad run.

Screenshots of the full trade history — every entry, every exit, every P&L — are included in the complete guide.

Important context: 24 live trades is a meaningful sample but not a statistically definitive one. I keep a running live log and update the guide quarterly. The strategy is reviewed and recalibrated every 30 days based on market conditions.

What This Strategy Cannot Do {#limitations}

I will be direct about the limits because a strategy that claims to work in all conditions is lying to you.

It does not work during extreme volatility spikes on synthetic indices. When Deriv's synthetic markets experience unusual price behaviour, the tick pattern becomes genuinely random for a period. Signals still fire — but reliability drops. The 120-second cooldown and the 2-minute session timing rules reduce exposure to these events, but do not eliminate it.

The forex/gold parameters are calibrated for 10-minute contracts. If you change duration to 1 minute or 30 minutes, the indicator settings need recalibration. The signal engine was designed and tested for 10-minute contracts specifically.

Past performance does not guarantee future results. This is not a legal disclaimer I am adding for protection. It is genuinely true. A 71% win rate in verified live sessions is a strong starting signal — not a permanent guarantee. Review your own results every 30 days.

Who This Is For

This strategy is for:

Deriv traders who have tried bots and lost money because they did not understand the underlying logic — now you have the logic
Python developers who want a well-documented, production-ready automated trading system to study and extend
Algorithmic trading beginners who need a working framework with real, verified results rather than theoretical backtests
Anyone tired of Telegram signal groups that charge monthly fees, never explain their methodology, and cannot show a single verified live trade

It is not for people looking for a system that wins every trade. No such system exists. This is for people who want to understand what they are running and why — and who are comfortable with a strategy that is profitable, not infallible.

Get the Complete $47 Guide {#get-the-guide}

The article above is everything you need to understand the strategy. The full guide gives you everything to build and run it yourself today.

What Is Inside

✅ Full annotated XML code — copy, paste, run in Deriv DBot immediately

✅ Step-by-step DBot setup — screenshots of every configuration screen

✅ Complete RSI and EMA implementation in DBot block format

✅ Python bot (v2.0) full source code — runs 24/7 free on Render

✅ Exact stake sizing formula for any account balance

✅ Optimisation settings for V10, V25, V50, and real forex pairs

✅ How to backtest before risking a single dollar live

✅ Live trade history screenshots — every session, every result

✅ Telegram alert setup — monitor everything from your phone

✅ SQLite query templates to analyse your own bot's performance

✅ Troubleshooting guide for the 5 most common DBot errors

✅ 30-day tuning protocol — what to adjust and when

✅ My personal pre-session checklist

The Pricing Logic

$47. One payment. Yours forever. No subscription.

A single winning day on a $500 account following this strategy returns $60. The guide pays for itself before lunch on day one — if it works for you even half as well as it works for me.

If it does not work for you, you have the complete methodology to diagnose exactly why and adjust. You are not buying a black box. You are buying understanding.

👉 Get the Complete Deriv Bot Strategy Guide — $47

Frequently Asked Questions

Do I need to know how to code to use the DBot XML version?

No. The XML guide is copy-paste into Deriv's DBot interface. No coding required.

What account size do I need?

The bot is calibrated for $1 stakes ($3 per signal). A minimum of $50 gives you enough buffer for the risk management rules to function properly. $100–$200 is more comfortable.

Does this work on demo accounts?

Yes. I strongly recommend running it on demo for at least 48 hours before going live. Set DEMO_MODE=true in the Python version to log all signals without placing real trades.

What happens if Deriv's API is down?

The bot handles WebSocket disconnections with automatic reconnection. If it cannot reconnect after multiple attempts, it logs the failure and waits. No trades are placed during connectivity issues.

Can I run this on V75 or V100?

The scoring thresholds were calibrated for V10. You can add V75 or V100 to ACTIVE_SYMBOLS but I recommend first running it in demo on those symbols and checking win rates via the SQL queries in Section 11 before going live.

Is binary options trading legal in my country?

This varies by jurisdiction. Verify that Deriv and binary options contracts are legal in your country before trading. Deriv maintains a list of supported and restricted regions on their website.

About the Author

Precious Anusiem is a Nigerian AI/ML Engineer, SaaS Founder, and algorithmic trader. She has built and published 5 Expert Advisors on the MQL5 Marketplace, developed 5 live AI SaaS products including Dr. Choice (a clinical AI assistant with >90% RAG accuracy) and InvestPropty (an AI fraud detection system that reduced property fraud review time by 96%), and holds certifications from Stanford University, Google, and IBM in Machine Learning, Data Analytics, Cybersecurity, and Generative AI Engineering.

Live Products:

🔗 Dr. Choice — AI clinical assistant

Available for custom bot development, AI product builds, and consulting.

⚠️ Risk Disclaimer: Trading binary options and synthetic indices involves substantial risk of loss. The strategy described in this article is based on verified personal live testing and is provided for educational purposes only. Past performance does not guarantee future results. Never trade with money you cannot afford to lose. This is not financial advice.

I spent 6 months obsessing over MT5 bot logic — here's what finally clicked

Precious Lyna Anusiem — Tue, 21 Apr 2026 01:25:05 +0000

Look, I'll be upfront with you: I'm not a hedge fund quant. I don't have a Bloomberg terminal. I learned MQL5 the same way most of us learn things — by breaking stuff repeatedly at 2am until it started making sense.

This post isn't a "get rich from trading" pitch. It's about the specific engineering decisions that separate a bot that slowly drains your account from one that actually holds up under real market conditions. I want to talk about what I got wrong for way longer than I should have, and what eventually worked.

The mistake I kept making (and I bet you're making it too)

My first few EAs were what I now call "single-factor bots." RSI crosses 30 → buy. MACD histogram turns positive → buy. They backtested beautifully because they were essentially curve-fitted to historical data. Put them live and they'd enter trades during news events, during ranging markets, during sessions with 40-point spreads. They didn't care. They just fired.

The problem isn't that RSI or MACD is useless. The problem is that any single indicator is basically a coin flip without context. Markets are multi-dimensional. A rising RSI in a downtrend during the Asian session with a 35-point spread is a completely different situation than a rising RSI in an uptrend during London open with a 4-point spread. Treating them identically is where bots die.

The shift that changed everything: confluence scoring

After enough blown accounts (demo, thankfully, mostly), I started thinking about entries differently. Instead of asking "did indicator X trigger?", I started asking "how many independent things agree right now?"

The idea is dead simple in code but surprisingly powerful in practice. You define N conditions. Each condition that's true adds 1 to a score. You only trade when the score hits a minimum threshold.

Here's a rough idea of what that looks like in MQL5:

int buyScore = 0;
if(close > trendEMA50)    buyScore++;  // trend direction
if(close > h4EMA)         buyScore++;  // higher timeframe
if(fastEMA > slowEMA)     buyScore++;  // EMA stack
if(macdMain > macdSig)    buyScore++;  // momentum
if(rsi > 40 && rsi < 65)  buyScore++;  // RSI zone
if(adx > 20)              buyScore++;  // trend strength (not ranging)
if(bullishCandle)         buyScore++;  // candle confirmation
if(close > bbMidline)     buyScore++;  // BB positioning

if(buyScore >= 5) openBuy();

This approach has a few things going for it that aren't obvious immediately:

It degrades gracefully. If MACD is giving mixed signals but everything else agrees, you still get a trade — just with one less point. Compare that to a system where a single indicator veto blocks everything regardless.

It naturally filters session and volatility problems. During low-liquidity Asian hours on a ranging pair, your EMA stack condition, your trend condition, and your ADX condition all fail simultaneously. The score doesn't reach threshold. The bot sits on its hands. That's the behavior you want and you didn't have to write a single session filter to get it.

It's easy to tune without blowing up the logic. Want to be more conservative? Raise the threshold from 4 to 5. Want more entries? Lower it. It doesn't cascade into unexpected behavior the way nested if-statements do.

The stop-loss problem nobody talks about enough

Here's something that cost me real time to figure out: a good entry is maybe 30% of the battle. Stop-loss placement is where most retail bots actually lose money.

Fixed-pip stops are almost always wrong. If you set a 30-pip stop on EURUSD and then trade the same EA on GBPJPY or XAUUSD, you're not accounting for the fact that those instruments have completely different volatility profiles. A 30-pip move on gold happens in minutes. On EURUSD it might take hours.

ATR-based stops fix this. You measure the Average True Range over N periods and set your stop as a multiple of that. If ATR is currently 80 pips, your 1.5× ATR stop is 120 pips. If ATR is 20 pips (quiet market), it's 30 pips. The bot adapts automatically.

The same logic applies to take profit. I use a 2:1 ATR ratio minimum (TP = 2× ATR, SL = 1× ATR). Some of my configs use 3:1 for trending pairs. It makes a bigger difference than most indicator tweaking ever will.

One thing that genuinely surprised me

I added an ADX filter expecting it to just cut trade frequency. It did. But what I didn't expect was the effect on average winner size.

ADX above 20 means the market is in a trending state. When you filter for that, your winning trades aren't just more frequent — they tend to run further because you're catching moves with actual momentum behind them rather than random noise that briefly crossed your other conditions.

It felt like one of those "why didn't I do this earlier" moments. The bot wasn't missing good trades, it was skipping ones that were statistically more likely to reverse immediately.

What I ended up building

After going through all of this (and a lot of iterations I haven't mentioned), I ended up with a fairly complete EA that does most of what I described:

9-factor confluence scoring, configurable threshold
ATR-based dynamic SL/TP with user-set multipliers
Automatic breakeven once price moves 1 ATR in your favour
Trailing stop based on ATR distance
Daily loss limit and profit target (as % of balance)
Weekly drawdown kill-switch
Session filters (London, New York, Asia toggleable)
Spread filter to avoid trading during news or low liquidity
Proper margin checking before opening trades

I put it together as GlimTrader Pro v3.0 and made it available as a compiled .ex5 — you can grab it here if you want to skip the six months of headaches.

Stuff I'd tell myself on day one

Don't trust backtests with default settings. Optimize on one date range, validate on a completely different one. If performance falls apart, you've overfit.

Your broker's spread matters more than you think. An EA that works at a 1-pip spread will look completely different at 4 pips. Build a spread filter.

Lot sizing based on account % is not optional. Fixed lot sizing turns a drawdown into an account wipe. Risk 1% per trade max while you're learning the system.

Demo trade for at least 3 weeks before going live. Real execution has slippage, gaps, disconnects. The backtest doesn't.

If you're going through the same frustrations I went through, I hope this saves you some time. The confluence approach genuinely changed how I think about automated entries. Worth experimenting with even if you build your own version from scratch.

Happy to answer questions in the comments—particularly around the ATR logic or the scoring approach.