Estimating Equity Volatility

Introduction

You're pricing options, sizing risk, or setting limits, so you need a reliable view of equity volatility that feeds models, capital, and guardrails; volatility is the standard deviation (s.d.) of log returns measured over a chosen horizon (daily, monthly, annual), and here's the quick math: compute log returns, take their s.d., then annualize (for daily multiply by sqrt(252)). It's defintely the baseline input for pricing, capital, and limits. Volatility estimates turn noisy returns into actionable risk numbers.

Key Takeaways

• Volatility = s.d. of log returns (annualize by sqrt(252) for daily); it's the baseline input for pricing, capital, and limits.
• Data hygiene is critical-adjust for corporate actions, remove outliers, align times, and pick sampling frequency; garbage in, garbage out.
• Match estimator to horizon: realized volatility for short windows, EWMA for adaptable persistence, GARCH/HAR for clustering and multi-horizon effects; blend methods when unsure.
• Implied vols and variance-swap term structures capture market expectations and risk premia-blend with historical estimates based on horizon and regime.
• Operationalize with rolling backtests, monitoring, automated pipelines, and retraining; tie forecasts to decisions and assign Risk/Quant ownership for delivery.

Data and preprocessing

You need clean, aligned market data before you estimate volatility - otherwise your model is fitting noise, not risk. Here's the direct takeaway: standardize sources, fix corporate actions, remove microstructure artifacts, and pick a sampling frequency that matches your horizon so your volatility numbers actually reflect the risk you act on.

Data sources

Start with four canonical feeds and use each where it shines. Daily closes give long-horizon stability; intraday ticks capture short-horizon variance; option-implied vols (from exchange option chains) reveal market expectations and premia; benchmark indices (S&P 500, Nasdaq, Russell) provide market-wide scaling and regime context.

• Daily prices - use exchange-adjusted close (regular session); good for horizons >1 week; typical sample: ~252 trading days per year.
• Intraday ticks and quotes - use consolidated TAQ or direct exchange feeds for high-frequency realized volatility; expect 390 minutes regular session → 78 5‑minute bars/day or 390 1‑minute bars/day.
• Option-implied vols - pull mid-implied vol from liquid strikes (near-the-money) and expiries; record bid/ask to filter stale quotes.
• Benchmarks and factors - use index returns, VIX/variance swaps, and sector ETFs to normalize idiosyncratic moves.

Practical tip: centralize timestamps in UTC and tag each instrument with exchange code. If you recieve multiple vendor feeds, prefer direct exchange data for ticks and consolidated feeds for fills.

Clean steps

Cleaning is step-by-step engineering, not one-off scripting. Apply consistent corporate-action adjustments, remove price anomalies, and align sessions so returns are comparable across instruments and timezones.

• Adjust for splits and dividends - back-adjust historical prices using split factors; for total-return analysis, add dividend cash flows to returns instead of changing prices.
• Handle corporate events - for spin-offs or large one-offs, create event flags and either remove affected window (recommended ±5 trading days) or model separately.
• Remove outliers - winsorize or filter intraday returns beyond a threshold (common: ±5% intraday, ±20% daily) but validate on a per-stock basis to avoid removing real jumps.
• Filter stale or crossed quotes - enforce spread and timestamp freshness rules (e.g., ignore quotes > 1 second old for tick aggregation).
• Align trading hours - drop trades outside regular trading hours (RTH) unless your strategy explicitly uses pre/post-market; for US equities RTH is 09:30-16:00 ET.
• Impute missing bars carefully - forward-fill only when markets are open; require minimum coverage (suggested: 80% of expected bars per day) or drop the day.
• Document all transforms - store raw, adjusted, and difference series; keep an audit trail and code versioning so changes are reproducible.

Quick check: recompute daily volatility before/after adjustments and report the percent change; if adjustments change vol by > 10%, investigate - that's often a sign of mis-handled corporate action.

Resample and choose sampling frequency

Match sampling to horizon: too-fine data amplifies microstructure noise; too-coarse misses intraday risk. Decide frequency based on decision cadence and liquidity.

