I have quite often read something akin to “when you simulate trading for a sub-hour timeframe you should try to use more precision, but above that the mid-price entry assumption is sufficient for model development”.

Let me offer a heart-felt warning that I am sure will not surprise anyone who has followed this publication.

For strategies operating in the High Frequency to Medium Frequency space, real spread simulation with latency is treated, rightly, as the absolute minimum. The claim I want to puncture is: that above that timeframe, for longer hold times — hours, days, weeks — the mid-price assumption becomes sufficient.

No doubt at that timeframe slippage precision accounts for less. But is it immaterial? I could argue here invoking my own writing as to how the shape of a good trade and a bad trade differ, or that the price itself we get on entry is paramount. But the strongest counter-arguments are more mechanical, and much simpler.

Spreads are non-uniform

Say you have thousands of mid prices in your feed, and the model assumes entry on 20 of them1. Even if the average spread for the instrument is just above a tick, what gives you any confidence that you are not entering or exiting exactly on the odd mega-wide spread?

And your slippage numbers from other models don’t come to the rescue — they just muddy the water further. You would need a slippage distribution for exactly this model constellation. And even if you had it, you adjust one parameter in your model and you need a completely fresh one. No bueno.

There is no static cost you can measure once and bolt on afterwards, because the slippage is a property of the specific strategy.

And then the model finds the edge...

Now imagine you are talking to an AI/agent to do most of the modeling and data fetching for you. You are extremely pragmatic, and know the drill — variety of models working together, in-sample out of sample, stochastic seeds and the lot — you trust nothing but confirmed real numbers. The broad arch of the request is: find me alpha that is the most consistently profitable across the periods. Bit by bit, byte by byte your model homes in on a strategy you know is — just too good to be true. Days and weeks pass staring at the impressive results — again and again it is confirmed. But you are a seasoned professional, and on this timescale — holding periods of a few hours to a few days — that seems very unlikely.

The model learned, through a variety of features, how to find the widest-spread entries and exits.

No amount of post-fact slippage or spread modeling will offset it, because the strategy was selected for the very moments where the mid lies most. Another rabbit hole. For the less doubtful, it could have resulted in real money lost, of course.

None of this scenario needs AI. It is just a simple modeling fallacy — the mid-price assumption.

A big dent in limit executions

I already mentioned execution slippage — but if you intend to use limit orders at any point, or if you (like many others in the space) separate model development from execution, the news is worse still.

With a market order the execution is all but guaranteed; the actual cost becomes the big question mark. A limit order, on the other hand, can save you from this unruly slippage; but you may simply miss the fill. The mid-price assumption quietly grants you both — you fill, and you pay nothing — not something that real execution will ever allow. And on the limit side the failure isn’t a worse price, it’s a missing fill. Whether it happens on entry or exit, the strategy is now on a new path, and the outcomes have been irrecoverably altered.

Easy fix: just tell the AI to calculate the spread

In the proverbial AI model-development scenario, the immediate fix is quite easy: just ask your AI companion politely to use the opposite side — Bid/Ask — for the execution price. Please. And always. It is an order! (Stop being so damn polite with your AI tool. Really!)

Does it solve the limit order problem? Not fully. And is that as good as having latency simulation also? No, of course not. But it is still much, much better than a pure mid-price assumption.

Over the next week, NVIDIA price drifts up. Nothing dramatic — no single trade you could point to, no name attached. A few accounts add on quiet days. By the time the ruling is public, the stock has already travelled most of the distance, and the announcement barely moves it.

Is that market efficiency?

The consensus view

The traditional story calls any price move that happens before public absorption “information acquisition,” and treats it as a sign of markets functioning correctly. The less the market jumps on such announcements, the healthier and smarter the market was to begin with.

This assumption is the basis of a subsequent discrimination. The process that helps this early absorption — the research that goes into predicting such information — is considered a force for good. The predatory HFT snipers that detect these footprints and erode such profits are cast as the malevolent actors: they rob the researcher of profits that would have gone into further honest research. So goes the story according to Weller, and many after him. He, in fact, plainly concludes that algorithmic trading reduces information acquisition — that HFTs harm price discovery1. A recent paper refines the story, arguing that it is the sniper HFT who is the malevolent actor, while the liquidity-providing kind is still a force for good2.

The problem with all of the above is that it assumes the early knowledge of future information was acquired completely honestly. Neither Weller nor those refining him mention insider trading — the politician, the entourage, the industry insiders, those who have been tipped off, those who have traded insider knowledge between them so that no single trade is traceable. Their arguments only work if the “illegitimate” share of knowledge acquisition is effectively zero. But is this really the case?

The ugly reality

It is not, and the evidence is not hard to find.

In the options market, informed trading ahead of public announcements is a measured fact. In a study of 1,859 US takeovers, roughly a quarter showed abnormal options activity before the deal became public — concentrated in short-dated, out-of-the-money calls, the cheapest way to bet on a jump you already know is coming3. Over half of that activity could not be explained by speculation, rumor, corporate-insider filings, or any other legitimate source. So: suspicious informed trading in a quarter of deals, roughly half of it unexplainable — and the SEC litigated about 8% of the deals in the sample. The overwhelming majority is never touched. And that is likely only scratching the surface.

The same pattern is visible in plain sight in Congress. In 2024, dozens of members — from both parties — outperformed the S&P 500, which returned about 25%. Nancy Pelosi’s disclosed portfolio was up roughly 71%; she has defended the practice as participation in a “free-market economy.” Tommy Tuberville and Marjorie Taylor Greene have been among the most actively tracked traders on the Hill, their timing repeatedly flagged against the committees they sit on. Ro Khanna, who leads the push to ban congressional trading, doesn't trade himself — his wife's trust is among the most active in Congress, and the bills he has championed stop at the member. The bill that passed the House yesterday does finally cover spouses4; it also lets everyone keep what they already hold. Around a hundred members trade actively, and year after year a substantial share beat the market they help write the rules for. The names span both parties, both chambers, and most committees. This is not name slinging, or if so, it is slinging both ways.

Now hold that number against everyone else. When honest retail traders do the research themselves, the results are brutal: across the largest studies — the entire Taiwan Stock Exchange over fourteen years, every new day trader in Brazil over several years — around 80% lose money, and fewer than one in a hundred is consistently profitable5. Research, it turns out, is hard; that is what the data says about people actually doing it. Yet a body of roughly a hundred people who happen to write the policy hits about 50% success rate. The parsimonious explanation for that gap is not that legislators are eighty times better analysts than everyone else. It is that they are doing something else.

The failed assumption

Since the dishonest share of information acquisition is not zero, the labelling and the moralizing should also not be absolute. Whether the early move comes from a genuine research finding inside Fidelity or from the nephew of a Congressman’s driver, the price absorption is indistinguishable. It turns out that when the sniper HFT erodes this illegally obtained advantage, he may actually be doing the market a favour. In this case it is a tax on the insider.

And it is not only the sniper the metric mislabels. For insider trades, the price is not supposed to move until the announcement. So the unmoved price the papers call a failure is exactly what should happen. The jump, when it comes, is the correct outcome — not a sign the market was slow, but the opposite.

The failure of the moral lens

Don’t mistake me — I am not saying that insider trading is fine; it should just be absorbed differently. Nor am I saying that HFTs are somehow redeemed from any wrongdoing.

My issue is that the literature has completely disregarded an inefficiency in the “real world” that redefines the problem right from the get-go: the reality of insider-like trading. On the HFT question I do believe researchers have set out to decide, empirically, whether HFT is good or bad. And in that quest they have forgotten to check their assumptions fully.

