Valuation & quality

TTM P/E divided by YoY TTM-EPS growth %. Growth = (sum of the 4 most recent reported quarterly EPS / sum of the prior 4) − 1, expressed as a percentage; both sums use most-recent-first ordering so the first 4 are the trailing twelve months. Sourced from `intel_earnings_reactions` (eps_actual, non-future, ordered by earnings_date DESC); falls back to `intel_earnings_surprises` (reported_eps, ordered by fiscal_date DESC). Result stored in `IntelTechnicalFactors.peg`; served via `ticker_service.py:1871`. PEG is null when ANY of these holds: (1) fewer than 8 quarters of reported EPS exist, (2) no TTM P/E is available, (3) the prior-year EPS sum is zero or negative — the growth base must be positive, so a stock turning from a loss to a profit is excluded even though its true growth is large and positive, or (4) the computed YoY growth is zero or negative. Engine: `backend/scripts/recompute_technical_factors.py:927-935`; frontend pass-through: `qtick/frontend/src/lib/data/map/valuation.ts:15`.

A low PEG tightens the valuation case — you're paying less P/E per unit of growth, which is the core of a growth-at-a-reasonable-price argument. A high PEG doesn't close it; pair it against quality signals (beat rate, revision momentum) to judge whether the growth deserves the premium or whether estimates are drifting down. PEG is also null whenever the prior-year EPS base is non-positive or trailing growth is non-positive, so its absence is itself worth noting — and it specifically goes missing on loss-to-profit turnarounds, exactly the cases where growth direction matters most.

Below 1 means the market prices the stock at less than one dollar of P/E per percentage point of trailing growth — the Lynch "cheap for the growth" zone. 1–2 is mid-range: the growth is priced in but not wildly stretched. Above 2 means you're paying a significant premium over trailing growth; the stock would need to accelerate earnings or compress P/E to justify it.

Theoretical floor near 0 (very high growth, modest P/E). Practical range: 0.3–5 for profitable growth stocks. ~1 = Lynch fair-value benchmark. Values above 3–4 appear mainly in high-multiple, slow-growth names. A non-positive prior-year EPS base or non-positive trailing growth makes PEG undefined (shown as null).

Uses trailing (reported) EPS growth, not forward estimates — a stock decelerating into the next year can show a flattering PEG built on last year's sprint. It is also null whenever the prior-year EPS base is non-positive or trailing growth is non-positive, which is why loss-to-profit turnarounds are excluded: the growth base must be a positive number for the ratio to be computed, so the early-recovery and early-growth cases where direction matters most show no value at all.

Right now this is always blank for us. The field `ev_ebitda` is declared in the `ValMetrics` schema but the service constructor never fills it in — only pe, fwd_pe, peg, ps, pb, p_fcf, earn_yield, and div_yield get passed, so ev_ebitda falls back to its None default. The code comment says it plainly: "ev/EBITDA → null (EBITDA not stored)." The textbook formula it would use: Enterprise Value (market cap + total debt − cash) ÷ trailing-twelve-month EBITDA. (A fully rigorous EV also adds preferred stock and minority interest; the market-cap+debt−cash form is the accepted simplification.)

A low ratio against sector peers supports a cheap-on-operations case; a high ratio works against it. Because EV folds in debt, this shows leverage that P/E hides — two companies with identical P/Es can read very differently on EV/EBITDA if one carries more debt. It anchors a comparison across different capital structures.

Practically 0 to about 50x for profitable companies; 8–15x covers most S&P 500 industrials and consumer names; tech and growth names routinely sit 20–40x; negative or undefined when EBITDA is at or below zero. These bands are sector-consensus figures, not derived from our own stored universe.

EBITDA strips out depreciation, which is a real cash cost for capital-intensive businesses — so a low ratio can flatter asset-heavy companies that have to keep reinvesting just to stand still.

We take the snapshot trailing P/E and compute 100 ÷ P/E, giving cents of trailing earnings per dollar of price, expressed as a percentage. The P/E is yfinance's trailingPE (last price ÷ trailing-12-month EPS), stored on TickerSnapshot. Null when P/E is missing or not positive.

Stack it against current Treasury yields: a wide spread (stock yield well above the bond yield) strengthens a cheap-valuation thesis; a narrow or inverted spread weakens it. It reframes P/E as a rate, so you can line equities up against fixed income without converting in your head.

Above ~5-6% (P/E below ~20) means the market is pricing in modest expectations — room for upside if earnings hold. Below ~2-3% (P/E above ~33) means the stock is priced for strong growth, so any earnings disappointment hits harder. Around 4% is roughly the market average in a normal rate environment.

Practically 0% to ~15%+. Companies with a non-positive P/E are excluded (shown null). Most profitable large-caps land 2-7%. Beaten-down cyclicals or deep-value names can reach 10-15%. Above ~15% often reflects distress or a one-time earnings spike, not durable cheapness.

Built from trailing P/E, so a one-time earnings boost (asset sale, tax benefit) inflates it and makes the stock look cheaper than it is on a go-forward basis. Because the input is yfinance's own trailingPE, it also carries whatever EPS adjustments yfinance applies in that TTM figure.

Not yet computed in our code. The field exists in the schema (FundMetrics.roic, schemas/stocks.py:304) and the frontend mapper passes it through (fundamentals.ts:19), but ticker_service.py:1831 explicitly leaves it null with the comment "roic/current-ratio/margin-trajectory aren't stored -> null (flag-don't-fake; the client keeps its prior value)." No backend engine populates it. The textbook formula is NOPAT divided by invested capital, but invested capital has several accepted conventions: total debt + total equity - excess cash; total assets - current liabilities; or simply debt + equity. We have not picked one because nothing computes it.

When populated, it describes whether a dollar of capital put into the business comes back as more than a dollar. ROIC compared against the firm's cost of capital is a common screen for whether returns exceed what that capital costs; readings that sit above it across multiple years are one base-rate marker of a durable advantage, while readings persistently below it describe a business whose reported profits are not keeping pace with the capital it consumes. It separates earnings growth that pays for itself from growth funded by ever-larger capital injections - a distinction ROE and margins can hide.

Theoretically unbounded on the high end - asset-light franchises can exceed 50-100%; negative for loss-makers. Typical S&P 500 median sits around 10-14%. Readings above ~30% are uncommon and warrant a check for off-balance-sheet capital (operating leases, expensed R&D) that shrinks the denominator.

Banks and insurers are excluded by convention - their "invested capital" is regulatory, not economic, so cross-sector comparison breaks down. For all companies, capitalizing operating leases and R&D changes the denominator materially, and different sources treat this differently, so ROIC is only comparable within one consistent methodology. Most importantly: in our product the value is NOT live-computed. The field is null in the backend (flag-don't-fake), so whatever shows on the stock page is the mock/seed value baked into the frontend's default Ticker object, falling back via `f.roic = m.roic ?? f.roic`.