• Daily horizon (weeks to quarters) - use end-of-day closes or daily returns; stable and low-noise for risk limits and VaR.
• Intraday horizon (minutes to a day) - use 5‑minute bars as a default for trading signals and realized vol; gives ~78 bars/day and balances noise vs information.
• High-frequency horizon (seconds) - only for market-making; apply subsampling, pre-averaging, or two-scale realized volatility to reduce microstructure bias.
• Resampling steps - convert ticks → time bars (calendar or trade-time), aggregate to VWAP or mid-price, compute log returns, then square and sum for realized variance.
• Seasonality and DST - adjust for daylight saving shifts and lunch-hour patterns; normalize intraday returns by time-of-day volatility profile.
• Validation - backtest realized vol at multiple sampling rates (1min, 5min, 15min) and pick the cadence that minimizes out-of-sample RMSE vs future realized vol for your horizon.

Operational rule: maintain both raw tick archive and prebuilt bar cache (1m, 5m, 15m, 1d) so you can reprocess when models or corrections change.

Garbage in, garbage out - data hygiene changes estimates materially

Estimating Equity Volatility - Historical and Realized Estimators

You need a repeatable, auditable volatility view to price options, size positions, and set limits; pick tools that match your horizon and liquidity. Here's the quick takeaway: for short windows use realized volatility from intraday ticks, for medium-to-long persistence use EWMA, and keep sample variance as a transparent baseline.

Sample variance baseline

Start simple to build trust: compute the sample variance of log returns as your baseline. The formula is s^2 = sum((r - mean)^2)/(n - 1). Keep this in a daily, auditable table so every value traces to raw closes.

Steps to implement:

• Collect adjusted daily close prices
• Compute log returns r_t = ln(P_t/P_{t-1})
• Calculate mean, then s^2 with n-1 denominator
• Annualize by multiplying std dev by sqrt(252)

Example math: with five daily returns 0.5%, -0.2%, 1.0%, -0.3%, 0.4% you get s^2 ≈ 0.0000287, daily σ ≈ 0.536%, annual σ ≈ 8.51%. What this estimate hides: equal weighting ignores clustering and leverage effects; it will underreact to regime shifts.

One-liner: Keep sample variance as a transparent, auditable fallback.

EWMA - adaptive persistence

EWMA (exponentially weighted moving average) gives recent returns more weight so the estimate responds quickly to volatility shifts. Use the recursion σ_t^2 = λ·σ_{t-1}^2 + (1-λ)·r_{t-1}^2. RiskMetrics popularized λ = 0.94 for daily equity returns; use a higher λ for slower assets, lower λ for ultra-short trading desks.

Practical guidance and controls:

• Initialize σ_0^2 with a recent sample variance (90 days)
• Set λ per use case: 0.94 daily, 0.97 for longer horizons
• Backtest on rolling 90-180 day windows; track RMSE vs realized vol
• Cap σ^2 to avoid explosive spikes from single mispriced ticks

Quick math example: if prior σ^2 = 0.0000287 and last return r = 1.0% (0.01), new σ^2 = 0.94·0.0000287 + 0.06·0.0001 ≈ 0.0000330, annual σ ≈ 9.12%. What this estimate hides: EWMA ignores mean reversion structure and asymmetric shocks; it adapts but can overweight transient noise-monitor hit rates.

One-liner: EWMA adapts fast while remaining simple and stable.

Realized volatility from intraday returns

Realized volatility (RV) sums squared intraday returns to estimate actual variance over short horizons. For a day with m intraday intervals, daily RV = sum_{i=1..m} r_{i}^2. Use RV for horizons measured in days or shorter; it captures intraday clustering and avoids overnight distortion when you separate jump contributions.

Implementation checklist:

• Choose sampling interval (commonly 5-min → 78 samples/day)
• Clean ticks: remove bad prints, align timestamps, adjust corporate actions
• Compute sum of squared log returns per day; annualize by sqrt(252)
• Use subsampling or pre-averaging to reduce microstructure noise
• Separate overnight return and jump component for variance decomposition

Example math: assume day sum of squared 5-min returns = 0.00009 → daily σ ≈ 0.949%, annual σ ≈ 15.07%. What this estimate hides: microstructure noise at 1-min, price discreteness, and missing data bias; choose 5-min as a practical trade-off, and test sensitivity to 1-min and 15-min samples.

One-liner: Use realized vol for short windows; adjust sampling to control noise and bias.

GARCH and model-based approaches

GARCH basics and practical setup

You're deciding whether to move from simple historical vol to a dynamic model that captures clustering and persistence, so start with the canonical GARCH formulation and a clear data pipeline.

