We built a real-time market scanner in a weekend. Here is what fired on the S&P 30.

On Saturday afternoon four stocks were sitting at the bottom of their Bollinger bands. NVDA at $194.83. AVGO at $360.45. WMT at $111.84. CSCO at $112.69. Tech pullback names, mostly. Semi and software leaders that had rolled off recent highs and were now touching the lower edge of their volatility envelope.

We did not notice them by staring at charts. We did not pay $50 a month for a screener subscription and manually flip through tickers. AutoQuant flagged all four about a minute after the bar closed, dropped them into a hit table, and offered to generate a backtestable strategy from the exact rule that fired. That is what shipped in v0.4.0 this weekend, and this is the story of how it works and what it caught.

The gap we were trying to close

AutoQuant already did research, backtesting, and deployment. You could describe a strategy in natural language, let the AI Loop iterate it against real market data, backtest the result, and deploy it to a paper or live Alpaca runner. What was missing was the front of that funnel. Discovery. The moment where you go from “I have no idea what to trade today” to “here is a specific setup on a specific name.”

Screeners solve that for discretionary traders, but they stop at the alert. You get a ping that says NVDA touched its lower band, and then you are on your own. You still have to decide whether the setup has any historical edge, code up a rule, and test it. The scanner sat in one tool, the backtester in another, the deployment engine in a third. Every handoff was a copy-paste and a context switch.

We wanted the whole path to live in one app. See the setup fire, backtest the rule behind it, deploy the winner. No leaving the window.

How the scanner is built

The design decision that mattered most was treating universes and conditions as first-class, composable pieces rather than a fixed menu.

A universe is just a named list of tickers. We ship five curated ones out of the box, including the S&P Top 30, a mega-cap tech basket, and a few others, but a universe is nothing more than a list, so you can point the scanner at whatever set of names you care about. On every run the scanner re-expands the universe from its definition, so if a list changes underneath you, the next scan reflects it instead of a stale snapshot.

A condition is a single testable predicate about a ticker at a point in time. The one we ran on Saturday was price_at_bollinger_band(period=20, num_std=1, band=lower). It asks, for each ticker, whether the current price is sitting at the lower Bollinger band computed over a 20-period window with a one standard deviation envelope. Conditions are composable, so a real scan can stack several of them, and the scanner only reports a hit when the full stack is satisfied.

When a scan runs, the engine pulls bars for every ticker in the universe. If a ticker has no local data cached, it fetches the bars on demand instead of silently skipping the name, which was one of the first bugs we caught during QA. It evaluates the condition stack against the latest bar for each ticker. Anything that passes becomes a hit, and each hit carries the ticker, the price, and which conditions matched.

Here is the part that closes the loop. For every hit, the engine emits roughly 130 words of Python that reconstructs the firing rule as an actual strategy. That generated code is sandbox-executable and, more importantly, backtestable through the exact same engine that runs the rest of AutoQuant. The rule that fired the alert and the rule you backtest are the same rule. There is no translation step where the meaning drifts.

Why we did not ship a strategy language yet

We thought hard about shipping a proper domain-specific language for expressing scan conditions. A little grammar, a parser, an editor with autocomplete. It is the kind of thing that looks impressive in a demo.

We decided against it for v1, on purpose. A DSL is a commitment. Once people write strategies in it, you own that syntax forever, and every future change has to stay backward compatible with whatever you shipped first. Getting the primitives right matters more than getting the surface syntax pretty, and we did not yet have enough real scans behind us to know which primitives deserve to be permanent. Condition blocks composed in the UI cover the cases we actually need right now, and the generated Python is the real artifact anyway.

The design work for a file-format spec is written down and waiting in the repo for when we have earned the right to freeze a syntax. For now the composable condition blocks do the job without locking us into decisions we would regret.

What fired on Saturday

We pointed the scanner at the S&P Top 30 with that single Bollinger condition and ran it repeatedly through the afternoon. Four names kept coming back.

