Introduction

Every investor faces the same trade-off: higher potential reward comes with higher risk. But how much extra return should you demand for taking on extra risk? The Capital Asset Pricing Model (CAPM) answers that question with a single equation and a single number.

The key number is beta (β\beta). It measures how sensitive an asset's returns are to the overall market. A stock with β=1\beta = 1 moves in lockstep with the market index. A stock with β=2\beta = 2 swings twice as hard — both up and down. A stock with β=0\beta = 0 is uncorrelated with market moves altogether.

CAPM then says: the fair expected return of any asset is exactly determined by its beta. Plot every asset with beta on the horizontal axis and expected return on the vertical, and they should all lie on one straight line — the Security Market Line (SML). Drift above the line and the market will bid the price up until you fall back; drift below it and rational investors will sell.

The model was developed independently by William Sharpe (1964) and John Lintner (1965), building on Harry Markowitz's portfolio theory. Sharpe received the Nobel Prize in Economics in 1990.

Try It: The Security Market Line

The chart below shows the Security Market Line and a set of sample assets. Each asset's position is determined by its beta (β\beta, horizontal axis) and its expected return (vertical axis).

<!-- CAPM Security Market Line chart: canvas + sliders for rf and market risk premium -->
<div class="controls">
  <label>Risk-free rate (rₐ) <span id="rfVal">2%</span>
    <input type="range" id="rf" min="0" max="8" step="0.5" value="2">
  </label>
  <label>Market risk premium (rₘ − rₐ) <span id="mrpVal">6%</span>
    <input type="range" id="mrp" min="2" max="12" step="0.5" value="6">
  </label>
</div>
<canvas id="sml" width="560" height="340"></canvas>
<div id="legend" class="legend"></div>
<div id="info" class="info"></div>