As with everything, we should not try to decide whether HFT is good or bad, but whether certain practices are useful or not, and if so to what extent.

The only practice that can be condemned outright is the insider-like trading — unambiguously, and in a bipartisan way.

Suppose the gates behind you are passed. The numbers were honest. The edge is real — you can say who pays you and why. There is one gate left, and it is the one where the invoice arrives: you are cashing in — or out. This is where the model finally touches the market, and the issue takes its title from what happens next.

Rob Carver spent seven years at AHL and has run his own fully automated futures system, on his own money, since 2014. He has sat in both seats this problem has — the institutional one and the kitchen-table one — which is why his answer to it is structural rather than motivational.

He wrote this piece in 2014, and I have deliberately not asked him to update a word, because the intervening decade is the argument. We now have tools that will write a working backtest in an afternoon. The temptation to promote that artifact into production has never been stronger, and the gap Carver describes — between code that simulates and code that runs — has not moved an inch. The backtest got cheap. Production didn’t. And my suggestion to read this piece as if it was written today, in the age of “AI confusion”.

The intro above is mine; everything below the line is his, untouched, from where it first appeared.

by Robert Carver published at This Blog is Systematic, on Monday, 8 December 2014

Running a fully automated trading strategy requires very little time. Apart from the 6 months or so of flat out coding you need to do first of course. Before doing this coding there is a chicken or the egg question to resolve. Do you write backtesting code and then some extra bits to make it trade live, or do you write live trading code which you then try and backtest?

Some background

If you haven’t had the pleasure of writing an automated trading strategy, perhaps because you use prebaked software like “Me Too! Trader“ or an online platform such as https://www.quantopian.com/1, you may wonder what on earth I am talking about.

The issue is that there are two completely different user requirements for what is usually one piece of software. The first user is a researcher. They want something highly flexible that they can use to test different, and novel, trading strategies; and to simulate their profitability by “backtesting”. Any component needs to be interactive, dynamic and easy to modify.

The next user - lets call them the implementor - does not rate flexibility, indeed it may be viewed as potentially dangerous. They want something that is ultra robust and can run with minimal human intervention. Every component must be unit tested to the eyeballs; modifications should be minimal and rigorously tested. Interaction is strongly discouraged and should be limited to reading diagnostic output. The code needs to be stuffed full of fail safes, “what ifs?”, and corner case catchers.

Ultimately you won’t benefit from a systematic trading strategy unless both users are happy. You will end up with a product which is either untested with market data and which may not be profitable (unhappy researcher), or with one which should be profitable but is so badly implemented it will either crash daily or produce fat finger class errors and buy 10e6 too many contracts (unhappy implementor).

Weirdly of course if, like myself, you’re trading with your own money these users are the same person!

Ideas have to be tested

In the vast majority of cases the backtest code comes first, for the same reason that when it comes to building a new car you don’t just weld together a bunch of panels and see what they look like; you get out your little clay model (or in this less romantic world, your CAD package). Pretty much every design discipline uses a ‘sandbox’ environment to develop ideas. Important fact: The people playing in the sandpit aren’t usually professionally trained programmers (including yours truly).

Either in a greenfield corporate context, or if you are developing your own stuff, the first thing you will do is write some code that turns prices or other data into positions; and then a little routine to pretend you were actually trading live in the past to see how much money you did, or didn’t make.

If you’re sensible then you might even have some of your core mathematical routines tidied up and unit tested so they are properly reusable. You can try and modularise the code as much as possible, so running a different trading rule just involves repointing one line of code. You could get quite fancy and have code that is flexible and is configurable by file or arguments, rather than “configuration” by script. Your simulation of backtested performance can get quite sophisticated.

At some point though you’re going to want to run real money on this.

Productionization - bringing in the grownups

This simulation code isn’t normally up to the job of running with real money. In theory all you need to do is write a script that runs the simulation every day / hour / minute and then another piece of code that turns the output of that into actual real live trades.

I suspect most people who are running their own money go down this path. However I would estimate that only 10% of my own code base (of which more in a moment) is needed to run a simulation. What that means in practice is you start with code that isn’t sufficiently robust to run in a fully automated way (because it’s missing most of the other 90%) and if you’re lucky you end up with a vast jerry built structure of things tacked on when you realise you needed them.

If you are trading your own money and not interested in the machinations of corporate fund management politics you’ll probably want to skip ahead to ‘Two systems’.

Alternatively what tends to happen next in a corporate context is some proper programmers get brought in to productionize the system. The simulation code is normally treated as a specification document, and a seriously incomplete and badly written one at that, rather than as a prototype. The rest of the spec, which is the stuff you need to do the 90%, then has to be written by the implementor.

The result is a robust trading systems but one on which it’s now impossible to do any research. The reason why it’s are that it’s very hard to unpick the 10% of code that can be mucked about with, muck about with it and then re-run it to see what will happen.

When lunatics run the asylum: need for innovation

What usually happens next is that the research user comes up with some clever idea that the solid monolithic tank like existing production code isn’t capable of doing. Given that most quant finance businesses have an oversupply of clever people with clever ideas, and an under supply of people who can actually make things work properly, they will then be faced with a choice. Either wait for many months for some programming talent to become available, or try and twist the arm of management to let them implement the simulation system with real money.

Most quant finance businesses are run by quants (Which you might think is the natural order of things. But being very clever and insightful AND being a great business person are quite unusual skills to find in the same person. Perhaps it is sometimes better to have the business run by a glorified COO whilst you stick to what you’re good at, which is usually the cool and fun stuff. Tech company bosses also take note). Which means that the simulation system ends up being used to trade real money, despite this being an insane idea. By the way having quants in charge is also why there is an under supply of builders AKA programmers versus architects AKA researchers in these businesses. That and separate reporting / manpower budget lines for CTO’s.

Anyway the bottom line is that rather than modify the existing production code to do the new new thing the programmers then often have to work with a hacked up backtest pretending to be a swan like production system. But because this is actually running real money it’s treated more as a prototype than a badly written spec. This means a lot of crud gets ported across into the production system, and the process of productionizing takes a lot longer.

Eventually we end up with a robust system again. Until that is some bright spark has another clever idea, and the cycle begins again.

Two systems: An aside on testing and matching

One way - indeed the best way - of dealing with this is to keep your two code bases completely separate. Once your bright idea is fully developed then you show the programmers your code. After laughing hard at your pathetic attempt they then incorporate it into the production system. You then continue to use your simulation code

You can also do this as an individual, although you probably won’t laugh at your own code, not if you’ve just written it anyway. As an individual programmer and trader having to maintain two systems is also a serious time overhead, but ultimately worth it.

Back in the corporate world an obvious problem with this is you still have the bottleneck of needing enough programmers to keep up with the flow of wonderful ideas. However at least they aren’t wasting their time trying to deal with hurriedly rewriting cruddy simulation systems that are already running real money before they blow up.

A slight problem with this is that you have created two ways to do something. Corporate types running systematic fund businesses have an unhealthy obsession with things being ‘right’. You have to prove that the position coming from your production system is ‘right’. If you have a simulation the most obvious way of doing this is to run that and crosscheck them. In this way the simulation becomes a glorified integration test of the production code.

This is a recipe for tens of thousands of person hours of wasted time and effort trying to work out why two are slightly different. This is completely stupid. For starters there is no ‘right’. All trading rules are guesses anyway. Under this logic a trading rule that did exactly what it was ‘supposed’ to do, but lost a billion dollars would be better than one which was a bit wayward but which made the same amount in profit.