NVDA at $194.83, price at the lower band. AVGO at $360.45, same. WMT at $111.84. CSCO at $112.69. Three of the four are tech, and the common thread is a group of semi and software leaders that had pulled back off recent highs and were now touching the bottom of their volatility range. WMT was the odd one out, a consumer staple showing the same mechanical signature for different reasons.

A lower Bollinger touch is a mean-reversion setup. The thesis is that price has stretched to the low end of its recent range and, absent a regime change, tends to snap back toward the middle. Whether that thesis actually has edge on any given name is exactly the question a screener cannot answer and a backtest can.

So we backtested one.

The NVDA backtest

We promoted the NVDA hit to a strategy, which took the auto-generated Bollinger rule and ran it through the backtest engine on NVDA from July 4, 2025 to July 4, 2026. A full year.

Correction, July 6: the numbers below originally overstated the strategy. A dtype bug in our code generator made entries fire on every bar a condition stayed true, instead of once per touch, and the backtest inherited that behavior. We found it two days later while writing tests for a related project, fixed it the same day, and re-ran everything. The corrected numbers are below. When the tool is wrong, the numbers change in public. That is what honest backtesting means to us.

The strategy returned +15.58% over the year. Buy and hold on NVDA over the same window returned +23.12%, so the rule underperformed a simple hold, which is exactly what you expect from a mean-reversion strategy during a strong bull run. Mean reversion sits out the trending moves. That is the tradeoff.

The Sharpe ratio came in at 0.725, with a Sortino of 0.708 and a Calmar of 1.483. Max drawdown was -10.64%. The win rate was 63.64%, which is 7 winners out of 11 trades, and the profit factor was 3.02 on an average win of $6.90 against an average loss of $3.99. Believable numbers for daily-bar mean reversion, which is the point. The original run showed a 112 profit factor, and a 112 profit factor is the kind of number that should have made us suspicious sooner.

Eleven trades is a small sample, and we would not deploy real money on eleven trades without more testing across more names and more history. The point is not that we found a money printer. The point is that the entire path from “NVDA is touching its lower band right now” to “here is a backtest of the rule behind that alert” happened inside one app, in a few clicks, with no copy-paste and no rewriting the rule by hand. The alert and the backtest were the same rule.

Deploy verified

We took the same scan and promoted it to a paper runner on NVDA through Alpaca. Because it was Saturday and the market was closed, the runner started with zero bars, which used to be a hard failure. One of the weekend fixes we shipped means the runner queues cleanly instead of crashing on empty data. It sits in the active runners list and will start evaluating the Bollinger rule at Monday’s open, right alongside a pre-existing runner we already had going on AAPL.

So the loop is closed end to end. A scan fired on Saturday, we backtested the rule behind it, and we deployed that rule to a paper account that will start trading it live on Monday. Same rule the whole way through.

What a weekend of QA actually looks like

The scanner did not ship clean. Building the happy path is the easy 80%. The last 20% is finding all the ways it breaks on real data, and most of Saturday went to exactly that.

The scanner was silently skipping tickers that had no local bars cached, so we made it fetch on demand. The hit table rendered the price and matched columns with no gap between them, so PRICE and MATCHED came out as PRICEMATCHED. Long scans over a universe that needed to auto-fetch data were blowing through the default 30 second client timeout, so we raised it to 30 minutes for scan runs. Promoted strategies were saving to the wrong path instead of the per-user store. Deep-linking from a hit into the backtester did not anchor the date range, so we pinned it to the trailing year. One of the S&P names in our curated list had a ticker format the data provider choked on, so we swapped it and started showing error tickers inline on hover instead of hiding them.

None of these are glamorous. All of them are the difference between a demo and a tool you would actually trust with a scan.

Try it

StratScanner is live in AutoQuant v0.4.0, available now for macOS and Windows at autoquant.ai. The scanner, the backtester, the AI Loop, and the deployment engine all live in the same desktop app, running on your machine against your data and your API keys.

If you want to see what your own universe is doing right now, and then immediately find out whether the setups that fire have any historical edge, you can try the whole thing as part of the 14-day free trial. Point it at the S&P 30, or point it at your own watchlist, and see what fires.

The AutoQuant team