Rules frozen first; results reported pass or fail.

We spent two weeks testing one of the oldest ideas in trading: buy the minute a stock crosses above a key price level.
We tested 892 ways to do it. None passed. But one piece of it was real - and it is why we are now building a generator
that fills in trade-by-trade detail for years where we only have one-minute bars.

The test

  • The trade: a mid, large or mega company (over $2 billion) crosses above a key level - a 52-week high, or a level built from where volume traded - and we buy in that minute, using the real trades and quotes of that minute (trades 2016-2025, about 2,750 trading days of tick data). Company size is its market value the day before the cross.
  • What we varied: what the order flow looked like at the cross (was buying pressure behind it or not), which volatility-sized stop protects the trade early, and when a working trade is finally sold. Every distance was measured in the stock's own volatility, never in dollars or fixed percentages.
  • The bar to clear: beat a plain stop, beat the same stock bought at a random minute of the same day, make money in the typical month, survive costs - and survive a correction for testing 892 combinations at once.
  • The core rules were written down before any result. Fixes added during the run (for data problems such as a ticker passing from one company to another, or a cash buyout being priced as a bankruptcy) were each frozen and reviewed before re-scoring. An independent reviewer re-read every score file.

What we found

0 of 892 passed. Not on their own, and not after the correction for multiple tests. Some combinations looked good on
average - a few percent a trade - and then failed the typical-month test or the random-minute test.

One thing was real: the entry minute. When buying pressure was behind the cross, entering on that minute beat
entering at a random minute the same day: 48 of the 60 combinations we could check that way cleared p below 0.001, and
all 60 pointed the same way. The cross is not noise. What failed was everything
after it: no stop and no exit rule we tried turned that better entry into a trade that passed.

So the open question is the exit. And the most natural exits - "sell when the buying pressure turns", "sell when the
spread widens" - need the same trade-by-trade detail the entry used.

Why we're building a tick generator

Tick data is huge and expensive, so most history only exists as one-minute bars: open, high, low, close, volume.
We are training a model that takes a one-minute bar (plus the earlier minutes of that day) and fills in what the ticks
would have shown: buy share, order-flow imbalance, spread, quote depth, odd-lot share, off-exchange share, block trades.

How it is being tested, fixed before any training run:

  • Trained on 150 days, graded on 90 days from nine different market moods it never saw: a flat quarter, a calm bull market, the 2018 selloff, the 2020 crash, the 2021 retail mania, the 2022 bear market, a rally, a choppy quarter and a shock-and-rebound quarter - with a month of distance between training and test days.
  • Each field gets a grade from how much of the real variation it explains on those unseen days: GOOD (at least 60%), PARTIAL (25-60%), POOR (under 25%).
  • Buy share has an extra bar: it must beat the classic shortcut that estimates buying from the bar alone (bulk volume classification), or it counts as POOR.
  • It will also be graded on the 737 real breakout-cross minutes that fall on the test days - the exact minutes the exit question is about.
  • The first training run is done and independently checked; the grades are in the follow-up post.

What a generator like this can and can't do

This is the part most "synthetic data" posts skip.

It can't add information. Everything it produces is a function of the bar it was given. If a strategy finds an
edge in the generated fields, that edge was already in the bar - or it is something the model invented. So our rule is
simple: any test that uses generated fields is logged as such, and nothing gets traded until the same result shows up
on real ticks.

What it is useful for:

  • Training and testing exit logic on years and stocks where real ticks don't exist, so you can see whether a rule is even worth the cost of real data before you buy it.
  • Realistic simulation: a backtest or an agent trained only on bars never sees spreads widen or buyers disappear inside a minute. Generated fields give it plausible microstructure to react to, so the training environment behaves more like the market it will face.
  • Stress-testing code: pipelines that read tick fields can run on full history instead of a sample.

Results of the grading come in a follow-up, field by field - including the ones that come out POOR.

What's next: the exit

The entry held up; the exits didn't. So the next test is the exit itself - rules driven by the tape instead of fixed
stops. Candidates include a buying-pressure flip, an order-flow imbalance turn and a widening spread; the design isn't
settled yet. It gets its own frozen rules, runs on real ticks first, and gets its own write-up, pass or fail.

A question for you

If you have filled in tick-level detail from bars - buy share, spread, imbalance - what did you measure it against,
and which fields held up?

Research and education only - not investment advice.