Second of all this is a very stupid way of testing anything. You should have a spec as to what the trading system should do. In case it isn’t obvious, I don’t think the simulation code should be the spec. At best it’s a starting point for writing the spec. But should you reproduce a bug in the simulation if it isn’t what was intended? No. You should find out what’s intended, write it down, and that is what you should implement. You then write tests to check the production code meets the spec. And mostly they should be unit tests. This is very obvious indeed to anyone working in any kind of other industry where you build stuff after prototyping it.

Production first?!?!

When it came to writing my own trading system about a year ago I did something radical. Since I knew exactly what I wanted to implement, I just sat down and wrote the production code. Of course I was in the unusual position of having already designed enough trading systems to know what I wanted to do, albeit in a corporate context and I had never written an end to end production system before.

I don’t think writing production first is unattainable even if you don’t know exactly what you’re going to do. If you have the pleasure of working in a greenfield setting you have two main jobs to do. The first is to write a production system, and the second is to come up with some new and profitable ideas. Don’t wait until you’ve come up with ideas to hire your proper programmers, hire them now. Get them to code up a simple trading rule in a robust production system. Meanwhile you can do your clever stuff. Occasionally they will come and confront you with questions, and hopefully this will will force you to direct your cleverness in the direction of clarifying what your investment process might end up being.

Similarly if you are writing your own stuff then it might be worth coding the simplest possible production system first before you do your research. You could even do both jobs them in parallel. It’s quite nice being able to shift to doing some hard core econometrics when you’ve been coding up corner cases for trading algorithms, and some mindless script writing can be just the ticket when you are stuck for inspiration and the great trading ideas just aren’t coming.

If your code is modular enough you should be able to subsequently write the simulation code from production rather than vice versa. The simulation code will just be some scaffolding around the core trading rule part of your production code (the 10% bit, remember?).

With my own system I did get round to doing this, but only after I’d be trading for 6 months. But to be honest I don’t really run my simulation code that much, and I certainly don’t check it against my production code. It’s only used for what it should be used for - a sandbox for playing in. If I come up with any new ideas then I’ll then have to go and implement them in the production code. So I am firmly in the two system world, although I approached it from the other direction than what we normally see.

Nirvana?

No not the early 90’s grunge band, but the idea of some perfect system existing that can do both. A giant uber-system which can meet both requirements. I don’t think such a nirvana is attainable, for a couple of reasons. Firstly the work involved is substantial - I would estimate at least four times as much as developing a separate production and simulation system.

Secondly, in a corporate context, there is usually too big a disparity in the needs of different users particularly on the research side. Often there is a temptation to over specify the flashy aspects of the project, such as the user interface having lots of interactive graphics. This often happens because the senior managers with the authority to order such large IT projects haven’t done much coding for a while and need more of a point and click interface.

Small steps

I don’t believe in the fairy story of ‘one system to rule them all’. Instead I believe that two systems probably works best, but with some sensible code reuse where it makes sense. Here are some of the small steps you can take.

As I’ve already mentioned your core utilities, like calculate a moving average*, should be shared, and tested to death, so you can trust them.

* Okay bad example, since I get pandas to do this for me. But you get the idea.

You can’t possible reuse code unless you have good modularity. The wrapper around the 10% of my production code that is reusable for simulations looks like this:

data1 = get_live_data_to_do_step_one(*args for live data)

config1 = get_live_config_to_do_step_one(*args for live config)

diag = diagnostic(* define where live diagnostics are written to)

output1 = do_step_one(data=data1, config=config1, diag=diag)

data2 = get_live_data_to_do_step_two(*args for live data)

config2 = get_live_config_to_do_step_two(*args for live config)

output2 = do_step_two(output1, somedata=output1, moredata=data2, config2=config2, diag)

Hopefully I don’t need to spell out how the simulation code is different, or how it would be hard to replace step one with a different step one in a research context if the code wasn’t broken down like this.

Try and separate out the parts that do all the corner case and type testing from the actual algorithm. The latter part you will want to play with and look at. This does however mean you can’t have a simple ‘doughnut’ model of production and simulation code, where there is just a different ‘scaffolding’ around a core position generation function (which I realise is what my pseudo code implies...). It needs to be more dynamic than that.

Don’t make stuff reusable for the sake of it. For example I toyed with creating a fancy accounting object which could analyse either live or simulated profitability. But ultimately I didn’t think it was worth it, just because it would have been cool. Instead I wrote a lot of small routines that did various small analysis, that I could stick together in different ways for each task.

As well as code reuse you can also have data reuse. It doesn’t make any sense to have two databases of price data, one for simulation and one for live data. If there are certain prebaked calculations that you always do, such as working out price volatility, then you should have your production system work them out as often as it needs to and dump the results where the rest of your system, including your simulation code, can get it.

Go forth and code

That’s it then. Hopefully I’ve convinced you that the two system model makes sense. Now if you will excuse me I’m going to go and hack some back testing code ....

Read the original piece here. Just as enjoyable as the first time.

You may explore the entire archive, which is live and well — and fully up-to-date here:

https://qoppac.blogspot.com

“Past returns are not indicative of future performance?...”

“No, that phrase is only really about liability”, the mindreader smiled.

I am talking about something different.

The characteristics of a strategy and the outcomes of a strategy are not the same. The counterparty it normally matches with, the flow and volatility it feeds on, the market constraints it exploits, even the way it misses the prediction — those are characteristics. Often meaningful ones. The equity curve, and most of its descriptors, are an outcome. A few P&L-metrics reach over into characteristics — Sharpe, Sortino, MaxDD and so on — and those can earn their keep. But as long as they depend on the P&L, they are a supporting act in a play where the market prima donna takes center stage.

Deconstructing your strategy results

The strategy outcomes — the P&L and its derivatives — are made up of edge plus noise, plus regime, plus luck. The sum produces the number you are measuring. The decomposition is immensely difficult.

Decomposing noise from the market itself is hard. In a strategy result, more so.

Regime? If you have tried defining regimes in your strategies, I bet the memory alone brings cold sweat. As the saying goes: “I have the perfect mean reversion system, and a stellar trend follower. I just don’t know when to switch.”

Luck is what is left after you discard the rest.

So the job is to focus on the edge. Still extremely elusive — we mostly don’t even try to quantify it precisely, but ask: is there any? Is there enough?

Does your strategy actually have an edge?

And that is directly related to the question of WHY your strategy works. Because institutions unwind their positions around the close of the week? Because the spot market moves gold overnight? Because there is excess volatility around NFP?

And then another measure that doesn’t get enough prime time: WHEN. What are the market conditions when your strategy capitalizes? When liquidity is flowing in but the price is whipsawing? Or when things calm down and it trends up?

We don’t answer these questions to put together a prospectus, or to explain away our responsibility for not beating the S&P 500 this quarter. It is very, very pragmatic. It is to know the conditions under which it may stop working. To understand the reasons those conditions change. And to look for measures that set off the alarm before the gates are shattered and the enemy is already inside — counting your money. Ed Thorp set this bar decades ago: you have an edge when you can explain why it exists — and how you will lose it1. The why and the when.

What do we use, if not returns?

The developer’s question, and a fair one. Let me list a few that survived my twenty-five years:

Who pays you — and are they still in the game. Every edge has a counterparty: “someone” making a systematic mistake, or wearing a constraint they can’t take off. If the why is institutional unwinds into the Friday close, then count the unwinds. Measure the flow, not the profit on the flow. The flow is a characteristic — observable directly, daily, with no luck in it. When it thins, you know something is off.

