Volatility Surface Construction: From Quotes to an Arbitrage-Free Surface

Quotes are noisy. Markets close, strikes get relisted, bid-ask spreads double during a 2 PM Fed announcement. The implied volatility surface your pricing library reads at 3 PM is not the same thing as the hundred thousand quotes your data vendor pushed at 3:01 — between the two sits an entire engineering discipline. This article is about that discipline.

The end goal is a function $\sigma(K, T)$ — or equivalently the total variance $w(K, T) = \sigma(K, T)^2 T$ — satisfying three things at once: smooth, arbitrage-free, and close enough to market quotes that the remaining pricing error stays below the bid-ask spread. Getting this right is much of the daily work of running a derivatives desk; getting it wrong means biased hedges, exotics priced away from the market, and eventually a blow-up somewhere. One lens runs through the whole article: the surface is a probability distribution in disguise, and every arbitrage constraint is, at bottom, a demand that the distribution actually exist.

The Three Arbitrage Conditions

An arbitrage-free surface means three classes of inequality hold everywhere, each mapping to an option structure that would otherwise print free money (Hull, 2018, Ch. 18.6; Gatheral, 2006, Ch. 2).

Calendar arbitrage (same strike, different maturities). For a fixed strike, total variance $w(T) = \sigma^2(T) T$ must be non-decreasing in $T$:

If $w$ falls with $T$, sell the cheap variance, buy the expensive, and lock in profit as the longer tenor converges to the shorter — a calendar spread at a single strike.

Butterfly arbitrage (same maturity, different strikes). For fixed $T$, the call price must be convex in strike:

or, numerically,

for any $K_1 < K_2 < K_3$ (with spacing weights). Violate it and you can build a butterfly with non-negative payoff and negative price. Convexity has a deeper reading — by Breeden-Litzenberger (1978), it is equivalent to a non-negative risk-neutral density:

for all $K$. This is “the surface is a distribution” taken literally: wherever the second derivative goes negative, your “distribution” has assigned negative probability somewhere.

Vertical arbitrage (call spreads). For any pair of strikes $K_1 < K_2$:

The left side says call prices are non-increasing in strike; the right says a bull spread cannot cost more than the discounted value of its maximum payoff — the discount factor appears because the payoff lands at $T$.

The three conditions must be checked jointly: a fix that repairs one can break another. And even when individual quotes are clean, naive interpolation between them manufactures phantom arbitrage — which is exactly why “quotes to surface” is an engineering problem rather than a lookup.

Cleaning: Always the First Step

The calibration pipeline starts with cleaning, in a fixed order:

1. Convert bid/ask to mid. Simple average, or size-weighted if you have top-of-book data. Mid is more stable than either side.
2. Filter bad quotes. With a prior guess for the vol, drop points where $|IV - \sigma_{\text{local}}| > 5\%$; without one, drop quotes with suspicious volume or vendor flags.
3. Synchronize across strikes and maturities. Intraday drift, holiday effects, and staggered vendor updates desynchronize the surface; replace inconsistent quotes with smoothed values.

A cleaned surface is “market-data-consistent” but not necessarily arbitrage-free. Making it arbitrage-free is the next step — and here the article hits its first real fork.

Parametric vs. Non-Parametric: Two Routes

Non-parametric smoothing fits a regularized smooth function to the data. The reference method is Andreasen & Huge (2010): on a discrete grid containing all quoted strikes and maturities, build the interpolation through a finite-difference construction that guarantees a positive density at every grid point, without going through Dupire’s formula; the result is arbitrage-free by construction. It’s implemented in commercial libraries and in QuantLib, and runs in production at many desks. Two costs: arbitrariness enters through grid resolution (too fine overfits, too coarse misses structure), and beyond the grid — in the deep wings — you need a parametric extension anyway.

Parametric forms choose a small-parameter family, constrain it to be arbitrage-free by construction, and fit the parameters. The shapes are restricted to “what you expect a surface to look like” — which is both the weakness (a regime change can leave the wings poorly fit) and the strength (interpretable parameters, trackable day over day, millisecond evaluation).

