← Quantery Blog

How to build a thesis worth testing

August 7, 2026 · 7 min readthesis-buildingmethod

Every investor carries hunches. "Companies that gush cash while the market ignores them." "Boring businesses nobody wants to talk about at parties." "Spin-offs that get dumped by index funds." Some of those hunches are edges. Most are vibes. The only way to find out which is which is to make the hunch testable — and that's a craft with real steps, not a personality trait.

Most screening tools quietly decide this question for you. If your idea can be expressed as a dropdown — P/E below X, market cap above Y — you can test it; if it can't, you can't. Quantery's screen engine works from the other direction: you get the raw point-in-time fundamentals and you define the calculations. Any thesis you can state precisely, you can screen and backtest. Which moves the hard work to where it should be: stating it precisely. Here's how.

Start by writing the claim down

Take the hunch and write it as a sentence with a claim in it:

Companies that generate lots of cash relative to their price, while the market ignores them, tend to be re-rated eventually.

Already this is progress, because the sentence has parts, and each part will need a definition or an honest admission that you can't define it:

• "generate lots of cash" — measurable, once you pick a measure.
• "relative to their price" — measurable.
• "the market ignores them" — fuzzy. This is where the work is.
• "re-rated eventually" — this is the prediction, the thing the backtest checks. It doesn't go in the screen; it's what the screen is graded on.

Separating the claim from the prediction matters. A thesis is rules for selecting companies today, and a testable belief about what happens to those companies afterward. Mixing the two — putting "and then the stock goes up" into your selection logic — is how look-ahead bias sneaks into homemade screens.

Choose proxies you can defend

Every concept in your sentence needs a proxy: a number, computable from data you actually have, that stands in for the idea. Choosing proxies is the most consequential act in thesis design, so do it in the open.

"Generates lots of cash" — the honest measure is free cash flow: operating cash flow minus capital spending, straight off the cash flow statement. Trailing twelve months, so one lumpy quarter doesn't decide anything. And a level test alone isn't enough — cash "relative to price" wants a yield: FCF over market cap.

"The market ignores them" — you can't screen for attention directly, so pick an observable footprint and admit the gap. Two defensible options: the price has gone sideways-to-down over a meaningful window (drawdown from a high), or the valuation is cheap despite the cash generation — which the FCF yield already captures. Pick one; don't stack three proxies for the same idea, because you'll never untangle which one your backtest is actually rewarding.

Write the gap down, too: drawdown ≠ ignored — a stock can be down 40% because everyone is watching it very closely and selling. That caveat becomes part of how you read your results later.

Kill the rules you can't measure

Every draft thesis accumulates rules like "quality management" or "the problems are temporary" or "a real moat." For each one you have three honest options:

1. Operationalize it. "Conservative debt" becomes net debt to EBITDA below a threshold. "Consistently profitable" becomes positive net income in each of the trailing periods you check. If a crisp version exists, use it.
2. Move it to the qualitative layer. Quantery theses can carry qualitative criteria that an AI (your own key or a local model — entirely optional) scores on the survivors — after the quantitative screen has done the ranking. That's the right home for "is the moat real?": a judgment call applied to a short list, clearly separated from the arithmetic, never a hidden fudge factor inside it.
3. Delete it. A rule that's neither computable nor worth a judgment pass is decoration. Cut it.

What you may not do is leave it vague. A screen with an unmeasured rule isn't a screen; it's a mood with a spreadsheet attached.

Decide what's a gate and what's a score

Not all rules deserve equal rank, and the structure of a thesis should say so:

• Gates are must-pass conditions. Fail one and the company is out, no matter how it scores elsewhere. Genuine dealbreakers only: negative free cash flow, missing data, a market cap too small to trade sanely.
• Scores are graded criteria. A 6% FCF yield is better than a 3%, which is better than a 1% — that's a scoring band, not a cliff.
• Verdict bands map the total score to labels — strong, watch, pass — so a ranked list comes out the other end instead of a binary in/out.

A classic beginner mistake is making everything a gate. Ten hard cutoffs multiplied together select for "companies that happen to sit on the right side of ten arbitrary lines" — brittle, and hostage to data quirks. Gate the dealbreakers; score the rest.

The worked example

Here's the hunch, assembled. The shape below is illustrative — the bundled templates in the app are the reference for exact field names — but this is genuinely how a thesis goes together: features you define from raw fundamentals, named parameters, criteria, a gate, bands.

# "Cash gushers the market ignores" — illustrative
params:
  yield_strong: 0.08        # FCF yield that screams
  yield_ok:     0.05        # FCF yield that whispers
  drawdown_min: 0.25        # how "ignored" must the price be
  conversion_floor: 0.8     # FCF should back up reported earnings

features:
  fcf_ttm:    ttm(free_cash_flow)
  ni_ttm:     ttm(net_income)
  fcf_yield:  if(market_cap > 0, fcf_ttm / market_cap, null)
  conversion: if(ni_ttm > 0, fcf_ttm / ni_ttm, null)
  drawdown:   1 - price / high_52w

criteria:
  cash_gusher:            # is the cash real and big?
    - { when: "fcf_yield >= $yield_strong", score: 2 }
    - { when: "fcf_yield >= $yield_ok",     score: 1 }
    - { else: 0 }
  earnings_backed:        # accruals check — see the FCF post
    - { when: "conversion >= $conversion_floor", score: 2 }
    - { when: "conversion >= 0.5",               score: 1 }
    - { else: 0 }
  ignored:                # the proxy we chose, gap and all
    - { when: "drawdown >= $drawdown_min", score: 1 }
    - { else: 0 }

gate:
  - fcf_ttm > 0           # no gusher without cash
  - min_market_cap        # tradability, not taste

verdict_bands:
  strong: score >= 4
  watch:  score >= 2

Notice what the precision bought you. ttm(free_cash_flow) is a calculation you chose, over a window you chose, from point-in-time filings — not a vendor's pre-baked "FCF" field with someone else's adjustments buried in it. The conversion feature is a ratio most stock screeners simply don't offer, and here it's one line, because you're composing raw fundamentals rather than picking from a menu. When a rule is wrong, it's your rule, sitting in plain text, one edit away from better.

Screenshot pending

The worked example open in the visual thesis builder, params panel visible

Keep it few, keep it round

Every parameter you add is a dial you can overfit with. Two disciplines pay for themselves:

Few parameters. The example has four. If your thesis needs fifteen, you don't have a thesis — you have a curve-fit in progress.

Round numbers. An 8% yield threshold is a belief; a 7.6% threshold is a backtest artifact. If moving a dial from 0.25 to 0.30 flips your results from great to garbage, the result was never real — it was the dial.

Decide, in advance, what failure looks like

Before you run the backtest, write down what would convince you the hunch is wrong: if the edge only shows up in one two-year stretch, it's regime luck, not a thesis — that kind of sentence. Then run it walk-forward and hold yourself to what you wrote. A thesis worth testing is one you're genuinely prepared to see fail; the rest is confirmation with extra steps. (What the backtest itself can and can't tell you is its own article.)

The template screens that ship with Quantery went through exactly this process — decades ago, in public, by their original authors. That's what makes them good starting points. But the engine doesn't know the difference between a famous screen and the one you wrote this evening from a hunch and four honest proxies. That's the point.

Want to try this on your own rules? Quantery is free for 14 days — the full app, no card required.

← All articles