The fills. Execution is the closest sensor you have to the mechanism. Fill rates against what the model expects. The adverse selection in your passive fills — what the market does in the seconds after it lets you in. A strategy whose fills start coming back different has changed, whatever the equity curve says.

The way it loses. Every mechanism has a signature failure. A mean-reverter should bleed in trends and get paid in chop. If it starts bleeding in chop, that is not variance — but a deafening siren. Losing right is evidence for the edge. Losing weird is evidence against it.

The size response. Push marginally more through it and watch what comes back — the impact, the fill quality at the increment. A strategy that scales too easily should worry you more than one that doesn’t. A similar problem to the one described in Front-loaded Value in Trading.

None of these are exotic. But the list is not exhaustive. Every strategy begs for a different set of metrics. All of them are observable daily, while a Sharpe ratio needs years to clear its own noise. A Sharpe 1 strategy produces one standard deviation of evidence per year — so you need roughly four years of live P&L before the returns alone separate your strategy from luck. That is the practical asymmetry: characteristics update fast and carry the why; outcomes update slowly and carry luck, noise and regime with them.

The evidence is all around us

For decades, the largest allocators on earth hired the managers with the best three-year record and fired the worst. Goyal and Wahal tracked 3,400 plan sponsors doing it: the hired winners delivered nothing, and the fired losers rebounded2. And when academics published nearly a hundred market edges, McLean and Pontiff measured what happened next: the edges decayed. And they did so on a specific schedule3. The costlier the arbitrage was to execute, the longer the edge lived. The why predicted the when.

None of this makes returns useless. They are the final auditor. But this auditor files late — even a Sharpe 2 strategy needs a full year for some confidence, while the characteristics report every day. By the time the P&L confirms, the fills have known for months.

So…

… cover your equity curve with that tear-soaked tissue, and tell me what you still believe about the strategy. Whatever is left — the counterparty, the fills, the failure signature, the size it bears — that is the edge. If nothing is left, there was never anything there.

All of this assumes the returns you just covered were honest — a larger assumption than it sounds, as Klement showed at the first gate. Ahead is the last one: an edge and the way it survives production.

This exploration has a dual purpose — to make you doubt yourself from the outset, but to also understand you are in good company. The industry that has thrown billions of dollars and many thousands of PhDs at this problem is struggling to clear this gate, too.

by originally published at

Klement on Investing

Thoughts on financial markets by a grumpy, middle-aged German. What more do you want?

By Joachim Klement

One of the eternal problems with measuring the return and risk of private investments is that the lack of liquidity artificially smooths return over time. This in turn creates the impression of a very good risk-return trade-off. But not only that. If one compares these smoothed returns to the return of listed investments like stocks and bonds, it appears as if hedge funds have skill (i.e. alpha) where there is none. It’s like the old illusion that many private investors suffer from where they believe that investing in real estate is very lucrative and has few risks compared to stock markets. Their views would likely change if their properties were valued and reported on TV daily.

Spencer Couts and his colleagues have gone through an elaborate exercise to unsmooth the returns of hedge funds and check what that implies for the alpha these hedge funds achieve vs. listed stocks and bonds. The chart below shows the reduction in hedge fund alpha by strategy from the raw alpha reported by hedge funds, collected in databases, and reported in the news to the true alpha they have achieved.

Alpha bias in different hedge fund strategies.

Source: Couts et al. (2024)

Note that most hedge fund strategies overreport their alphas by about 1.5% per year. Only the most liquid strategies like macro hedge funds, CTA, and equity market neutral show little to no bias.

If we correct hedge fund returns from this bias, then it changes which hedge fund strategies have true alpha and which ones don’t. Long-short hedge funds, for example, on average report an annual alpha of 1.5%, but that disappears completely when the true volatility of the underlying investment portfolio is taken into account. Long only, emerging market, and sector specialist hedge funds even end up with negative alpha on average, meaning on average it’s better to just go with an index fund than these vehicles. And that is before costs!

Meanwhile, the three hedge fund strategies with the highest positive alpha on average are relative value funds (though their alpha drops from about 3.3% p.a. to 2.5% p.a.) and macro and CTA hedge funds (both with an average alpha of about 2% p.a.). Event-driven and market-neutral funds have small positive alphas before fees, but the fees are much higher than these alphas, so investors end up with lower returns than simply going into a low-cost 60/40 stock/bond portfolio for example.

writes every day. I highly recommend subscribing to him here:

Klement on Investing

Thoughts on financial markets by a grumpy, middle-aged German. What more do you want?

By Joachim Klement

And you can read the original piece here.

Trading Reality has, until now, been one practitioner writing from the seat. It becomes something else today.

Each issue, we’ll gather a handful of pieces — some from people whose work I’ve read for years, some as original commentary — around a single problem that matters in production. This first Publication Series — ISSUE 1 — takes up the oldest and most expensive problem in systematic trading: the gap between the model and the market. The track record that doesn’t survive contact with reality.

We take it in the order you meet it. Someone hands you a number — an equity curve, drawdowns, a history. You need to pass three gates that very few strategies do:

• Do the numbers mean anything — or is the apparent skill a measurement artefact that vanishes the moment you measure honestly?

• Even if the numbers are honest, is the edge real — if your strategy works: why, and when — or do you only have a pnl-based measure and a prayer?

• And even if the edge is real, what’s left of it once it runs in production, not in research?

Joachim Klement and Robert Carver take the first and last gates. The middle one is written here.

We start with the scrutiny of the numbers, first.

The pieces publish over the coming days — one a day. If you’d rather read the whole issue now, the links are here: Klement · Trading Reality · Carver. Otherwise, they arrive in sequence.

ordersim gives you exchange matching-engine-level realism in how your orders fill. I recommend that level of granularity for anyone serious about trading. And even if you never touch ordersim — be absolutely anal about simulator precision when you write, or shop around for, a “backtester.” I’m not so narcissistic as to point only at my own: hftbacktest stands out in the field — serious queue-position and latency modelling, though crypto- and HFT-focused. (No affiliation) The honest truth is the field is short. Do the research. Mostly you will find tools people call “backtesters” run at bar level and quietly bury the exact fill assumptions that matter.

And they do.

If you’ve read some of my earlier pieces — or simply been exposed to real trading — you’ll know how big the gap can be between what a backtest tells you and what the market actually does to your order. And you’ll have understood by now how much hinges on the simulation framework and its assumptions. Yes, assumptions. Every backtester has them. The question is: how crude are they? How many are packed into the system? And are they independent, or additive?

That difference — between the fill you assumed and the fill you got — is not a rounding error.

So, why use this simulator and not just the others referenced?

Over almost two and a half decades, every three or four years, I’ve started another order simulator from scratch — because the organization needed one, or because I needed one for my own research. I grew tired of it. I’m hoping to have something central now, something I can reuse without building it again from the ground up. The logic in it is mine: the assumptions, the matching behaviour, the things twenty-five years of watching orders meet real books taught me to model and not to fudge. This last build started as futures research. I had it cleaned up and repackaged for open source — but I was watching every line closely, because in a tool like this the fill logic is the product, and every iota matters.

Self-promotion that appears like selfishness masquerading as selflessness? Or is it the other way around?

ordersim needs you. Not in the abstract “stars and forks” way — your questions, your scrutiny, your taking issue with it. And your use of it. If it helps you make a lot of money, it makes you richer and me happier. That’s the deal. The beauty of good open source — for everyone, by everyone — is that it ends up built by the people who are best in class. That’s the version of “by everyone” I love.