Write the core recursion as sigma^2_t = omega + alpha e_{t-1}^2 + beta sigma^2_{t-1}, where e_t is the return innovation (return minus conditional mean) and sigma^2_t is the conditional variance. Use returns in decimal form (0.01 = 1%).

Quick math example: pick alpha = 0.06 and beta = 0.92. If you want a long-run annualized vol of 20%, convert to daily variance: 0.20^2 / 252 = 0.0001587. Solve for omega = (1-alpha-beta) daily_var = 0.02 0.0001587 = 1.59e-6. That gives stable, interpretable parameters. What this hides: parameter estimates shift if you use returns net of dividends, different sampling frequency, or a changing mean.

Practical steps

• Use de-meaned returns and test for autocorrelation.
• Initialize sigma^2_0 at sample variance of the in-sample window.
• Clip extreme intraday returns or winsorize to avoid estimation blow-ups.
• Fit on at least 1,000 observations for daily GARCH; use longer series for reliable alpha/beta.

Watchouts: if alpha + beta → 1 you're near a unit root (persistent shocks). That's defintely a red flag for parameter instability and needs either re-specification or a fractionally integrated model.

Extensions: asymmetry and multi-horizon realized-vol models

GARCH is a baseline; extensions fix empirical patterns. Choose based on the behavior you see in residuals and in-sample diagnostics.

EGARCH (exponential GARCH) models log variance so shocks impact volatility asymmetrically without requiring non-negativity constraints. Use EGARCH when negative returns spike vol more than positive returns. Typical EGARCH term: gamma (|e_{t-1}| - E|e|) + xi e_{t-1}.

GJR-GARCH (Glosten-Jagannathan-Runkle) adds a leverage indicator: sigma^2_t = omega + alphae_{t-1}^2 + gammaI_{t-1}e_{t-1}^2 + betasigma^2_{t-1}. Use when negative returns produce larger variance increments; expect gamma > 0 if leverage exists.

HAR-RV (Heterogeneous Autoregressive model of Realized Volatility) uses realized (intraday) variances at multiple horizons: daily, weekly, monthly. Fit the regression RV_t = c + b_d RV_{t-1} + b_w RV_{t-1}^{(weekly)} + b_m RV_{t-1}^{(monthly)}. HAR excels for multi-horizon forecasting and is robust when you have high-frequency data.

Practical guidance

• Use EGARCH/GJR for asymmetric effects; prefer EGARCH if you see heavy tails and sign-dependent response.
• Use HAR-RV when you can build realized volatility from tick or 1-min data and need 1-30 day forecasts.
• Combine: fit HAR-RV for short-term realized forecasts, then feed those as inputs or priors into a daily GARCH-type model for stability.
• Estimate standard errors with robust (Newey-West) corrections when serial correlation is present.

One-liner: Model choice trades complexity for incremental forecast accuracy.

Calibration, validation, and deployment controls

You'll calibrate by likelihood and validate by measured forecast impact-here's a step-by-step playbook you can run in 30 days.

Calibration steps

• Choose likelihood: normal for QMLE (quasi-maximum likelihood), Student-t if tails matter. Use QMLE if you expect misspecification.
• Provide initial guesses: set beta from squared-return ACF at lag 1, alpha = 0.05-0.10 as a starting point, omega from unconditional variance.
• Optimize with BFGS or constrained L-BFGS-B to enforce non-negativity and stationarity (alpha ≥ 0, beta ≥ 0, alpha+beta < 1 for standard GARCH).
• Report parameter SEs from the inverse Hessian and check parameter stability across rolling windows of 252 and 1,000 days.

Validation and performance metrics

• Out-of-sample RMSE on annualized vol points (e.g., RMSE = 1.2 vol points means 1.2%); compare to EWMA and realized-vol baselines.
• Conduct a Diebold-Mariano test to check if RMSE reductions are statistically significant.
• Translate forecast differences to P&L: rerun option valuations and delta-hedge simulations. For example process: reprice an ATM one-month option daily under each forecast, simulate hedging P&L over the period, then report mean and tail losses.
• Track VaR exception rates and P&L sensitivity: count exceptions over a rolling 250-day window; target exception rate aligned to your nominal (e.g., 1% for 99% VaR).

Operational controls