In practice, surface construction for European options is dominated by parametric forms. The next two sections cover the two generations of protagonist on that route.

SVI: One Slice at a Time

Gatheral’s SVI (2004) parameterizes the implied variance of a single maturity slice (annualized convention; multiply by $T$ for total variance):

with $k = \ln(K/F)$, $F = S_0 e^{rT}$, and the 5-vector $\theta_{\text{SVI}} = (a, b, \rho, m, \sigma)$ — five parameters per slice. Its expressiveness matches equity smiles almost exactly: asymptotically linear wings, at-the-money curvature governed by $\sigma$, skew by $\rho$, translation by $m$. The well-known constraints:

The first two keep variance positive; the third caps the wing slopes — it comes from Lee’s moment formula bounding the slope of total variance in the wings, and holding it is what keeps the deep wings from implying exploding moments (it’s a wing/butterfly-direction constraint; the calendar direction must be checked separately across slices).

Fitting SVI is non-convex least squares. The robust recipe has two steps: pick anchor strikes per slice — ATM, 10-delta put, 25-delta put, 25-delta call, 10-delta call; five points against five parameters gives you a direct initial solve — then refine by least squares over all quotes in the slice.

SVI’s weakness is between slices: fit each independently and the parameters can jump across tenors, and ATM total variance can even decrease in $T$ — which is calendar arbitrage. The patch is to re-smooth $(a, b, \rho, m, \sigma)$ across tenors with a low-degree spline. The cure is the next section.

SSVI: The Whole Surface in One Piece

SSVI (Surface SVI) covers all maturities with a single parameterization (Gatheral & Jacquier, 2014):

where $k$ is log-moneyness as before, $\theta_T$ is the ATM total variance at tenor $T$ (read directly from the market), $\rho$ is a skew parameter shared across tenors, and $\varphi(\theta)$ is a shape function governing how smile curvature decays with tenor — a power law $\varphi(\theta) = \eta\,\theta^{-\gamma}$ is standard. Structurally, $w(0, \theta_T) = \theta_T$ holds automatically at the money, and the smile’s shape is driven uniformly by $\varphi$.

SSVI’s selling point is that no-arbitrage becomes explicit inequalities on the parameters: $\theta_T$ non-decreasing in $T$ (with mild conditions on $\varphi$) guarantees freedom from calendar arbitrage across tenors, and in the butterfly direction, sufficient conditions are

Carry these as constraints during calibration and the fitted surface comes out clean — that is what “arbitrage-free by construction” concretely means.

SSVI buys whole-surface consistency with one global $\rho$, at the cost of expressiveness in the skew term structure. Production fitting therefore often uses extensions: eSSVI (Hendriks & Martini) lets $\rho$ vary by tenor while preserving inter-slice no-arbitrage, and the broader family of arbitrage-free SVI surfaces is developed in Guo, Jacquier, Martini & Neufcourt (2016).

Implementation Sketch

import numpy as np
from scipy.optimize import minimize

def ssvi_total_var(k, theta, rho, phi):
    """SSVI total variance slice: w(k) = θ/2 · (1 + ρφk + sqrt((φk+ρ)² + 1−ρ²))."""
    return 0.5 * theta * (1 + rho * phi * k
                          + np.sqrt((phi * k + rho)**2 + 1 - rho**2))

def ssvi_calibrate(strikes_by_tau, ivs_by_tau, taus, S0, r, eta=1.0, gamma=0.5):
    """Fit SSVI across tenors: power-law φ(θ) = η·θ^(−γ), refine (θ_T, ρ) per slice."""
    fits = []
    for tau, K_arr, iv_arr in zip(taus, strikes_by_tau, ivs_by_tau):
        F = S0 * np.exp(r * tau)
        k = np.log(K_arr / F)
        w_mkt = iv_arr**2 * tau
        x0 = np.array([np.interp(0.0, k, w_mkt), -0.7])  # init: ATM total var, skew
        bounds = [(1e-4, None), (-0.95, 0.95)]
        res = minimize(
            lambda p: np.mean((ssvi_total_var(k, p[0], p[1],
                               eta * p[0]**(-gamma)) - w_mkt)**2),
            x0, bounds=bounds, method='L-BFGS-B')
        fits.append(res.x)
    return fits