It’s on GitHub. pip install ordersim. Break it, use it, tell me where it’s wrong.

Here’s why.

The people I want to feature aren’t similar to me or each other, which is the point. One works in the corner of systematic trading that Substack readers rarely see; another is Substack-native; another sits closer to allocators. Different desks, different parts of the process — fitting and validation, signal construction, the production pipeline, how the work actually gets evaluated. No single voice sees all of it, including me.

They also bring their own expertise, their style, and their own humour — well needed, since mine tends to run out in the face of the stubborn strategy developer.

This is not a reading list. It isn’t a digest or a links roundup. Each issue has an arc. The pieces are chosen and ordered to build on each other — the walk-through I’d have been grateful for when I was building my own career, and didn’t have. The selection and the sequence — are mine. You may find value in a piece for reasons different from why I selected it. That’s fine. The work earns multiple readings.

Each issue includes a handful of pieces, some selected from existing work, some written for Trading Reality. Every piece runs with full credit and a link back to the original. I won’t tell you what to make of them; I’ll let them speak to YOU. Not every piece will be for every reader. Maybe the next one will, so “swipe” away at will. But come back and read them in order — you’ll be rewarded for it.

Everything stays free. No advertising, no sponsorship, no payment from any party covered, nothing gated. The work is here because it’s worth reading.

If you’ve been reading, stay with me. If you know someone in the field — practitioner, allocator, builder — forward this to them.

Issue 1 is coming.

He was right. It took me years to understand why.

This was a man who once made me pick four Black Labels out of sixteen whisky glasses at the Christmas party to settle an argument about my taste — so disagreements with him were never boring. He was thirty years my senior and a finance professor at a top US university, so I should have caved. But as most people in their twenties do, I thought my arguments were bulletproof:

A buy trade good for an HFT is bad for a hedge fund. The HFT wants to close it for the slightest profit; the fund wants a double-digit return contribution to a huge portfolio. Surely their view of the same trade should differ — so there is no point in chasing universality.

The counter-arguments I received were mostly based in literature and authority, neither of which fazed me much.

Years of strategy development, strategy oversight, and trading system evaluation flipped my view completely. From inside a strategy, the window is fixed and the signals are frozen. My original argument was about evaluation after the fact — but strategies don’t jump back and forth in time to prove you right. They come with a fixed signal set, perhaps 57% winning and 43% losing by default. You could argue that some of the losers would be profitable if only you waited two hours or three days more. That is not this strategy, though. That is a different strategy altogether.

Once committed and deployed, what’s available is the now, not the future. Once you accept that, the only variable left is the price. This is actually an everyday intuition: “this was an absolute steal”, “a killer deal”, “the bargain of the century”. These expressions show the same awareness at the store. It’s all about the price. But somehow when we elevate ourselves into the heights of strategy development, we start looking for a more sophisticated take. On this one, the industry and academia have long sided with the common folk1. The overthinkers among us were in the wrong.

Surely, though, buying Bitcoin in 2010 is inarguably a good trade, you may say. A price tick here and there cannot make a difference in that determination. I hear you, but think of it this way. Imagine we are in early 2010, Bitcoin is trading at a cent2. You have $100, so you buy 10,000 Bitcoin. Happy days. Now, instead, you get it at a worse price — say 1.1 cents. You are left with 9,091 Bitcoin. At the approximate price at the time of writing, that means instead of $734 million on your $100, you would have only made $667.3 million. A $66.7 million difference between a good trade and a bad trade!

The trick lies in the freezing. You freeze the assumptions and accept the future as unknown. The trade was good or bad the moment it was executed. Everything after is just the outcome arriving.

Knowing less about cars than the average high schooler, I barely paid attention to what was being said, only registering mechanically what was being presented. I watched Antonio grow more and more compelled to impress. By the third loop through the 20-30 cars we’d narrowed down to, I realized there was one he kept skipping over. When I pushed him about it, finally, he admitted it was a “good car.” I closed the deal quickly, used the car for many years, and ended up selling it for more than I had paid for it.

I am not a bargainer, nor do I easily see through all sales tricks. But the words adverse selection lit up in front of my trading-geek eyes. This short story, adverse selection, and lemons all have something in common — and I will show you how.

Actuarial origins

In the last piece we covered three important market participant categories: the informed, the uninformed traders, and the market makers. We also showed that informedness is only spread-deep — that is to say, it can only be defined in relation to the market maker. This explains something intuitive: the market maker is trying to avoid being matched with informed traders, and adjusts their quotes accordingly to achieve a dual purpose. First, to widen and shift their quotes, making it more expensive for the informed trader to hit. Second, to be matched as often as possible with uninformed counterparties to offset the losses caused by matching informed flow.

The market maker being picked off by an informed trader is a phenomenon called adverse selection.

The notion originates outside of finance, in the late 19th century, in the insurance industry. Insurers realized roughly a century and a half ago that if they followed pure statistical probabilities when underwriting claims, they would end up going under imminently. They identified an effect they termed anti-selection, or adverse selection — namely, that the people most willing to purchase their life insurance products were the ones likely to already suffer serious illnesses. The information asymmetry between insured and insurer left the insurer unable to predict claim probabilities correctly. Disaster — pun intended — was hard to avoid without coping strategies.

The same effect plays out with market makers, who may not be privy to the information that informed — or “toxic” — traders possess. So they developed several coping strategies.

One strategy is to stop offering the product to a specific target audience. To stop selling life insurance to those with terminal illnesses. Or to skip over the car that is priced correctly — shoutout to the Antonios and car dealerships of this world. For the market maker, this equates to refusing to quote to select counterparties. Not always readily available in regulated markets, but it very much happens in more fragmented financial marketplaces — selective quoting in CFD and interbank feeds is the obvious example.

Another option is to raise the price. Increase the insurance premium, up the sale price of the car, widen the quote. Enough to make the transaction financially viable. The reader will recognize that both strategies are widely followed in all the cases listed.

About a century after the insurance industry coined the term, Akerlof posited that this information asymmetry can have serious consequences. His example was close to home: sellers of used cars know whether theirs is a car with hidden issues; buyers do not. Rational buyers therefore adjust the price they are willing to pay downwards to take this into account. As a consequence, sellers of good cars withdraw from the market — finding this price too low. After just a few cycles of this we are left with: you guessed it — only Lemons.1

The mother of all costs: the Spread

The year was 2013. The country: Switzerland. The room set up for “Ultimate” Agile: a Kanban board, a sprint-board, a 3-min meeting board, and a room-sized whiteboard with never-ending post-its all pushing back on any and all deadlines. I know my strategy is the basis for the next unicorn, but whenever we test-execute it drifts... — I was told. This was familiar territory. This time it was at the strategy design phase. It works on all instruments, so we decided to start with spot FX. The alarm bells were deafening me. Let’s understand the underlying concept first. Statistical pattern deviation from noise. Ok.

So then the buy signal triggers, he said. And we buy at the bid. I know there is slippage, but...

Throat clearing. It was me, but it should have been the strategy author. I exhaled, inhaled, and again several times — I need to say this in a tone that is neither alarmed, nor surprised, nor demeaning, I thought to myself. What do you mean at the bid?...

The strategy was assumed to execute at the prevailing inside bid and ask, not even at the mid-price. So the discrepancy from the get-go was 2× the spread plus commission, plus slippage. It was a long conversation. And many more followed.

