What We're Actually Running Live: USDJPY IPDA CE on cTrader

Most strategies die in research. This one made it all the way to live execution.

The blog went quiet for a bit because the work stopped being rhetorical and started becoming operational. We were rebuilding the cTrader stack, auditing the old FTMO carcass, smoke-testing order placement, fixing systemd rot, wiring notifications, and making sure the thing would still be there after a reboot instead of vanishing like a weekend conviction.

So here is the clean version: this is the strategy we are actually running now.

Not a thesis. Not a wishlist. Not a simulated portfolio of beautiful lies.

A live stack. Demo capital for now, real execution path, real cTrader bars, real order placement and cancellation, real monitoring, and a strategy simple enough to survive contact with reality.

The Short Version

The strategy is IPDA CE on USDJPY:

• detect 30-minute fair value gaps
• enter at the consequent encroachment (the midpoint of the gap)
• only trade during London Open and New York Open
• only take longs in discount and shorts in premium
• reject stale setups that are too far from current price
• place pending limits through cTrader, then sync broker state back into the local risk engine

At the validated 1:1.6 geometry, the USDJPY log we are using showed:

• 368 trades
• 55.4% win rate
• PF 2.25
• +1959.9 pips

That does not mean it is invincible. It means it survived enough skepticism to earn live oxygen.

Why This One, Not One of the Other Corpses?

We tested a lot of nonsense. Some elegant nonsense. Some very expensive nonsense.

A few things looked brilliant until they met fees. Others looked robust until we forced them through walk-forward splits. Others were never even wrong — just vague enough to keep sounding clever while producing no tradable edge.

The surviving CE landscape ended up looking like this:

• XAUUSD had the best research profile
• USDJPY had the best mix of edge, operational simplicity, and cTrader readiness
• EURUSD had history, but too much infrastructure baggage and too little current love

That distinction matters.

XAUUSD was the research champion. USDJPY became the operational champion.

When you are trying to get a live system back on its feet, the winner is not always the pair with the prettiest headline PF. It is the pair that still looks good once you include execution, fills, session behavior, stack maturity, and the psychological cost of babysitting it.

What the Strategy Actually Does

There is no secret sauce here. The whole point is that the logic is understandable.

1. Build 30-minute structure from broker bars.
2. Detect valid fair value gaps.
3. Compute the CE level.
4. Ask whether the setup is aligned with the current premium/discount regime.
5. Ask whether the setup is happening inside the allowed sessions.
6. Reject stale or distant gaps.
7. Place a pending limit order if the setup survives all of the above.

That is the core of it.

The real lesson from too many dead strategies is that complexity likes to cosplay as depth. Trading systems rot when you keep adding extra “intelligence” to protect yourself from variance and end up strangling the edge instead.

The Session Filter Is Not Decorative

This part deserved a sanity check before we went live because the instinct says:

“USDJPY is an Asian pair. Shouldn’t we be trading Asia?”

The data says: not so fast.

And the validated trade log makes it more explicit:

London Open was not merely acceptable. It was the stronger leg of the strategy.

On the validated USDJPY 1:1.6 trade log:

• London Open: 157 trades, 59.2% WR, PF 2.92, +1192.9 pips
• New York Open: 211 trades, 52.6% WR, PF 1.81, +767.0 pips

That is the interesting heresy.

A JPY pair does not automatically belong to the Asian session just because the quote has Japanese characters in its ancestry. Strategies do not care about our aesthetic theories. They care about where the edge clusters.

For this setup, London matters more than intuition.

Backtest Clock and Live Clock Match

This was the first thing worth checking before trusting any live behavior.

We already had a painful lesson in timezone drift almost killing a profitable strategy. So this time the rule was simple: no hand-waving, no “probably close enough.”

The sanity check came back clean:

• the backtest session logic uses UTC explicitly
• the live session logic uses UTC explicitly
• the cTrader bar conversion uses the broker’s UTC trendbar timestamp, not the broker schedule timezone label
• London and New York windows are treated the same way in both paths

So the live stack is not secretly drifting because the machine is in one timezone, the broker labels sessions in another, and the human operator lives somewhere else entirely.

That sounds boring. Good. Boring is what you want from time handling.

What the Live Stack Looks Like

A strategy is not live because you can print a signal to stdout. A strategy is live when the entire path from data to order to recovery is real.

The stack now does four things that matter:

• fetches USDJPY bars directly from cTrader
• computes the signal logic locally
• places and cancels real pending orders through cTrader
• syncs state back from the broker so the risk engine is not hallucinating positions

That last part matters more than people think. Plenty of “live” bots are just signal generators attached to prayer. If the local state and broker state diverge, you are not automating a strategy. You are automating confusion.

We Smoke-Tested the Plumbing Before Arming It

Before enabling the timer, we did the obvious adult thing:

• place a tiny far-away USDJPY pending order
• verify the broker accepts it
• cancel it cleanly
• confirm the order is gone
• confirm open orders and open positions are both zero afterward

This is not glamorous, but it is the difference between “we went live” and “we discovered in production that our broker adapter was fan fiction.”

The smoke test passed the gut check:

• order accepted
• order visible
• order cancelled
• broker sync clean afterward

That was enough evidence to arm the timer.

The Operational Bits We Refused to Ignore

A live strategy that dies on reboot is not live. It is a desktop toy with ambition problems.

So the cTrader stack now has a few properties that matter more than one more decimal place of backtest PF:

• systemd timer for 30-minute execution
• persistent missed-run replay after reboot
• linger enabled so the user service manager survives restarts without waiting for a manual login
• broker reachability probe before each cycle
• retry loop with backoff for transient outages
• Discord notifications for fills, cancellations, and runtime failures
• heartbeat monitoring checking the timer, logs, and broker sync every few hours

This does not make the system immortal.

It makes it less stupid.

That is usually the real job.

Why We Kept It Simple

There was a temptation to stack more cleverness on top of CE:

• more gating
• more sub-filters
• more regime logic
• more dynamic exceptions
• more “adaptivity”

That road has a bad smell because we know where it leads: strategies that look more sophisticated as their real edge quietly evaporates.

The version we kept has a cleaner philosophy:

• simple setup definition
• honest session filter
• distance gate to avoid stale nonsense
• clear risk geometry
• tight operational plumbing

If a strategy cannot survive that level of simplicity, it usually does not deserve production complexity as life support.

The Honest Caveat

We are not claiming victory from one clean deployment.

This is the strategy we are running because it passed more skepticism than the alternatives, not because reality has signed a permanent endorsement contract.

Three things can still go wrong:

1. Live execution drag can shave more edge than expected.
2. Regime change can turn a strong session profile into a mediocre one.
3. Operational mistakes can still do damage even when the signal is fine.

That is why the stack matters almost as much as the signal. If the strategy degrades, we want to know whether the culprit is:

• the idea,
• the execution,
• the session choice,
• or the infrastructure.

Without that separation, every loss feels like philosophy instead of diagnosis.

Why This Post Exists

The blog had gone quiet because the work moved from idea generation into the less photogenic phase: wiring, auditing, smoke tests, retries, timers, alerts, and boring correctness.

But that boring correctness is the story.

A strategy is not interesting because it produces a chart in a notebook. It becomes interesting when you trust it enough to let it place a real order, survive a reboot, recover after the network sneezes, and tell you what it did afterward.

That is where research stops being decorative.

That is where it starts costing something.

And that is where we are now.

---

Related reading: Starting from the End for the Monte Carlo view of prop-style survival, A Timezone Bug Almost Made Me Abandon a Profitable Strategy for the timestamp paranoia that shaped this deployment, and 31 Strategies Tested, 4 Survived for the graveyard this one had to escape.