PROMPT

“Write a Python SSVI total-variance function and a per-slice calibration sketch with a power-law phi, using scipy minimize with L-BFGS-B bounds.”

Not award-winning code — it doesn’t carry the no-arbitrage constraints from the previous section, and there’s no bad-fit or outlier handling. Production-grade is 100-200 lines per parametric family, and the difference is all robustness.

The Calibration Pipeline, End to End

At a typical desk the full flow is:

1. Snapshot. Pull the latest quotes at snapshot time; merge calls and puts via put-call parity into a complete grid in $K$ for each $T$.
2. Clean. The three steps above.
3. Choose a model. By asset class: equity indices use (e)SSVI; FX smiles are close to symmetric, so SVI near $\rho = 0$ is common; single names may take a different family.
4. Calibrate. Minimize $\sum_i (\sigma^{\text{mkt}}_i - \sigma^{\text{model}}_i)^2$ weighted by inverse bid-ask (tighter spreads are more trustworthy), initialized from the prior day’s parameters.
5. Verify no-arbitrage. Check butterfly, calendar, and vertical constraints jointly on the fitted surface; on failure, refit with penalty terms (a Lagrangian treatment).
6. Store. Save the parametric surface for downstream consumers (pricing engines, risk systems).
7. Publish. Convert as needed: to a local vol surface via Dupire, to a Heston parameter set, or keep the SVI parameters for direct use.

Total runtime: 5-30 seconds on a modern machine. A small number — but note step 4’s “initialized from the prior day”: that’s both an accelerator and part of the stability machinery discussed next.

Failure Modes: Calibrations Break

A typical calibration team expects 1-5% of daily calibrations to fail. Failing isn’t shameful; failing without a recovery plan is. Three modes recur:

NaN strikes. A particular strike produces NaN or implausible values during fitting — usually a bad quote (vendor error) or a strike so far out the parameterization can’t reach it. Handle it by dropping and refitting, or by adding a smoothness constraint.

Bad initial guess. Parameters diverge into nonsense. Common with Levenberg-Marquardt started from scratch, rare with a warm start from yesterday’s parameters — that’s the warm start earning its keep. When even that fails, fall back to a global optimizer (differential evolution).

Inter-slice wiggles. Every slice looks fine alone, but the joined surface oscillates between tenors — the per-slice parameterization isn’t capturing the smooth cross-tenor structure. The cure is a multi-slice parameterization: SSVI or eSSVI.

The uniform recovery strategy: revert to the last good calibration, log the incident, alert an engineer. Production systems log every calibration with diagnostics; a trader on the risk dashboard can see calibration degrading — the classic symptom being a P&L explain that stops matching the Greeks.

Post-Calibration Diagnostics

Two cheap, sensitive sanity checks worth bolting onto the end of the pipeline.

The butterfly diagnostic plot. For the fitted surface, plot

across all $K_1 < K_2 < K_3$. Non-negative everywhere means no same-maturity butterfly arbitrage; negative anywhere means the fit has manufactured phantom arbitrage.

The calendar check. For each strike, plot total variance $w(T) = \sigma^2 T$ against $T$; it should be non-decreasing. Numerically, verify

across the interpolation grid. A violation is a phantom calendar spread.

Add one parameter-level observation: trace the fitted parameters themselves across tenors. Skew or curvature parameters changing rapidly as a function of $T$ mean the surface isn’t smooth; for the SSVI family, also verify the inter-slice constraint that $\theta_T$ is non-decreasing. The parameter time series is itself diagnostic data — which is why the architecture section below insists on versioning each day’s parameters.

Beyond Traded Strikes: Extrapolation

The market trades a limited strike range — SPX liquidity reaches out to a few tens of percent OTM on the put side and a narrower band on the call side, varying with conditions — while real positions live further out on the wings. Three approaches to extrapolation.