It isn’t controversial to say that the biggest and most significant cost to trading is the spread. What others term slippage is generally just the difference between the spread at the time of the order intent and the time of it arriving to the market. The former is a virtual spread that drives the decision. The latter is the spread and price in effect.

A strategy developer needs to understand exactly what the spread is, and what it isn’t. Why it exists. What it means for a strategy. How it interacts with your system.

The spread is considered to comprise three structural components:

• Order processing costs — exchange, settlement, and other transaction fees.

• Inventory costs — the price of the maker having to hold excess positions.

• Adverse selection — the cost of the maker being picked off by more informed players.

In modern markets, adverse selection accounts for 50-80% of the spread. The other two have been compressed by technology — exchanges run leaner, settlement is cheaper, processing is automated. What is left is the cost of the maker not knowing who you are. So you are paying the cost of what the market maker has to defend against. Namely, their inability to identify you, or any other market participant.

How Adverse Selection reaches all

Adverse selection affects both limit orders and market orders. A market order surrenders price for timing. A limit order surrenders timing for price. The trade-off sounds straightforward.

Most developers I’ve watched come at this from the wrong angle. They treat the order-type choice as a tactical question — limit if there’s time, market if there isn’t. The realization takes a while: the choice doesn’t decide whether you pay the spread. It decides how the spread comes back for you.

The market order’s timing guarantee in particular deserves more scrutiny than it usually gets. It assumes what you see as the market price is not a mirage. That the price won’t move significantly by the time you hit the market. That this instrument’s volatility is within the range you expect on the micro time scales. That is a bigger bet than it appears, which is why most professional and systematic trade designers rarely use full market orders. They use marketable limit orders when they need to be the aggressor.

The deeper observation is that adverse selection affects both order types — through different delivery mechanisms.

On a limit order, you are the one quoting a price. You get filled when someone hits your bid or lifts your offer. But who chooses to hit you? I have some bad news and more bad news. Most likely it will be an informed trader. That means you lose. Assume instead that it is incidentally an uninformed trader that wants to dip their paw into the book while you are there. Do you think the market maker — with state-of-the-art infrastructure, fee structure, incentives, and near-perfect microstructure algorithms — will let you lead the queue to face the uninformed player?

On a market order, you are the one crossing the spread to demand execution. The maker moves their price to protect against informedness. They have to — that is their function. You are bundled in so the cost lands on your fill price, and you call it slippage. When there isn’t much slippage, well, it was just too obvious for them that you were not informed to begin with: they are happy to make money off you.

No free order type

The common framing that limit orders capture the spread and market orders pay the spread is simply untrue. Limit orders do not avoid the cost. They transmute it. The spread you didn’t pay shows up as adverse fill selection. The trade-off between price certainty and timing certainty simply becomes: which form of adverse selection you choose to bear.

If you haven’t ever done the exercise to check all-passive (limit) versus all-aggressor (market) PnL for several trading hours, I highly suggest you do it for any market or instrument. What you find will surprise you and make you understand the point viscerally: sometimes the aggressors out-trade the limits, sometimes the other way around. There is no consistency. No determinism.

This matters to you. It sure matters for your strategy. If your signal has urgency, the slower fill rate of limit orders will likely erode it. If you think you can operate without urgency, posting limits could be profitable — but be sure to check your assumptions about infrastructure, costs, and latency, because your competitors are of the most sophisticated type. And overall, if your signal is genuinely informed — predictive of near-term price movement — both order types will cost you, just differently.

Understanding which form of adverse selection your strategy is exposed to, and navigating that interaction deliberately, is paramount if you want to succeed and be consistent in trading.

In the next piece I will turn to a related practitioner discussion — the notion of a good trade and a bad trade, why I used to push back on it, and what changed my mind.

Recommended Reading

Akerlof, G. A. (1970). The Market for “Lemons”: Quality Uncertainty and the Market Mechanism. Quarterly Journal of Economics, 84(3), 488-500.

Stoll, H. R. (1978). The Supply of Dealer Services in Securities Markets. Journal of Finance, 33(4), 1133-1151.

Copeland, T. E., & Galai, D. (1983). Information Effects on the Bid-Ask Spread. Journal of Finance, 38(5), 1457-1469.

Glosten, L. R., & Milgrom, P. R. (1985). Bid, Ask and Transaction Prices in a Specialist Market with Heterogeneously Informed Traders. Journal of Financial Economics, 14(1), 71-100.

Huang, R. D., & Stoll, H. R. (1997). The Components of the Bid-Ask Spread: A General Approach. Review of Financial Studies, 10(4), 995-1034.

Hendershott, T., Jones, C. M., & Menkveld, A. J. (2011). Does Algorithmic Trading Improve Liquidity? Journal of Finance, 66(1), 1-33.

There is little value in obsessing about the fear and resulting actions a retail trader goes through upon detecting a pattern, when retail traders make up a minuscule percentage of the market anyway — and even that portion is diluted by stacking on top of some larger player who has already purchased the flow from the Robinhoods of this world.

In the last piece I closed with the question of why good signals have a front-loaded shape. The answer starts with who is on the other side of those signals — and that is where this piece picks up.

Let’s focus on two participant categories whose implications cannot be overstated: they will determine how you trade, how much you trade, what you can trade, and when you trade. Many readers will be familiar with informed and uninformed traders. Few realize that informedness only makes sense relative to a third participant — the market maker. So that is where we have to start.

Market making, in practice

In the early 2000s I was CTO/COO of an HFT shop that did what we called 5-5 for years (a tongue-in-cheek nod to hedge fund fee structure). With a headcount of just five people, we matched 5% of Nasdaq OTC volume. As part of the incessant pursuit to chisel away unit costs, we had a seat at the exchange, were a registered market maker, and were a self-clearing broker-dealer.

Without getting into the distinction between designated and primary status, registered market makers are required to quote two-sided continuously during regular trading hours, within a defined band of the National Best Bid and Offer. The point is that being more than just an Electronic Liquidity Provider — quoting voluntarily, withdrawing when unprofitable — came with obligations, and those obligations came with allowances. The rules differ slightly for options, but the concept is the same.

One point worth emphasizing because it tends to be missed: a market maker is not obligated to always sit at the inside bid and ask. They are required to quote a certain percentage of the time and within a defined band of the prevailing best bid/ask. They are designated as providing liquidity, which is itself considered a service. That liquidity is not a guarantee, and market makers compete with all other participants for profit. They are neither the villain of the market story nor a benevolent provider of public good — just another competing participant.

So why spend this much time on market makers if what we want to focus on is informed and uninformed traders? Because informedness is defined relative to the market maker. Not as a pure concept. As a structural relation. And as I will show, the distinction between informed and uninformed is not an incidental property of who happens to be in the market. It is not a “designation” of who is smart and who isn’t. It is a structural and unavoidable feature of how markets operate.

A flash history of informedness

The distinction between informed and uninformed traders has been discussed since at least 1971, when Bagehot — the pseudonymous Jack Treynor — framed market making as a contest between liquidity providers and traders with superior information. The formal academic framework arrived with Kyle (1985) and Glosten-Milgrom (1985). What this body of work established is that the distinction is structural, not behavioral. It is integral to how markets operate, not an incidental fact about who happens to be trading on a given day.

Your intuition that a big institution’s block trade, or a super-pod order from the Millenniums and Citadels of the world, would be termed informed — while a retail order is uninformed — is not really the correct distinction according to this framing. And yet, this remains a valid way to think about informedness. At least as a starting point. Size enters the story too: Kyle’s 1985 model is built on the idea that informed traders strategically choose how aggressively to trade because their order size and timing leak information to the market. The bigger the trade, the more the maker can infer, the more the price moves before the trade completes. Size is not what defines informedness, but it is one of the signatures by which informedness gets detected. At our HFT shop we ran algorithms tuned specifically to detect block trades hiding behind VWAP/TWAP slicing — the size signal worked in both directions.

