Our trading system had a Sharpe ratio of 4.29.
Most hedge funds are thrilled with 1.5. We had 4.29 -- a number that, on paper, says the system is working. That the edge is real. That we should be printing money.
Our actual average profit per trade was negative $2.68.
This is the story of how we found the leak, built a fix in Python, and what happened the first time we tested it.
The Ghost in the Numbers
When a system has a Sharpe ratio that high but still loses money, there's exactly one place to look: exits.
Entries we had. The PCS (Predictive Convergence System) signal was clean -- market structure analysis, momentum confirmation, high-probability setups. The entries were doing their job.
The exits were destroying the profits before they could land.
The data point that made this undeniable was Maximum Favorable Excursion, or MFE. This metric answers a simple question: during this trade, how far did price move in our favor before we closed it? It's the unrealized profit that was sitting inside each trade at its best moment.
Our MFE average: $114 per trade.
Our actual captured profit average: -$2.68 per trade.
That's a gap of over $116 per trade -- evaporating consistently, across every setup, in every session. The market was giving us the move. We were giving it back.
The culprit was our exit system: a flat 8-point hard stop, no dynamic management, no ability to let a winner breathe. Once a trade was on, it either hit a fixed target or got clipped. No middle ground.
We were running a sophisticated entry engine attached to a blunt hammer for an exit. So we built something better.
Enter Bobby
Bobby is a Python-based trade manager. It doesn't generate signals -- that's PCS's job. Bobby's entire purpose is to manage what happens after the entry: how the trade breathes, when it's protected, and when it's allowed to run.
The core design philosophy came from a simple insight: trades are not all the same. Some should be scalped. Some should be held for the big move. Deciding which before the trade opens is guesswork. Deciding in real time, based on what the market is actually doing, is management.
Bobby manages trades through a three-tier exit system.
The Three-Tier System
Tier 1: Survival
The first job of any trade is not to profit -- it's to survive.
When a trade opens, Bobby enters Survival mode. The original stop is in place. Bobby is watching for the trade to reach a small profit threshold that confirms the market agrees with the direction. Until that confirmation comes, we don't touch the stop. We wait.
This sounds passive, but it's doing something critical: it's giving the trade room to breathe without immediately exposing it to the full-width stop if it never confirms. It's the difference between disciplined patience and blind hope.
Tier 2: Lock-In
Once the trade clears the Survival threshold, Bobby shifts to Lock-In mode.
The stop moves to breakeven (or slightly above entry). We're now in a risk-free position -- the trade can close at worst at even. But Bobby doesn't just park the stop at breakeven and walk away. It calculates a dynamic trailing buffer based on recent price structure: ATR-derived spacing, swing levels, the kind of breathing room this particular market needs right now.
The goal is clear: we cannot lose on this trade. But we can still run it.
Tier 3: Runner
If the trade extends meaningfully beyond the Lock-In zone, Bobby switches to Runner mode.
The trailing stop widens. The target expands. Bobby is now managing for a potential high-magnitude move -- the kind of trade that can define a week's P&L in a single entry.
This is the tier the old fixed-stop system could never reach. Trades were getting clipped before they had the chance to become runners. The 8-point stop wasn't just a risk management tool -- it was a ceiling on profits that we didn't realize we'd built.
The First Trade. One Tick from Nothing.
The first trade Bobby managed in replay testing became the proof-of-concept moment.
Under the old system, this trade had been stopped out. The market hit our 8-point stop, we got kicked out with a loss, and the market then moved 21 points in our direction.
How close was the stop? One tick. A single quarter-point move against us triggered the exit. Then price turned and ran.
Over a thousand dollars of move on a single ES contract -- and we captured none of it.
In the replay with Bobby managing the trade, the same tick-against us occurred. But Bobby's Survival mode dynamic buffer didn't trigger on a one-tick excursion. The trade stayed open.
Price confirmed direction. Tier 2 Lock-In engaged -- stop to breakeven.
Price extended. Tier 3 Runner engaged -- trailing stop widened, target expanded.
The trade that was stopped out for a loss under old management rode through the dip, survived, and captured a substantial portion of that 21-point move.
Same entry signal. Same market data. Same tick-by-tick price action.
Different management. Completely different outcome.
Week 1 Replay: The Numbers
Three trades. One contract. One week of historical data.
| Metric | Old Management | Bobby |
|---|---|---|
| Trade 1 | Stopped out (1-tick), missed 21pt move | Tier 3 Runner, captured significant portion |
| Total P&L | -$40 | +$231 |
| Swing | -- | +$271 |
-$40 old management. +$231 with Bobby. A $271 swing.
This isn't a backtest with optimized parameters. This is replay trading -- real historical tick data, real order execution simulation, real trade-by-trade documentation. The entry signals were identical. Only the exit management changed.
The MFE gap is closing. The Sharpe ratio of 4.29 was always telling us the system had an edge. Bobby is finally letting that edge get paid.
What This Is -- and What It Isn't
A few honest caveats, because they matter:
This is one week of replay data.
One week is not a statistically complete sample. We need more trades, more market conditions, more volatility regimes. We're building that data set now.
Replay isn't live trading.
Slippage, liquidity, and execution conditions in live markets will differ. We're accounting for this in our parameter design, but it's a real factor.
Bobby doesn't predict the market.
It doesn't know where price is going -- it manages what's already happening. If the trade fails, Bobby manages the loss. It doesn't prevent losses, it sizes them properly while maximizing what good trades can return.
What this is: a documented, reproducible demonstration that the MFE gap we identified is real, that it's caused by exit management, and that a systematic, dynamic exit system can close a meaningful portion of it.
The mechanism is proven. The work now is validation at scale.
The Technical Architecture (Brief)
For the developers reading this -- Bobby is built in Python, event-driven, running on tick data. Key design decisions:
- --Event-driven, not polling. Bobby reacts to each tick, not on a fixed interval. Trade management decisions happen in real time.
- --ATR-based buffers. The Survival and Lock-In tier thresholds scale with current volatility. A low-volatility session and a high-volatility session get appropriately sized breathing room.
- --No curve-fitting on tier parameters. Thresholds were derived from the MFE distribution analysis -- where did trades historically show confirmation? Where did they begin to run? The data drove the tiers, not wishful thinking.
- --Separation of concerns. Bobby doesn't know about PCS's entry logic. It receives an entry event and takes over from there. This keeps the systems modular and independently testable.
A future post will go deeper into the code architecture. For now, the important thing is that it works -- and why it works is explainable.
What's Next
We're running Bobby across a longer historical window -- different seasons, different volatility environments, trending vs. choppy conditions. The 3-tier structure needs to prove it's robust, not just right for one particularly good week.
Parameters will be stress-tested. We're not looking for perfect -- we're looking for consistent.
After sufficient replay validation: paper trading. After paper trading: live capital, starting small.
Every step gets documented here. Real P&L, real trades, the ugly weeks alongside the good ones.
If you're building something similar -- especially if you've hit the same MFE gap problem -- the comment section is open. This problem is more common than most systematic traders like to admit.
The system was right the whole time.
Bobby just taught it how to get paid.
Disclaimer: This content is for educational and informational purposes only. Nothing here constitutes financial advice. Trading futures involves substantial risk of loss.