• Automate ingestion, calibration, and daily forecast distribution; include alerts when alpha+beta > 0.985 or parameter SEs double.
• Retrain cadence: weekly re-estimation for intraday models, monthly for daily GARCH, quarterly for structural changes.
• Archive model versions and inputs for backtest audit; keep raw high-frequency ticks for 90 days live and full dataset for compliance.
• Set governance: Risk/Quant to own model sign-off, with clear rollback triggers (e.g., forecast RMSE worse than EWMA by >10% for 10 trading days).

Concrete next step: Risk/Quant - run a 90-day rolling backtest comparing EWMA, GARCH, EGARCH, and HAR-RV using your FY2025 returns feed; produce RMSE, Diebold-Mariano p-values, and a hedged option P&L table within 30 days.

Market-implied measures and term structure

Implied volatility: extract from liquid option prices using Black model inversion

You need implied vols when you want the market's forward-looking price of risk, so start by pulling clean option mid-prices for the most liquid strikes and expiries that trade on the exchange you use.

Practical steps:

• Filter by volume and open interest; drop stale quotes.
• Use mid (bid+ask)/2 and remove obvious crosses or zero bids.
• Convert American equity options to Black-Scholes equivalents (use forward price with continuous dividend yield) or use Black-76 for futures.
• Invert option price to implied volatility using a robust root finder (Brent or Newton-Raphson with bounds 0.0001-5.0).
• Interpolate the volatility surface in strike (use SVI or piecewise quadratic) and time (linear in variance) for missing points.

Concrete example and quick math: suppose underlying S = $100, strike K = $100, time to expiry T = 30/365 years, risk-free r = 3.5%, option mid-price = $2.50. Run Black-Scholes inversion - you'll find implied vol around ~27-30% (use a numeric solver). What this hides: early exercise, dividends, and poor quote quality can bias the result, so always sanity-check implied vols vs nearby strikes and expiries.

One-liner: Implied vols are market prices, not model outputs - they embed expectations and risk premia.

Use VIX-style variance swaps to get 30-day expected variance; derive term structure via strips

If you want a single-number market consensus for 30 days, use the VIX/variance-swap approach: integrate OTM option prices across strikes to compute expected variance, then convert to volatility. That gives you an arbitrage-derived 30-day variance quote.

Steps and best practices:

• Collect OTM call and put mid-prices across strikes for the two nearest expiries that bracket 30 days.
• Compute forward price F using the put-call parity at the at-the-money strike.
• Follow the VIX discrete integration: sum option price/strike^2 terms, weight by strike spacing, then annualize variance.
• Interpolate between expiries to get exactly 30-day variance using time-weighted linear interpolation in variance.
• Convert annual variance to 30-day variance by multiplying by 30/365; convert back to vol by square root.

Concrete conversion: if the annualized VIX-style number is 16%, annual variance = 0.16^2 = 0.0256. The 30-day expected variance is 0.0256 30/365 = 0.00210, so the 30-day implied vol (annualized) remains 16% but the 30-day variance used in models is 0.00210.

Building the term structure: compute variance swaps for multiple expiries (7, 30, 90, 180 days), then express each expiry as annual variance and interpolate/extrapolate linearly in variance to get any horizon. Use bootstrapped variance strips to price horizon-specific exposures and to compare market-implied vs realized term structure.

One-liner: Variance-swap strips convert option smiles into a tradable term structure of expected variance.

Blend implied and historical with a weight based on forecast horizon and regime

You'll usually get better forecasts by combining implied and historical information. Implied vols tell you market expectations plus risk premia; historical (realized) vols tell you what actually happened. Blend them explicitly, and tie weights to horizon and regime.

Practical recipe:

• Compute annualized implied variance V_imp and historical realized variance V_hist over a rolling window (typically 90 days for history).
• Choose a horizon H in days. Convert horizon to fraction of year h = H/365.
• Use a simple weight rule: weight implied = min(0.9, max(0.1, 0.7 (30/H))) for H≥7; or use a statistically optimal weight by minimizing MSE on your backtest (analytical if you estimate each estimator's error variance).
• Blend in variance space: V_blend = wV_imp + (1-w)V_hist. Convert to vol: sigma_blend = sqrt(V_blend).

Numeric example: market implied annual vol = 18% (V_imp = 0.0324), historical annual vol = 12% (V_hist = 0.0144), target horizon = 30 days. Using w = 0.7, V_blend = 0.70.0324 + 0.30.0144 = 0.02724. sigma_blend = sqrt(0.02724) ≈ 16.5%. Here's the quick math: implied pulls the forecast up from 12% to 16.5% for the month. What this estimate hides: implied may include a volatility risk premium and short-term skews; historical may lag regime shifts.

Operational controls and regime rules:

• Shift weight toward implied when realized 30-day jump (VIX gap) exceeds a threshold (e.g., > 3 percentage points).
• Lower implied weight when option market depth is thin (low notional or wide bid-ask spreads).
• Backtest weights on rolling 90-day windows and measure P&L sensitivity and VaR exceptions before production.

One-liner: Implied vols reflect market expectations and risk premia, not pure realized risk.

Practical implementation and controls

Horizon and estimator fit

You need the estimator to match the decision horizon: use intraday realized measures for trading-day decisions, short-window EWMA for weekly sizing, and model-based or blended forecasts for quarter-level risk limits.

Steps to map horizons to estimators:

• Use 5‑minute or tick returns (typically 78 5‑min intervals per U.S. trading day) to build realized volatility for intraday trading and execution risk.
• Use daily returns with EWMA (common lambda 0.94; half‑life ≈ 11 trading days) for tactical weekly forecasts and position-sizing.
• Use GARCH/HAR or blended implied/historical for monthly to quarterly stress and limit-setting-rely on multi‑horizon models like HAR‑RV for persistence across 1/5/22 day horizons.
• Annualize and convert consistently: daily sigma × sqrt(252) = annual sigma; monthly ~ sqrt(21) etc.

Here's the quick math: a 15% annual vol → daily sigma = 0.15/√252 ≈ 0.00945; for a $100,000,000 portfolio, 1‑day 99% VaR = 2.33×0.00945×100,000,000 ≈ $2,200,000. If vol rises to 18%, VaR ≈ $2,640,000-a $440,000 P&L swing.

What this estimate hides: non‑normal tails, liquidity haircuts, and intraday autocorrelation-so pick the estimator by action (trade, limit, hedge), not by elegance.

One-liner: Match estimator to decision horizon and quantify the P&L impact before you act.

Backtest, performance metrics, and P&L sensitivity

Run rolling, out‑of‑sample backtests tied to the exact decision you make: forecasts used for trading must be tested using the same rebalancing and execution rules.

Concrete backtest design:

• Use rolling windows: 90, 180, and 252 trading‑day anchor windows; reforecast daily and keep forecast errors out‑of‑sample.
• Track metrics: RMSE, MAE, hit rate (coverage), quantile loss for VaR, and P&L sensitivity (delta VaR × portfolio value).
• VaR exception checks: at 99% VaR expect 2.5 exceptions per 250 trading days; at 95% expect 12.5.
• Stat tests: use Kupiec (coverage) and Christoffersen (independence) tests for exception patterns; reject models that fail both repeatedly.
• Simulate P&L: run stress revaluations and option greeks; e.g., change in vol from 15%→18% gave ~$440k one‑day VaR increase on a $100m book-use that to set intraday limits.

Backtest cadence and thresholds:

• Daily: track realized vs forecast and alert on >20% persistent error over 10 trading days.
• Weekly: update model parameters and check RMSE drift; monthly: full out‑of‑sample comparison across models.

What this test hides: lookahead bias, mismatched execution assumptions, and regime shifts-so always simulate the actual trading and settlement latencies.

One-liner: Backtests must measure the decision impact-coverage, P&L, and exception patterns-not just low RMSE.

Operationalize data pipeline, monitoring, and retraining cadence

Automation and controls turn a good model into a usable tool: build SLAs, observability, and clear retrainning triggers so the model stays decision‑relevant.

Data and pipeline rules:

• Sources: daily closes, intraday ticks, option mid/prices, and benchmark indices; enforce corporate action adjustments within T+1.
• Latency SLAs: intraday ticks must arrive within 60 seconds for live risk; end‑of‑day reconciliation within 30 minutes.
• Quality gates: flag >0.5% missing intervals or >1% price jumps (ex‑dividend corrected) for manual review.

Monitoring and alerts:

• Track model metrics: 30/60/90‑day RMSE, realized:forecast ratio, hit rate, and implied‑realized gap; set alerts when any metric moves >20% vs baseline.
• Operational alerts: daily feed drop, stale option vols, or failed corporate action apply should trigger on‑call quant.

Retraining and governance:

• Cadence: intraday/realized volatility models retrain weekly; daily/EWMA parameters review monthly; structural models and GARCH recalibrate quarterly or after major regime shifts.
• Trigger-based retrain: retrain whenever 30‑day RMSE increases >25% or exception frequency exceeds expected by >50%.
• Approval: model changes require backtest summary, P&L impact table, and risk committee sign‑off for parameter shifts >10%.

Operational checklist example: automated pipeline → daily backtest run at 07:00 ET → monitoring dashboard updates → alert if realized:forecast outside 0.8-1.2 band → quant on call investigates.

One-liner: Forecasts must be measurable, monitored, and tied to decisions so alerts turn directly into actions.

Next step: Risk/Quant - deliver a 90‑day rolling backtest comparing EWMA (λ=0.94), realized 5‑min, and GARCH forecasts and present P&L sensitivity analysis within 30 days.

Conclusion

Choose estimators by horizon, liquidity, and use case

You're picking an estimator to drive a decision - sizing intraday positions, setting a weekly hedge, or fixing quarter-end limits - so match the tool to the job.

Use these practical mappings and tradeoffs:

• Favor realized volatility (high-frequency sum of squared returns) for intraday and same-day trading - it reacts to current microstructure and jumps.
• Use EWMA (exponentially weighted moving average) with a daily lambda like 0.94 for short-to-medium horizons when you want persistence but faster adaptation than a plain sample variance.
• Choose GARCH-family or HAR-RV (Heterogeneous Autoregressive Realized Vol) for multi-week to quarterly forecasting where clustering and multi-horizon effects matter.
• Pull market views from implied vol (options) for near-term event risk or when pricing client trades; treat implied as expectation plus risk premium, not pure realized.

One-liner: Pick the estimator that maps to your decision horizon and liquidity; blend if you can't decide.

Quick actions: build a ninety day backtest, compare EWMA, GARCH, and realized vols, and track implied vs realized gaps

You're asked to deliver a rapid, measurable comparison - here's a tight, executable plan you can run now.

• Assemble data: clean daily closes, 5-minute intraday ticks, and front-month option vols for the most recent window ending the run date.
• Run a rolling backtest covering the most recent 90 calendar days (or 90 trading days if you prefer consistency) with daily reforecasting.
• Generate forecasts from: sample variance (30/60-day windows), EWMA (0.94 lambda), GARCH(1,1) (MLE), and realized volatility (5-min aggregation).
• Score forecasts on these metrics: RMSE of variance, Mean Absolute Error of volatility, VaR exception rate at 99 percentile, and P&L sensitivity (Δ daily VaR → Δ funding required).
• Track implied vs realized: compute daily implied minus realized gap, summarize with mean, median, and 95th percentile of the gap over the backtest.
• Visualize: time series of forecasts vs realized, a scatter plot of implied vs realized, and a confusion table for VaR hits by model.

One-liner: Run a 90-day rolling backtest, score on RMSE and VaR hits, and plot implied vs realized gaps to expose model divergence.

Owner: Risk/Quant team to deliver first backtest and model comparison within thirty days

You're delegating delivery - make the ask tight and auditable so the team can act without endless debate.

Deliverables (owner: Risk/Quant):

• Data pack: cleaned price and option files for the backtest window, with adjustment logs.
• Backtest notebook: reproducible code that runs the 90-day rolling experiment and outputs metrics and charts.
• Model table: point estimates, RMSE, VaR exception rate, and P&L sensitivity for EWMA, GARCH, realized vol, and a simple implied blend.
• One-page decision memo: recommended default estimator per horizon and a blend rule (weights) for production use.

Timeline and checkpoints:

• Day 7: data ingestion and cleaning complete; sample runs validated.
• Day 18: full backtest complete; draft metrics and charts ready.
• Day 30: final memo and model code delivered; handoff to Ops for automation.

One-liner: Risk/Quant owns the run - deliver code, metrics, and a recommendation within 30 days so Ops can automate next steps.

Next step: Risk/Quant - confirm dataset access and start the first ingestion job by end of business tomorrow; Ops - reserve compute for the 90-day backtest run.