The Uninformed come to the rescue

The above intuition breaks down when you push it further, however. What if all the retail-like flow disappeared, one might ask — and you can argue this is already partially the case given the retail order flow business operating upstream of public venues. Would the markets become more efficient? Would informed-on-informed be the new reality?

No, and the reason is structural. Uninformed flow isn't just the contrast that defines informedness — it's what makes the market work. The literature is precise on this: Black (1986) called noise traders necessary, and the no-trade theorem (Milgrom and Stokey, 1982) shows why. If everyone were rational and informed, the fact that someone wants to trade with you would tell you they think they have an edge — so you should refuse. Markets seize up. Liquidity disappears. I saw this at the HFT in the small: we refused to trade with players whose cancel/replace patterns suggested they were reading the same signals we were. The theorem isn't abstract — it's how a desk actually operates when it suspects the other side knows what it knows.

Noise traders break the deadlock. Their flow has no information in it, which gives informed traders something to trade against and lets prices catch up to reality. The uninformed lose on average. That’s the cost of having a market at all. It is this informational asymmetry that makes the price tick.

Definition. Please.

It is dead simple. If the Market Maker loses when trading against you, you are informed. If they make money, you are uninformed. Don't try to beat the market. Beat the Market Maker first.

He who Makes the vocabulary

The language has evolved. From 1971 to today the terms have drifted: uninformed became noise trader, informed became toxic flow. Notice how the names have become pejorative for both groups. Uninformed flow used to be a structural necessity; now it's noise. Informed flow used to be the trader earning a return on their information; now it's toxic.

The vocabulary tells you whose seat at the table got the loudest voice. That seat belongs to the third participant we have been circling: the Market Maker.

Some readers will recognize toxic order flow from a different marketplace than this piece centers on: CFDs. Colloquially called FX. Liquidity providers in that business throw the term around a lot, especially when they want to upcharge or restrict access. This is no coincidence. Informed, uninformed traders and market makers are not exclusive to centralized markets. They are emergent features of any market where someone quotes both sides. The vocabulary ports because the structure does.

Why this matters for trading systems

Some of the cleanest, most reliable strategies I have worked on were ones we eventually traced back to a specific class of participants doing a specific thing. The strategies we couldn't trace? Those went away first. Half-life detection is great, but it's only a "half-solution".

Every trading system makes assumptions about participant mix, whether the developer knows it or not. The strategy that worked in backtest assumed a certain composition of flow. The execution model that produced a clean equity curve assumed a certain receptivity from the makers on the other side. When the mix changes — and it does, regularly — the assumptions degrade. Quietly.

You can build trading systems without thinking this way. Plenty of people do. But if you arrive at a persistent edge without ever asking whose behavior this is exploiting, you have most likely found a participant-structural pattern without knowing it. Which means when it goes away — and it will — you won't know why.

Adverse selection is one of the mechanisms that turns participant structure into the actual cost of trading. And it defines the spread. Now we can explore it substantively, and that is what my next piece will do. And with this we add very important concepts to our toolkit — ones that will survive any trend, strategy, and possibly even you and me.

References

Bagehot, W. [Treynor, J.] (1971). The Only Game in Town. Financial Analysts Journal, 27(2), 12-14.

Milgrom, P., & Stokey, N. (1982). Information, Trade and Common Knowledge. Journal of Economic Theory, 26(1), 17-27.

Black, F. (1986). Noise. Journal of Finance, 41(3), 528-543.

Further reading

De Long, J. B., Shleifer, A., Summers, L. H., & Waldmann, R. J. (1990). Noise Trader Risk in Financial Markets. Journal of Political Economy, 98(4), 703-738.

Easley, D., Kiefer, N. M., O’Hara, M., & Paperman, J. B. (1996). Liquidity, Information, and Infrequently Traded Stocks.Journal of Finance, 51(4), 1405-1436.

Easley, D., López de Prado, M., & O’Hara, M. (2012). Flow Toxicity and Liquidity in a High-Frequency World. Review of Financial Studies, 25(5), 1457-1493.

I have seen this across trading systems, in the widest range of assets and markets. The implications should make you pause. Pause. Repeat: bad trades have no shape. Good trades have a specific one. This affects everything — signal discovery, sizing, exits, and your ultimate PnL touchpoint: Executions.

A recap

In my previous post I took you through my Quant Room struggles to convey how executions rewrite strategy results completely, and how often I had to go through the same exercise. To gather the data, build the argument, confront the enthusiasm of a Strategy Builder with facts on the ground. The same facts.

It took dozens of cumulative samples before I started to wonder. The effect could not be explained by a combination of spread, commission, and slippage costs plus the core statistical mechanics. It wasn’t cost of execution. It was the shape of the value when the signal was the right one.

The shape

The first time I started to suspect was when I had to do the same exercise back-to-back-to-back, reviewing five very different strategies within two days. Momentum. European equities. Spot and FX futures with a carry component. A dollar-neutral US stocks portfolio. Medium-frequency day trading. They should have had nothing to do with each other. But my analyses from the previous four were still on my desk. The sheets were still on the Desktop. I could not unsee it. It was glaring at me.

In good signals, the extractable value rises sharply from entry and is mostly realized in the first part of the holding period. The initial jump is sudden, followed by a plateau or modest decay.

This shape is the cumulative average across the system’s good trades, not any individual trade. Yet the same shape surfaced again and again across the systems, in their positive-outcome trades. Regime and asset class adjust the exact shape, but not the pattern.

Bad trades, on the other hand, wander, bleed, spike, and revert. The more you accumulate, the more distinct the pattern appears compared to good signals.

So being front-loaded is a feature. It itself is a diagnostic about the quality of the trade.

One caveat: this is a post-event observation. The shape only emerges in retrospect, which limits its direct use in real-time signal generation. And to be clear about what I’m describing — the front-loading is disproportionate, not absolute. There is real value in the rest of the holding period; you can’t just cut early and assume the trade is done. What you can say is that the early window carries more of the value than its share of the holding period would suggest.

For a long time I had the observation without the implication. I knew the shape was there; I didn’t yet see what it meant for the rest of the strategy. That came later, and it came through analysis.

Why this matters for execution

A two-day holding period trade may have most of its value accrue in the first few hours. But importantly, a disproportionate fraction of that will be packed into the very first minutes. Counterintuitive, but a logical consequence of the pattern described — the same disproportionality recurses within the early window itself.

Slippage and timing

This reframes what slippage actually is.

The traditional view treats it as a uniform tax on returns, a few basis points subtracted from the edge regardless of when in the trade they’re paid. Under the front-loaded shape, that view is wrong. Slippage is an edge-dampener, and the path it dampens is the good-signal path. The same basis points cost more when paid in the window where the value is concentrated.

Timing the entry becomes impactful for any strategy. A late entry isn’t just a delayed entry — it’s a different trade. The shape has begun without you. What is left to capture is the reduced part of the curve, while the fixed costs and the bad trades continue to drag you down at full strength.

This is why post #1’s claim that execution rewrites strategy results isn’t a marginal-cost story. It’s a shape-of-alpha story.

A note on what this isn’t