/* Layout: controls above canvas, legend below */
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; color: #222; background: #fff; }
.controls { display: flex; flex-wrap: wrap; gap: .7rem 1.4rem; margin-bottom: .8rem; }
label { font-size: .85rem; color: #444; display: flex; flex-direction: column; gap: .15rem; }
label span { font-weight: 700; color: #1d3557; }
input[type=range] { width: 140px; accent-color: #1d3557; }
canvas { border: 1px solid #dde3ea; border-radius: 8px; max-width: 100%; display: block; }
.legend { display: flex; flex-wrap: wrap; gap: .4rem .8rem; margin-top: .5rem; font-size: .8rem; }
.dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; margin-right: 4px; }
.info { min-height: 1.2em; font-size: .82rem; color: #555; margin-top: .35rem; font-style: italic; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* Sample assets: beta values span 0 to 1.9; two 'special' assets sit off the SML (alpha != 0) */
const ASSETS = [
  { name: 'T-Bill',  beta: 0.00, color: '#2a9d8f' },
  { name: 'Utility',   beta: 0.45, color: '#457b9d' },
  { name: 'Consumer',   beta: 0.80, color: '#1d3557' },
  { name: 'Market',    beta: 1.00, color: '#6c757d' },
  { name: 'Tech',   beta: 1.40, color: '#e9c46a' },
  { name: 'Biotech',beta: 1.90, color: '#e76f51' },
  { name: 'Above SML',  beta: 1.10, color: '#0a7d33', special: 'above' },
  { name: 'Below SML',  beta: 0.70, color: '#c92f3c', special: 'below' }
];

const canvas = document.getElementById('sml');
const ctx = canvas.getContext('2d');
const rfSlider  = document.getElementById('rf');
const mrpSlider = document.getElementById('mrp');
const rfVal  = document.getElementById('rfVal');
const mrpVal = document.getElementById('mrpVal');
const legend = document.getElementById('legend');
const info   = document.getElementById('info');

/* chart drawing dimensions with padding for axes */
const PAD = { left: 54, right: 20, top: 20, bottom: 44 };
const W = canvas.width, H = canvas.height;
const CW = W - PAD.left - PAD.right;
const CH = H - PAD.top  - PAD.bottom;

/* helpers to map beta and return% to canvas pixels */
function toX(beta)   { return PAD.left + (beta / 2.5) * CW; }
function toY(ret)    { return PAD.top  + CH - (ret / 22) * CH; }
function capm(rf, mrp, beta) { return rf + beta * mrp; }

function draw() {
  const rf  = parseFloat(rfSlider.value);
  const mrp = parseFloat(mrpSlider.value);
  rfVal.textContent  = rf  + '%';
  mrpVal.textContent = mrp + '%';

  ctx.clearRect(0, 0, W, H);

  /* light grid lines */
  ctx.strokeStyle = '#e8eef3';
  ctx.lineWidth = 1;
  for (let b = 0; b <= 2.5; b += 0.5) {
    ctx.beginPath(); ctx.moveTo(toX(b), PAD.top); ctx.lineTo(toX(b), PAD.top + CH); ctx.stroke();
  }
  for (let r = 0; r <= 20; r += 4) {
    ctx.beginPath(); ctx.moveTo(PAD.left, toY(r)); ctx.lineTo(PAD.left + CW, toY(r)); ctx.stroke();
  }

  /* x and y axes */
  ctx.strokeStyle = '#adb5bd';
  ctx.lineWidth = 1.4;
  ctx.beginPath(); ctx.moveTo(PAD.left, PAD.top); ctx.lineTo(PAD.left, PAD.top + CH); ctx.stroke();
  ctx.beginPath(); ctx.moveTo(PAD.left, PAD.top + CH); ctx.lineTo(PAD.left + CW, PAD.top + CH); ctx.stroke();

  /* numeric tick labels */
  ctx.fillStyle = '#555';
  ctx.font = '11px system-ui, sans-serif';
  ctx.textAlign = 'center';
  for (let b = 0; b <= 2.5; b += 0.5) {
    ctx.fillText(b.toFixed(1), toX(b), PAD.top + CH + 16);
  }
  ctx.textAlign = 'right';
  for (let r = 0; r <= 20; r += 4) {
    ctx.fillText(r + '%', PAD.left - 6, toY(r) + 4);
  }
  ctx.save();
  ctx.translate(14, PAD.top + CH / 2);
  ctx.rotate(-Math.PI / 2);
  ctx.textAlign = 'center';
  ctx.fillText('Expected return (%)', 0, 0);
  ctx.restore();
  ctx.textAlign = 'center';
  ctx.fillText('Beta (β)', PAD.left + CW / 2, H - 4);

  /* draw the Security Market Line */
  ctx.strokeStyle = '#1d3557';
  ctx.lineWidth = 2.2;
  ctx.setLineDash([]);
  ctx.beginPath();
  ctx.moveTo(toX(0),   toY(capm(rf, mrp, 0)));
  ctx.lineTo(toX(2.5), toY(capm(rf, mrp, 2.5)));
  ctx.stroke();

  /* label the SML line */
  ctx.fillStyle = '#1d3557';
  ctx.font = 'bold 11px system-ui, sans-serif';
  ctx.textAlign = 'left';
  ctx.fillText('SML', toX(2.1), toY(capm(rf, mrp, 2.1)) - 8);

  /* draw each asset dot, with optional alpha dashed line */
  ASSETS.forEach(a => {
    const smlReturn = capm(rf, mrp, a.beta);
    /* expected return on SML at this beta */
    const dispReturn = a.special ? smlReturn + (a.special === 'above' ? 2.5 : -2.5) : smlReturn;
    const x = toX(a.beta);
    const y = toY(dispReturn);

    /* dashed vertical line shows alpha (distance above/below SML) */
    if (a.special) {
      ctx.strokeStyle = a.color;
      ctx.lineWidth = 1.2;
      ctx.setLineDash([4, 3]);
      ctx.beginPath(); ctx.moveTo(x, y); ctx.lineTo(x, toY(smlReturn)); ctx.stroke();
      ctx.setLineDash([]);
    }

    /* filled circle for the asset */
    ctx.beginPath();
    ctx.arc(x, y, 7, 0, Math.PI * 2);
    ctx.fillStyle = a.color;
    ctx.fill();
    ctx.strokeStyle = '#fff';
    ctx.lineWidth = 1.5;
    ctx.stroke();
  });

  /* build the color legend below the chart */
  legend.innerHTML = ASSETS.map(a => {
    let note = '';
    if (a.special === 'above') note = ' (' + 'positive α' + ')';
    if (a.special === 'below') note = ' (' + 'negative α' + ')';
    return '<span><span class="dot" style="background:' + a.color + '"></span>' + a.name + note + '</span>';
  }).join('');

  /* show the SML equation in the info bar */
  const rm = rf + mrp;
  info.textContent = i18nFmt('SML: E(r) = %rf%% + β × %mrp%% — market return rₘ = %rm%%', { rf: rf.toFixed(1), mrp: mrp.toFixed(1), rm: rm.toFixed(1) });
}

rfSlider.addEventListener('input',  draw);
mrpSlider.addEventListener('input', draw);

/* on hover show the asset name, beta, expected return and alpha */
canvas.addEventListener('mousemove', function(e) {
  const rect = canvas.getBoundingClientRect();
  const mx = (e.clientX - rect.left) * (W / rect.width);
  const my = (e.clientY - rect.top)  * (H / rect.height);
  const rf  = parseFloat(rfSlider.value);
  const mrp = parseFloat(mrpSlider.value);
  let hit = null;
  ASSETS.forEach(a => {
    const smlReturn = capm(rf, mrp, a.beta);
    const dispReturn = a.special ? smlReturn + (a.special === 'above' ? 2.5 : -2.5) : smlReturn;
    const dx = mx - toX(a.beta), dy = my - toY(dispReturn);
    if (Math.sqrt(dx*dx + dy*dy) < 10) hit = { asset: a, dispReturn, smlReturn };
  });
  if (hit) {
    const alpha = (hit.dispReturn - hit.smlReturn).toFixed(1);
    const alphaStr = alpha > 0 ? '+' + alpha : alpha;
    info.textContent = i18nFmt('%name% — β = %beta%, E(r) = %ret%%, α = %alpha%%', {
      name:   hit.asset.name,
      beta:   hit.asset.beta.toFixed(2),
      ret:    hit.dispReturn.toFixed(1),
      alpha:  alphaStr
    });
  }
});
canvas.addEventListener('mouseleave', function() {
  const rf  = parseFloat(rfSlider.value);
  const mrp = parseFloat(mrpSlider.value);
  const rm  = rf + mrp;
  info.textContent = i18nFmt('SML: E(r) = %rf%% + β × %mrp%% — market return rₘ = %rm%%', { rf: rf.toFixed(1), mrp: mrp.toFixed(1), rm: rm.toFixed(1) });
});

draw();
Result
Console

Use the sliders to change the risk-free rate rfr_f and the market risk premium (rm−rf)(r_m - r_f). Watch how the entire line rotates — because beta is the only factor that separates one asset from another under CAPM. Assets sitting on the line are fairly priced; assets above it offer a positive alpha (excess return beyond what their risk justifies); assets below it are overpriced relative to their risk.

The Real Complexity

CAPM's elegance comes from strong assumptions. Relaxing any of them complicates the picture:

  • Homogeneous expectations: every investor holds the same beliefs about future returns and correlations. In practice, information is private and opinions differ wildly.
  • Frictionless markets: no taxes, no transaction costs, unlimited short-selling. Real portfolios pay taxes, face bid-ask spreads, and hit borrowing limits.
  • Single-period horizon: investors optimize over one identical time period. Real investors have different horizons, liquidity needs, and liability structures.
  • The market portfolio is observable: CAPM requires the true market portfolio of all risky assets — stocks, bonds, real estate, human capital. The S&P 500 is a rough proxy.

Empirically, the SML is flatter than predicted: low-beta stocks earn higher returns than CAPM says they should, and high-beta stocks earn less. Eugene Fama and Kenneth French (1992) showed that size and book-to-market ratios explain return differences far better than beta alone, spawning the Fama-French three-factor model and its descendants.

Yet CAPM remains the baseline. Its core insight — that only systematic risk (co-movement with the market) earns a premium, because idiosyncratic risk can be diversified away — survives every extension. Understanding CAPM is the entry point to all of modern asset pricing, from the Black-Scholes model to multi-factor models and beyond.

Where It Matters

Despite its imperfections, CAPM shapes how the financial world operates every day:

  • Cost of equity: companies use CAPM to estimate what return equity holders require. This feeds directly into the Weighted Average Cost of Capital (WACC) used to discount future cash flows in corporate valuation.
  • Capital budgeting: a project's hurdle rate is often set by its beta relative to the firm's existing assets — high-beta projects need a higher bar.
  • Portfolio performance: "alpha" — the vertical distance from the SML — is the standard measure of whether a fund manager added value beyond what the market risk alone would have produced.
  • Regulatory finance: utilities and regulated industries use CAPM to argue before regulators for an allowed rate of return on their equity.
  • Index funds and factor investing: the realization that alpha is scarce led directly to passive index investing, which now holds the majority of US equity assets.

Beta and CAPM also connect naturally to ideas from other fields: the security market line is a linear model, and fitting it from historical data is an instance of regression — the same mathematical tool that underlies linear regression everywhere in data science.

Conclusion

CAPM achieves something remarkable: it collapses the messy question of "how much return should I demand?" into a single number — beta — and a single line. Once you know how much a stock co-moves with the market, the model tells you its fair expected return. Everything else is alpha, and alpha is hard to find.

The model's assumptions are heroically simplified, and the data show the real SML is flatter than predicted. But the underlying logic — that only undiversifiable risk deserves compensation — is a lasting insight. Every refinement, from Fama-French to the APT, is an argument about which additional risks also deserve a premium, not a refutation of the core idea.

So the next time you see a stock's beta quoted alongside its price, remember: that number is doing something profound. It is placing the asset on a line that stretches from the safety of government bonds to the volatility of speculative growth — a line drawn by a simple model with deep mathematical roots.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/capm-beta/Content licensed under CC BY-NC 4.0.