Parametric forms (SVI, SABR, Heston) come with formulas defined at all strikes, so extrapolation is smooth — another dividend of the parametric route. Asymptotic methods lean on theory: Lee’s moment formula says total variance grows at most linearly in the deep wings, $w(k) \sim \beta |k|$ with $\beta \leq 2$, i.e. implied vol grows at most like $\sigma(k) \approx \sqrt{\beta |k| / T}$ — extrapolating super-linearly means implying moments that don’t exist. The crudest option is slice-by-slice linear extrapolation of IV in log-strike: workable, but it eventually collides with the Lee bound; treat it as an emergency measure.

For deep-OTM exotic positions, the extrapolation choice materially moves prices: two extrapolations that both hug the calibrated range can differ by tens of vol basis points out at the 5-delta wing. Don’t file extrapolation under details.

The Surface Moves: Dynamics the Parameterization Doesn’t Cover

A fitted surface is a snapshot, and the market cares how snapshots move. Three layers of dynamics, mostly outside the parameterization:

Skew-of-skew. Skew steepness varies with the vol level — steeper when vol is high, flatter when low. SVI expresses this weakly; SABR somewhat more strongly.

Vol-of-vol. The smile’s steepness is itself stochastic. High vol-of-vol periods coincide with high VIX and stressed markets; smiles flatten quickly after crashes. Most parametric forms miss this layer.

Forward skew dynamics. How a forward-starting smile’s shape evolves as it rolls toward the present is handled explicitly only by term-structure models (multi-factor Bergomi and kin).

For traders these dynamics are not academic — they expose you to second-order moves beyond the first-order Greeks. Example: a 30-day short-vol position carries theta (long), vega (short), and vomma (long). A vol spike triggers vega losses, a sideways tape collects theta, a long stretch of high realized vol collects vomma. The P&L profile is determined by the smile’s shape and how it moves — and the latter is not among the five parameters you fitted.

Production Architecture and Historical Lessons

If you’re building a surface library for production, the structural requirements: a calibration-manager class that holds the current surface, decides when to recalibrate, remembers yesterday’s parameters, and serves lookups; multiple parameterizations side by side (SVI for fitting, SABR for fast lookups, Heston for semi-analytic pricing — chosen at runtime); a daily cycle that calibrates against market data, stores parameters, compares to yesterday, and tracks degradation; a no-fit fallback that returns yesterday’s parameters with a flag rather than nothing; parameter versioning as a time series — invaluable for backtesting and post-mortems; and simple threshold alerts (say, $R^2 < 0.95$ triggers an investigation).

The daily self-check is equally simple: apply yesterday’s calibration to today’s market data and measure the price deviation. Median 5bp with a max of 30bp: the calibration is working. Median 50bp: something broke — probably the data, or a stale prior.

To see why “handle regime changes gracefully” is a hard requirement, history suffices. Before 1987, equity smiles were roughly symmetric — skew estimates from before Black Monday are strikingly flat. After 1987 and again after 2008, steep negative skew became the norm; each crisis reset the baseline skew higher, and smiles became more dynamic. In March 2020, deep-wing SPX implied vols spiked to extreme levels and smiles steepened enough to test calibrators everywhere. Every regime shift invalidates the previous day’s parameters — handle it badly, and you’re fighting today’s quotes with yesterday’s surface.

Where This Lands

The volatility surface is the most important data product in derivatives. Parametric forms (the SVI/SSVI family) currently offer the best balance of fit quality, smoothness, and tractability; the arbitrage conditions are the consistency constraints that make “surface = probability distribution” literally true; and data quality plus operational discipline decide whether any of it still works tomorrow morning. When learning, going deep on one parametric family beats sampling all of them — the structural insight (the surface is a distribution in disguise) outlives whichever form you fit.

The next article covers variance and volatility swaps — the instruments that turn the entire surface into a single tradable product.

Reading list. Hull, Options, Futures, and Other Derivatives, 10th ed., Ch. 18 (2018). Gatheral, The Volatility Surface, Ch. 4-5 (2006). Gatheral & Jacquier, “Arbitrage-free SVI volatility surfaces” (2014). Andreasen & Huge, “Volatility Interpolation” (2010). The Zeliade Systems whitepaper on quasi-explicit SVI calibration and its no-arbitrage conditions.