I want to clarify this has not been derived from first principles, nor is it a claim that this will consistently repeat for all asset classes in all markets, now and in the future. The mechanism — fast information assimilation, real edges being narrow in time, the difference between a real signal and one that’s mostly noise — is suggestive but underdetermined. These are observations, and empirical assertions.

So this is not an academic claim, even as the related literature has been documenting related shapes — particularly in how price impact decays after large orders — for decades. Even as analysis of informed and uninformed market participants has led to convergent conclusions (more on this later). What I would like to offer is the trader-side mirror of those observations, framed in a way practitioners can use.

For readers who want to go deeper into the underlying market mechanics from the academic perspective, here are the foundational papers and a few accessible follow-ups I would recommend (skip if short on time):

Recommended reading

Kyle, A. S. (1985). Continuous Auctions and Insider Trading. Econometrica, 53(6), 1315–1335. The foundational paper on how information enters prices.

Glosten, L. R., & Milgrom, P. R. (1985). Bid, Ask and Transaction Prices in a Specialist Market with Heterogeneously Informed Traders. Journal of Financial Economics, 14(1), 71–100. The companion 1985 paper, on adverse selection.

Hasbrouck, J. (1991). Measuring the Information Content of Stock Trades. Journal of Finance, 46(1), 179–207. Empirical foundation for permanent vs. transient impact.

Almgren, R., & Chriss, N. (2000). Optimal Execution of Portfolio Transactions. Journal of Risk, 3(2), 5–39. The execution-scheduling literature’s anchor.

Bouchaud, J.-P., Farmer, J. D., & Lillo, F. (2009). How Markets Slowly Digest Changes in Supply and Demand. In T. Hens & K. R. Schenk-Hoppé (Eds.), Handbook of Financial Markets: Dynamics and Evolution (pp. 57–160). North-Holland (Elsevier). Review of market impact and order flow dynamics.

The question

There is a question that we have been brushing against without pinning it. Why does this shape exist? Why does information get absorbed in a way that front-loads the value? Why front-loaded for good signals and not for bad ones?

The answer lives in the domain of market participants and information availability. Information becomes available to all or to a few in waves — waves that are difficult to conceal for long. It is the sudden availability of this information that underpins the effect we described so far.

The market participants who are in on it and those who only see the effects after the fact play a different role in price discovery.

This is exactly the topic of my next piece: the informed and uninformed traders, and how their interaction determines most of the market mechanics relevant to a trading system developer.

In this article I want to show how true that is — not by listing everything that can go wrong, but by pointing to the few things that consistently matter.

A most human trading-exec anecdote

When I was hired as an Executions Specialist at a multi-billion dollar hedge fund, I used to sit — politely, patiently — through meetings and presentations from quants and portfolio managers. It would quite often play out the same way.

They would present their stellar performance charts, methods, equations, market references — everything you would expect. These were serious people. Ivy League PhDs, experienced PMs, people who had clearly put in the work.

At some point I would ask a simple question:

“May I ask what the execution assumptions were?”

Almost without fail, something would shift in the room.

“We don’t care about execution — we have average holding times of 2 full days and above!”

You could hear the resounding irritation. So I learned not to push it in the room.

I would wait for the meeting to finish, then ask for a private conversation. Same question, this time without the audience. Polite, dry: gather the data.

Then I would go back, collate the information, and do the work — sit there, shut everything else out, run the analysis properly, knowing already that this might not go well. I had my intuition, and my internal statistics. Then another private conversation. Because the result was rarely subtle.

Sharpe ratios north of 4 would drop to around 1.2 under optimistic assumptions. Under more conservative ones, the strategy would simply bleed. The clearest case I remember was a cross-asset carry, EUR-pegged — and it was very much not the only one.

And this was NOT high-frequency trading. But: Multi-day holding periods. Highly liquid instruments. Top-tier market access. Competitive commissions.

And still — execution didn’t just “adjust” the result.

It rewrote it.

Where things break

Most systematic trading strategies follow a familiar path: signal discovery, backtesting, deployment. Execution is either assumed, simplified, or treated as neutral. This is where things start to break.

Slippage — if it is considered at all — is often treated as a fixed adjustment. A number. A parameter. But it is not. It is variable. Context-dependent. State-dependent.

And this leads to the first structural trap.

Trap #1 — The better the signal, the harder it is to execute consistently

There is a counterintuitive truth about fills that most people miss: a good trade is contested. Informed traders on the other side of a real edge will not let you in cheaply. A bad trade is often uncontested — the book gives way, slippage is small, you fill at touch.

Which means cheap, easy fills should make you question your signal. Slipped, partial fills, adverse selection — the things that feel like the market punishing you — are often the market confirming that something is actually there.

There is a structural reinforcement of the same effect: strong signals also tend to appear in transitional regimes — news, dislocations, crowded inventory — where spreads widen and execution gets worse for everyone. But the cleaner version of the trap is simply that good fills correlate with poor trade quality.

What is assumed to be independent — signal and execution — is not. They interact. And that interaction is rarely in your favor.

This is the first of several traps I’ll be writing about. Subsequent posts will cover risk-layer distortion, the market-selection trap, and the one nobody wants to hear about: the cost of being right.

Execution and risk

An experienced trader will place a lot of emphasis on risk. But if execution assumptions are wrong, the entire risk layer is distorted. Entry is not where you think it is. Exit is not where you think it is. Drawdowns are not what you modeled.

The problem is not just that execution adds cost. It is that it quietly reshapes your risk profile — sometimes by hurting you, and sometimes by helping you for the wrong reasons.

Here is a real one: A single tick of slippage caused a missed exit. The position stayed on. The next entry — one that should never have fired if the exit had triggered correctly — missed a big winner. The rest you can imagine. Double the drawdown, strategy abandoned, and my post-humous analysis revealing the real drift. This happened not to one but to a dozen different trading systems I was tasked with overseeing. So as a trader you need to be ready, firm and honest.

What execution actually is

Execution is much more than most people think. It is not just slippage. It is not just the trading platform. It is the market you chose, the venue, the latency, the commissions, the placement, the size of the order, the available liquidity, the competition for the same trade.

In one word: Reality.

Take “trading gold” — a useful example, because it sounds like a single thing and isn’t. Gold futures, micro futures, OTC, CFD products — each has a different book, a different liquidity profile, a different microstructure, and even different price behavior. They are not interchangeable. And execution is where that difference shows up first — usually painfully, and usually after you have already committed.

Why it gets ignored

Execution is unsexy. It’s often treated like the last administrative step — the final turn before you “get your license” to trade.

But it’s not a formality. It’s a traffic light. It should tell you green, yellow, or red. And in practice, it should very often tell you: No.

That “No” is not a failure. It is information.

Implications

Execution is market selection. It is cost. It is timing. It is not a layer on top of the strategy — it is part of the strategy. It feeds directly into risk. It operates at the level of micro, even nano-level details. And those details accumulate.

If you have a great “strategy,” you may have signal. You may even be 10–40% of the way there, depending on what you’re doing. But that’s not the end. And it shouldn’t feel like the end.

A red light from execution is often the most valuable answer you can get. It means either:

• you are onto something real but not yet implementable,

• or you have been disciplined enough to hit a wall before carving a hole in your wallet.

Closing

Years later, I still think back to those private conversations after the meetings. The walk back to the desk. The dry presentation of numbers that nobody had asked for. A Sharpe of 4 becoming a Sharpe of 1.2, then sometimes a flat line.

Without execution, a strategy is just a thesis. With execution, it becomes either a position or a lesson.

Execution is not downstream of the strategy.

It is where the strategy actually becomes real.