By Expected Move From Implied Volatility
Expected move is price times IV times the square root of days over 365. See the formula, the straddle shortcut that matches it, and what realized moves did.
The expected move is the range an options market is pricing for a stock over a fixed number of days, and implied volatility is the input that sets it: share price times implied volatility times the square root of days divided by 365. A $100 stock carrying 30% implied volatility over 30 days has an expected move near $8.60, or 8.6%, since 0.30 times the square root of 30 divided by 365 comes to 0.086. That figure is a one-standard-deviation range, not a forecast of direction and not a level the price is unable to cross.
How to calculate the expected move from implied volatility
Implied volatility is the annualized standard deviation of returns that an option's price implies. It always arrives as a yearly number, so a 30% reading describes a one-year range, and every shorter window has to be scaled out of it. Volatility scales with the square root of time, which is why the days sit under a square root sign rather than dividing straight through.
Expected move = price × IV × √(days ÷ 365)
Two conventions decide whether your number matches the one your broker shows. Calendar days over 365 is the retail standard, while some desks scale by trading days over 252, which returns a slightly wider range for the same IV. The output is one standard deviation, a band covering roughly 68% of outcomes under a normal distribution. Doubling it gives the two-standard-deviation band and roughly 95%.
Whether the IV you plugged in is large at all is a separate question with its own page: is 30% IV high puts a single reading against the market's own distribution.
Why the range grows with the square root of days
Hold one stock and one session fixed, change only the horizon, and the shape of the formula appears on its own. Apple's near-the-money contracts in mid-July 2026, grouped by how far out they expire:
The exact SQL behind every number
SELECT multiIf(days_to_expiry <= 7, '1 week',
days_to_expiry <= 14, '2 weeks',
days_to_expiry <= 45, '1 month',
days_to_expiry <= 120, '3 months',
days_to_expiry <= 240, '6 months',
'1 year') AS horizon,
round(avg(days_to_expiry), 0) AS avg_days,
round(100 * avg(toFloat64(implied_volatility)), 1) AS iv_pct,
round(100 * avg(toFloat64(implied_volatility)) * sqrt(avg(days_to_expiry) / 365), 2) AS expected_move_pct,
round(avg(toFloat64(underlying_close)) * avg(toFloat64(implied_volatility))
* sqrt(avg(days_to_expiry) / 365), 2) AS expected_move_usd,
round(avg(toFloat64(underlying_close)), 2) AS underlying_price,
formatDateTime(max(date), '%b %e, %Y') AS as_of
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND date = (SELECT max(date)
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND date <= toDate('2026-07-15'))
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 1 AND 400
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
GROUP BY horizon
HAVING count() >= 3
ORDER BY avg_daysAs of Jul 15, 2026, the 1 week bucket averaged 5 days to expiry and 28% implied volatility, an expected move of 3.17%, or $10.41 against a $327.8 share price. The 1 year bucket averaged 292 days and 28.4% IV, an expected move of 25.44%, or $83.39.
The lesson is in the ratios rather than the levels. Quadruple the days and the expected move doubles, on any stock at any IV, since the square root of 4 is 2. Someone annualizing a one-month range by multiplying it by 12 overstates the year by a factor of about 3.5: the correct multiplier is the square root of 12, which is 3.46.
The straddle shortcut, and why it reads about 20% low
There is a faster route to the market's own expected move, and it needs no arithmetic. Look up the at-the-money straddle, the call and the put struck at the same price with the same expiry, and add the two premiums. Many desks quote that sum as the expected move.
The two methods do not print the same number, and the gap is not an error in either one. A straddle pays the absolute distance the stock finishes from the strike, so its price is the market's expected average move. The formula returns one standard deviation. For a normal distribution the average absolute deviation equals 0.798 of a standard deviation, so the straddle sits about 20% under the formula's answer, and multiplying the straddle by 1.25, which is 1 divided by 0.798, brings the two together.
Run it on the $100 hypothetical from the top. The formula gives $8.60. The at-the-money straddle on that stock would price near $6.86, since 0.798 × 8.60 = 6.86. Multiply $6.86 by 1.25 and you land back at $8.58. Two routes, one number, once you know which statistic each of them reports. Reading an option chain shows where those two premiums sit.
What the expected move does not mean
- Not a direction. The band is symmetric around today's price, and the options market prices its width, not its side.
- Not a promise. The 68% comes from a normal distribution, and real returns carry fatter tails, so far outcomes land more often than the model allows.
- Not a barrier. Under the model, about one window in three finishes outside the one-standard-deviation band. Landing outside it is the ordinary case.
- Not fixed. Implied volatility is repriced every session, so the expected move for a given expiry is rewritten daily.
What happens after an earnings report
A scheduled earnings date is the clearest case of implied volatility being bid up in advance and marked down the session after the news is public, a pattern known as IV crush. The expected move collapses on the same schedule. NVDA's late-May 2023 report landed after the close of the first session in the panel below.
The exact SQL behind every number
WITH
(SELECT avg(toFloat64(implied_volatility))
FROM global_markets.options_greeks
WHERE underlying_symbol = 'NVDA'
AND date = toDate('2023-05-24')
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 20 AND 45
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05) AS iv_report_day,
(SELECT avg(toFloat64(underlying_close))
FROM global_markets.options_greeks
WHERE underlying_symbol = 'NVDA'
AND date = toDate('2023-05-24')
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 20 AND 45
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05) AS px_report_day
SELECT date,
formatDateTime(date, '%b %e') AS session_label,
round(100 * avg(toFloat64(implied_volatility)), 1) AS iv_pct,
round(100 * avg(toFloat64(implied_volatility)) * sqrt(avg(days_to_expiry) / 365), 2) AS expected_move_pct,
round(100 * avg(toFloat64(implied_volatility)) / iv_report_day, 1) AS iv_pct_of_report_day,
round(100 * (avg(toFloat64(underlying_close)) / px_report_day - 1), 2) AS move_from_report_day_pct
FROM global_markets.options_greeks
WHERE underlying_symbol = 'NVDA'
AND date BETWEEN toDate('2023-05-24') AND toDate('2023-06-09')
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 20 AND 45
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
GROUP BY date
HAVING count() >= 3
ORDER BY dateNear-the-money implied volatility measured 115.1% on May 24, the session of the report, with an implied move to expiry of 30.54%. The next session the same measurement came to 42.9% of that mark. By Jun 9 implied volatility read 39.2%, and the shares stood 1.71% from their report-day close.
That combination sits behind a familiar complaint. A trader can call the direction of an earnings move correctly and still lose money on a long option: the volatility input the contract was priced on gets marked down the moment the uncertainty is resolved. How earnings move the greeks carries the rest of that position through.
Does the expected move hold up against realized moves?
The claim is testable, so here is the test. Every Wednesday over the two years to mid-June 2026, for six liquid names, take the near-the-money implied volatility on contracts 25 to 40 days out, convert it to an expected move over the days that follow, then measure how far the stock actually travelled by the first session at least 30 calendar days later.
The exact SQL behind every number
WITH obs AS (
SELECT underlying_symbol AS ticker,
date AS obs_date,
avg(toFloat64(implied_volatility)) AS iv,
avg(toFloat64(underlying_close)) AS spot
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('NVDA', 'AAPL', 'MSFT', 'XOM', 'SPY', 'KO')
AND date BETWEEN toDate('2024-06-12') AND toDate('2026-06-17')
AND toDayOfWeek(date) = 3
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 25 AND 40
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
GROUP BY ticker, obs_date
HAVING count() >= 4 AND avg(toFloat64(implied_volatility)) > 0.01
),
px AS (
SELECT underlying_symbol AS ticker,
date AS px_date,
avg(toFloat64(underlying_close)) AS close_px
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('NVDA', 'AAPL', 'MSFT', 'XOM', 'SPY', 'KO')
AND date BETWEEN toDate('2024-06-12') AND toDate('2026-07-25')
AND days_to_expiry BETWEEN 5 AND 60
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.02
GROUP BY ticker, px_date
),
moves AS (
SELECT obs.ticker AS ticker,
obs.obs_date AS obs_date,
any(obs.iv) AS iv,
any(obs.spot) AS spot,
argMin(px.close_px, px.px_date) AS end_px,
min(dateDiff('day', obs.obs_date, px.px_date)) AS elapsed_days
FROM obs
INNER JOIN px ON obs.ticker = px.ticker
WHERE px.px_date >= addDays(obs.obs_date, 30)
AND px.px_date <= addDays(obs.obs_date, 36)
GROUP BY ticker, obs_date
)
SELECT ticker,
count() AS windows_tested,
round(quantileDeterministic(0.5)(100 * iv * sqrt(elapsed_days / 365), cityHash64(obs_date)), 2) AS implied_move_pct,
round(quantileDeterministic(0.5)(100 * abs(end_px / spot - 1), cityHash64(obs_date)), 2) AS realized_move_pct,
round(100 * countIf(abs(end_px / spot - 1) > iv * sqrt(elapsed_days / 365)) / count(), 1) AS realized_over_implied_pct
FROM moves
GROUP BY ticker
ORDER BY implied_move_pct DESCNVDA priced the widest range of the six, a median implied move of 13.3% against a median realized move of 6.77% across 103 windows. At the calm end, SPY priced 4.37% against 2.68% realized.
The last column is the honest one. A one-standard-deviation range is supposed to be breached about 32% of the time, and that is the benchmark to hold it against, not zero. 23.3% of NVDA windows finished outside the range its options had priced, and 24.3% of SPY windows did the same. Read the two medians side by side for each name and the gap between them, in whichever direction it runs, is the whole argument about whether options were priced for more movement than arrived. Screening for the names carrying the widest implied ranges is a different exercise, and the highest implied volatility stocks ranks them.
Data notes and definitions
- Near the money means a strike within 5% of that session's underlying close, on contracts with converged implied volatility and non-zero volume.
- Expected move uses calendar days over 365 throughout, and the realized move is the percentage distance between the observation close and the close on the first session at least 30 calendar days later, with the sign removed.
- Observations are weekly while the forward windows run 30 days, so neighbouring windows overlap and the counts are not independent draws.
Expected move FAQ
How do you calculate the expected move from implied volatility?
Multiply the share price by implied volatility as a decimal, then by the square root of days divided by 365. A $50 stock at 40% implied volatility over 45 days: 50 × 0.40 × √(45 ÷ 365) = $7.02, a range of about 14%.
Is the at-the-money straddle price the same as the expected move?
Close, and not identical. The straddle prices the expected average move, which sits at about 0.798 of one standard deviation. Multiplying the straddle premium by 1.25 recovers the one-standard-deviation figure the formula gives.
Does a stock stay inside its expected move?
Usually, and the model expects it to fail about 32% of the time. Across the weekly windows tested above, 23.3% of NVDA windows finished outside the implied range and 24.3% of SPY windows did.
Why does the expected move shrink right after earnings?
The expected move is a direct function of implied volatility, and implied volatility is bid up before a scheduled report and marked down once the result is known. In the panel above, the session after NVDA's report carried 42.9% of the report-day reading.
Is a wider expected move a better opportunity?
It is a wider range and nothing more. A larger expected move means the options market is pricing more uncertainty, and the contracts carrying that uncertainty cost more in proportion. The width says nothing about whether its price is fair.
Every panel here is a stored query with its SQL attached. Open one, swap the ticker, and run the same implied-versus-realized test on the Strasmore terminal.