Hedging Strategies with Derivatives

This page illustrates how derivatives can be used to manage financial risk through different hedging strategies. We’ll compare three approaches: no hedging, hedging with forwards/futures (reducing/eliminating risk), and hedging with options (providing insurance).

Important Distinction: Payoffs vs. Profit/Loss

Payoffs refer to the cash flows generated by a derivative contract at expiration, based solely on the difference between the final price and the strike/forward price. They don’t account for the initial cost of establishing the position.

Profit/Loss represents the total economic result after considering all costs, including premiums paid for options or any initial setup costs. This is what you actually gain or lose from the strategy.

In the visualizations below, we show profit/loss which includes the cost of building the strategies (such as option premiums), providing a complete picture of the economic outcome.

See also: the overview of payoffs on the Payoffs page.

Choose a Scenario

Select a scenario to explore different hedging strategies:

viewof scenario = Inputs.radio(
  ["currency", "portfolio"], 
  {
    label: "Risk Scenario:",
    value: "currency",
    format: x => x === "currency" ? "Currency Risk (€ payment)" : "Portfolio Risk (Apple stock)"
  }
)

scenarios = ({
  currency: {
    name: "Currency Risk",
    description: "A U.S. company needs to pay EUR 3 million on November 7th. Current exchange rate: $1.174/EUR",
    position: 3000000,
    currentRate: 1.174,
    forwardRate: 1.179,
    optionStrike: 1.175,
    optionPremium: 0.0108,
    contractSize: 125000,
    numContracts: 24,
    units: "$/EUR",
    assetLabel: "Exchange Rate ($/EUR)",
    xMin: 1.0,
    xMax: 1.4,
    yMin: -1000000,
    yMax: 1000000,
    sliderMin: 1.0,
    sliderMax: 1.4,
    sliderStep: 0.001,
    decimals: 3
  },
  portfolio: {
    name: "Portfolio Risk", 
    description: "You own 5,000 shares of Apple stock at $240/share. You want to hedge against a drop by November 21st.",
    position: 5000,
    currentPrice: 240,
    forwardRate: 240,
    optionStrike: 240,
    optionPremium: 7.59,
    contractSize: 100,
    numContracts: 50,
    units: "$/share",
    assetLabel: "Stock Price ($/share)",
    xMin: 180,
    xMax: 300,
    yMin: -300000,
    yMax: 300000,
    sliderMin: 180,
    sliderMax: 300,
    sliderStep: 1,
    decimals: 0
  }
})

currentScenario = scenarios[scenario]

// USD formatting helper
formatUSD = (value, digits = 0) => new Intl.NumberFormat('en-US', {
  style: 'currency', currency: 'USD', maximumFractionDigits: digits, minimumFractionDigits: digits
}).format(value)

Scenario:

Adjust Market Price at Maturity

Use this slider to see how different market prices at maturity affect each hedging strategy:

viewof maturityPrice = Inputs.range(
  [currentScenario.sliderMin, currentScenario.sliderMax], 
  {
    step: currentScenario.sliderStep, 
    label: `${currentScenario.assetLabel} at Maturity (S0 = ${
      (scenario === "currency" ? currentScenario.currentRate.toFixed(currentScenario.decimals) : currentScenario.currentPrice)
    })`,
    value: scenario === "currency" ? 1.174 : 240
  }
)

Without any hedging, you are fully exposed to market price movements. This strategy has the highest risk but also the highest potential reward.

Note

Currency liability (priced in $/EUR):$$\mathrm{P/L} = -\,(S_T - S_0)\,Q$$

{
  const showCurrency = scenario === "currency";
  document.getElementById("pl-currency-1")?.style.setProperty("display", showCurrency ? "block" : "none");
  document.getElementById("pl-portfolio-1")?.style.setProperty("display", showCurrency ? "none" : "block");
  null
}

noHedgePayoff = {
  if (scenario === "currency") {
    return -(maturityPrice - currentScenario.currentRate) * currentScenario.position
  } else {
    return (maturityPrice - currentScenario.currentPrice) * currentScenario.position
  }
}

noHedgeSeries = d3.range(currentScenario.xMin, currentScenario.xMax, 
  (currentScenario.xMax - currentScenario.xMin) / 100).map(price => ({
    x: price,
    y: scenario === "currency" 
      ? -(price - currentScenario.currentRate) * currentScenario.position
      : (price - currentScenario.currentPrice) * currentScenario.position
}))

Plot.plot({
  caption: "Profit/Loss with No Hedging",
  x: {
    domain: [currentScenario.xMin, currentScenario.xMax],
    label: currentScenario.assetLabel
  },
  y: {
    domain: [currentScenario.yMin, currentScenario.yMax],
    label: "Profit/Loss ($)",
    tickFormat: "~s"
  },
  grid: true,
  pointer: "plot",
  marginLeft: 84,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([currentScenario.currentRate || currentScenario.currentPrice], 
      {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.line(noHedgeSeries, {x: "x", y: "y", stroke: "blue", strokeWidth: 2}),
    Plot.dot(
      [[maturityPrice, noHedgePayoff]], 
      {
        fill: "red", 
        r: 6,
        title: d => `Price: ${maturityPrice.toFixed(currentScenario.decimals)}\n${formatUSD(noHedgePayoff, 0)}`,
        tip: true
      }
    ),
    // Tooltip that follows the pointer over the line
    Plot.tip(Plot.pointerX(noHedgeSeries), {
      x: "x", y: "y",
      title: d => `S: ${d.x.toFixed(currentScenario.decimals)} ${currentScenario.units}\nP/L: ${formatUSD(d.y, 0)}`
    }),
    // Data-bound crosshair anchored to the line
    Plot.crosshair(noHedgeSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "No Hedge - Full Market Exposure"
})

html`<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>S0
    <span class="badge">${(scenario === "currency" 
      ? currentScenario.currentRate.toFixed(currentScenario.decimals) 
      : currentScenario.currentPrice.toFixed(currentScenario.decimals))} ${currentScenario.units}</span>
  </span>
</div>`

html`<div class="profit-loss-table">
<table>
<thead>
<tr><th>Item</th><th>Value</th></tr>
</thead>
<tbody>
<tr><td>Initial Position</td><td>${scenario === "currency" ? "EUR 3,000,000 payment obligation" : "5,000 shares @ $240"}</td></tr>
<tr><td>Market Price at Maturity</td><td>${maturityPrice.toFixed(currentScenario.decimals)} ${currentScenario.units}</td></tr>
<tr><td><strong>Net Profit/Loss</strong></td><td><strong>${formatUSD(noHedgePayoff, 0)}</strong></td></tr>
</tbody>
</table>
</div>`

Forward contracts lock in a price today for a future transaction, eliminating price risk but also upside.

Note

Currency liability hedge (long forward on EUR): \[\mathrm{P/L} = -\,(S_T - S_0)Q + (S_T - F_0)Q = (S_0 - F_0)Q\]

Note: Generally, $F_0 \neq S_0$ due to carry and maturity.

{
  const showCurrency = scenario === "currency";
  document.getElementById("pl-currency-2")?.style.setProperty("display", showCurrency ? "block" : "none");
  document.getElementById("pl-portfolio-2")?.style.setProperty("display", showCurrency ? "none" : "block");
  null
}

forwardHedgeComponents = {
  const underlying = scenario === "currency"
    ? -(maturityPrice - currentScenario.currentRate) * currentScenario.position
    : (maturityPrice - currentScenario.currentPrice) * currentScenario.position
  
  const forward = scenario === "currency"
    ? (maturityPrice - currentScenario.forwardRate) * currentScenario.position
    : -(maturityPrice - currentScenario.forwardRate) * currentScenario.position
  
  return {
    underlying: underlying,
    forward: forward,
    total: underlying + forward
  }
}

forwardCombinedSeries = d3.range(currentScenario.xMin, currentScenario.xMax, 
  (currentScenario.xMax - currentScenario.xMin) / 100).map(price => ({
    x: price,
    y: (() => {
      const underlying = scenario === "currency"
        ? -(price - currentScenario.currentRate) * currentScenario.position
        : (price - currentScenario.currentPrice) * currentScenario.position
      const forward = scenario === "currency"
        ? (price - currentScenario.forwardRate) * currentScenario.position
        : -(price - currentScenario.forwardRate) * currentScenario.position
      return underlying + forward
    })()
}))

Plot.plot({
  caption: "Profit/Loss with Forward Hedge",
  x: {
    domain: [currentScenario.xMin, currentScenario.xMax],
    label: currentScenario.assetLabel
  },
  y: {
    domain: [currentScenario.yMin, currentScenario.yMax],
    label: "Profit/Loss ($)",
    tickFormat: "~s"
  },
  grid: true,
  pointer: "plot",
  marginLeft: 84,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([currentScenario.forwardRate], 
      {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([currentScenario.currentRate || currentScenario.currentPrice], 
      {stroke: "gray", strokeDasharray: "2,2"}),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const underlying = scenario === "currency"
          ? -(price - currentScenario.currentRate) * currentScenario.position
          : (price - currentScenario.currentPrice) * currentScenario.position
        return [price, underlying]
      }),
      {stroke: "blue", strokeWidth: 1.5, strokeDasharray: "3,3", opacity: 0.6}
    ),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const forward = scenario === "currency"
          ? (price - currentScenario.forwardRate) * currentScenario.position
          : -(price - currentScenario.forwardRate) * currentScenario.position
        return [price, forward]
      }),
      {stroke: "orange", strokeWidth: 1.5, strokeDasharray: "3,3", opacity: 0.6}
    ),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const underlying = scenario === "currency"
          ? -(price - currentScenario.currentRate) * currentScenario.position
          : (price - currentScenario.currentPrice) * currentScenario.position
        const forward = scenario === "currency"
          ? (price - currentScenario.forwardRate) * currentScenario.position
          : -(price - currentScenario.forwardRate) * currentScenario.position
        return [price, underlying + forward]
      }),
      {stroke: "green", strokeWidth: 2}
    ),
    Plot.dot(
      [[maturityPrice, forwardHedgeComponents.total]], 
      {
        fill: "red", 
        r: 6,
        title: d => `Price: ${maturityPrice.toFixed(currentScenario.decimals)}\n${formatUSD(forwardHedgeComponents.total, 0)}`,
        tip: true
      }
    ),
    // Tooltip that follows the pointer over the combined line
    Plot.tip(Plot.pointerX(forwardCombinedSeries), {
      x: "x", y: "y",
      title: d => `S: ${d.x.toFixed(currentScenario.decimals)} ${currentScenario.units}\nP/L: ${formatUSD(d.y, 0)}`
    }),
    // Data-bound crosshair anchored to the combined line
    Plot.crosshair(forwardCombinedSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Forward Hedge - Locked-in Price"
})

html`<div class="plot-legend">
  <span><span class="swatch" style="background: blue;"></span>Underlying</span>
  <span><span class="swatch" style="background: orange;"></span>Forward</span>
  <span><span class="swatch" style="background: green;"></span>Combined</span>
</div>
<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>S0
    <span class="badge">${(scenario === "currency" 
      ? currentScenario.currentRate.toFixed(currentScenario.decimals) 
      : currentScenario.currentPrice.toFixed(currentScenario.decimals))} ${currentScenario.units}</span>
  </span>
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>F0
    <span class="badge">${currentScenario.forwardRate.toFixed(currentScenario.decimals)} ${currentScenario.units}</span>
  </span>
</div>`

html`<div class="profit-loss-table">
<table>
<thead>
<tr><th>Item</th><th>Value</th></tr>
</thead>
<tbody>
<tr><td>Initial Position</td><td>${scenario === "currency" ? "EUR 3,000,000 payment obligation" : "5,000 shares @ $240"}</td></tr>
<tr><td>Forward Rate (F0)</td><td>${currentScenario.forwardRate.toFixed(currentScenario.decimals)} ${currentScenario.units}</td></tr>
<tr><td>Contracts</td><td>${currentScenario.numContracts} contracts × ${currentScenario.contractSize.toLocaleString()} ${scenario === "currency" ? "EUR" : "shares"}</td></tr>
<tr><td>Underlying Profit/Loss</td><td>${formatUSD(forwardHedgeComponents.underlying, 0)}</td></tr>
<tr><td>Forward Profit/Loss</td><td>${formatUSD(forwardHedgeComponents.forward, 0)}</td></tr>
<tr><td><strong>Net Profit/Loss</strong></td><td><strong>${formatUSD(forwardHedgeComponents.total, 0)}</strong></td></tr>
</tbody>
</table>
</div>`

Note: The forward hedge creates a perfect offset, resulting in a constant profit/loss of $(S_0 - F_0)Q$, regardless of $S_T$.

{
  const showCurrency = scenario === "currency";
  document.getElementById("pl-note-currency-2")?.style.setProperty("display", showCurrency ? "block" : "none");
  document.getElementById("pl-note-portfolio-2")?.style.setProperty("display", showCurrency ? "none" : "block");
  null
}

Options provide insurance against adverse price movements while allowing you to benefit from favorable ones. You pay a premium for this flexibility.

Note

Currency liability with a call on EUR: $\mathrm{P/L} = -\,(S_T - S_0)Q + \max(0, S_T - X)Q - \text{Premium}$

When exercised ($S_T > X$), the P/L is fixed at: $(S_0 - X)Q - \text{Premium}$

{
  const showCurrency = scenario === "currency";
  document.getElementById("pl-currency-3")?.style.setProperty("display", showCurrency ? "block" : "none");
  document.getElementById("pl-portfolio-3")?.style.setProperty("display", showCurrency ? "none" : "block");
  null
}

optionHedgeComponents = {
  const underlying = scenario === "currency"
    ? -(maturityPrice - currentScenario.currentRate) * currentScenario.position
    : (maturityPrice - currentScenario.currentPrice) * currentScenario.position
  
  const optionPayoff = scenario === "currency"
    ? Math.max(0, maturityPrice - currentScenario.optionStrike) * currentScenario.position
    : Math.max(0, currentScenario.optionStrike - maturityPrice) * currentScenario.position
  
  const premium = currentScenario.optionPremium * currentScenario.position
  
  return {
    underlying: underlying,
    optionPayoff: optionPayoff,
    premium: -premium,
    total: underlying + optionPayoff - premium
  }
}

optionCombinedSeries = d3.range(currentScenario.xMin, currentScenario.xMax, 
  (currentScenario.xMax - currentScenario.xMin) / 100).map(price => ({
    x: price,
    y: (() => {
      const underlying = scenario === "currency"
        ? -(price - currentScenario.currentRate) * currentScenario.position
        : (price - currentScenario.currentPrice) * currentScenario.position
      const optionPayoff = scenario === "currency"
        ? Math.max(0, price - currentScenario.optionStrike) * currentScenario.position
        : Math.max(0, currentScenario.optionStrike - price) * currentScenario.position
      const premium = currentScenario.optionPremium * currentScenario.position
      return underlying + optionPayoff - premium
    })()
}))

Plot.plot({
  caption: scenario === "currency" ? "Profit/Loss with Option Hedge (Call)" : "Profit/Loss with Option Hedge (Put)",
  x: {
    domain: [currentScenario.xMin, currentScenario.xMax],
    label: currentScenario.assetLabel
  },
  y: {
    domain: [currentScenario.yMin, currentScenario.yMax],
    label: "Profit/Loss ($)",
    tickFormat: "~s"
  },
  grid: true,
  pointer: "plot",
  marginLeft: 84,
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([currentScenario.optionStrike], 
      {stroke: "gray", strokeDasharray: "4,4"}),
    Plot.ruleX([currentScenario.currentRate || currentScenario.currentPrice], 
      {stroke: "gray", strokeDasharray: "2,2"}),
    Plot.ruleX([
      (scenario === "currency" 
        ? currentScenario.currentRate - currentScenario.optionPremium 
        : currentScenario.currentPrice + currentScenario.optionPremium)
    ].filter(v => v >= currentScenario.xMin && v <= currentScenario.xMax),
      {stroke: "green", strokeDasharray: "6,2"}
    ),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const underlying = scenario === "currency"
          ? -(price - currentScenario.currentRate) * currentScenario.position
          : (price - currentScenario.currentPrice) * currentScenario.position
        return [price, underlying]
      }),
      {stroke: "blue", strokeWidth: 1.5, strokeDasharray: "3,3", opacity: 0.6}
    ),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const optionPayoff = scenario === "currency"
          ? Math.max(0, price - currentScenario.optionStrike) * currentScenario.position
          : Math.max(0, currentScenario.optionStrike - price) * currentScenario.position
        return [price, optionPayoff]
      }),
      {stroke: "purple", strokeWidth: 1.5, strokeDasharray: "3,3", opacity: 0.6}
    ),
    Plot.line(
      d3.range(currentScenario.xMin, currentScenario.xMax, 
        (currentScenario.xMax - currentScenario.xMin) / 100).map(price => {
        const underlying = scenario === "currency"
          ? -(price - currentScenario.currentRate) * currentScenario.position
          : (price - currentScenario.currentPrice) * currentScenario.position
        const optionPayoff = scenario === "currency"
          ? Math.max(0, price - currentScenario.optionStrike) * currentScenario.position
          : Math.max(0, currentScenario.optionStrike - price) * currentScenario.position
        const premium = currentScenario.optionPremium * currentScenario.position
        return [price, underlying + optionPayoff - premium]
      }),
      {stroke: "green", strokeWidth: 2}
    ),
    Plot.dot(
      [[maturityPrice, optionHedgeComponents.total]], 
      {
        fill: "red", 
        r: 6,
        title: d => `Price: ${maturityPrice.toFixed(currentScenario.decimals)}\n${formatUSD(optionHedgeComponents.total, 0)}`,
        tip: true
      }
    ),
    // Tooltip that follows the pointer over the combined line
    Plot.tip(Plot.pointerX(optionCombinedSeries), {
      x: "x", y: "y",
      title: d => `S: ${d.x.toFixed(currentScenario.decimals)} ${currentScenario.units}\nP/L: ${formatUSD(d.y, 0)}`
    }),
    // Data-bound crosshair anchored to the combined line
    Plot.crosshair(optionCombinedSeries, {x: "x", y: "y", stroke: "#444", opacity: 0.6})
  ],
  title: "Option Hedge - Downside Protection with Upside Potential"
})

html`<div class="plot-legend">
  <span><span class="swatch" style="background: blue;"></span>Underlying</span>
  <span><span class="swatch" style="background: purple;"></span>${scenario === "currency" ? "Call Option" : "Put Option"}</span>
  <span><span class="swatch" style="background: green;"></span>Combined (after premium)</span>
</div>
<div class="plot-legend">
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>S0
    <span class="badge">${(scenario === "currency" 
      ? currentScenario.currentRate.toFixed(currentScenario.decimals) 
      : currentScenario.currentPrice.toFixed(currentScenario.decimals))} ${currentScenario.units}</span>
  </span>
  <span><span class="swatch-line" style="border-top-color: gray; border-top-style: dashed;"></span>Strike (X)
    <span class="badge">${currentScenario.optionStrike.toFixed(currentScenario.decimals)} ${currentScenario.units}</span>
  </span>
  <span><span class="swatch-line" style="border-top-color: green; border-top-style: dashed;"></span>Breakeven
    <span class="badge">${(() => { const be = scenario === "currency" ? (currentScenario.currentRate - currentScenario.optionPremium) : (currentScenario.currentPrice + currentScenario.optionPremium); return be.toFixed(currentScenario.decimals) + ' ' + currentScenario.units })()}</span>
  </span>
</div>`

html`<div class="profit-loss-table">
<table>
<thead>
<tr><th>Item</th><th>Value</th></tr>
</thead>
<tbody>
<tr><td>Initial Position</td><td>${scenario === "currency" ? "EUR 3,000,000 payment obligation" : "5,000 shares @ $240"}</td></tr>
<tr><td>${scenario === "currency" ? "Call" : "Put"} Strike Price</td><td>${currentScenario.optionStrike.toFixed(currentScenario.decimals)} ${currentScenario.units}</td></tr>
<tr><td>Option Premium</td><td>$${currentScenario.optionPremium.toFixed(4)} per ${scenario === "currency" ? "EUR" : "share"}</td></tr>
<tr><td>Total Premium Paid</td><td>${formatUSD(currentScenario.optionPremium * currentScenario.position, 0)}</td></tr>
<tr><td>Contracts</td><td>${currentScenario.numContracts} contracts × ${currentScenario.contractSize.toLocaleString()} ${scenario === "currency" ? "EUR" : "shares"}</td></tr>
<tr><td>Underlying Profit/Loss</td><td>${formatUSD(optionHedgeComponents.underlying, 0)}</td></tr>
<tr><td>Option Payoff</td><td>${formatUSD(optionHedgeComponents.optionPayoff, 0)}</td></tr>
<tr><td><strong>Net Profit/Loss (after premium)</strong></td><td><strong>${formatUSD(optionHedgeComponents.total, 0)}</strong></td></tr>
<tr><td><strong>Strategy Breakeven Price</strong> <sup>(i)</sup></td><td>${(() => { const be = scenario === "currency" ? (currentScenario.currentRate - currentScenario.optionPremium) : (currentScenario.currentPrice + currentScenario.optionPremium); return (be >= currentScenario.xMin && be <= currentScenario.xMax) ? be.toFixed(currentScenario.decimals) + ' ' + currentScenario.units : 'N/A' })()}</td></tr>
</tbody>
<tfoot>
  <tr><td colspan="2" style="font-size: 0.8em; text-align: left;"><sup>(i)</sup> Price where the total P/L for the strategy (Underlying + Option) is zero.</td></tr>
</tfoot>
</table>
</div>`

Comparing Hedging Strategies

Key Differences

Strategy	Risk Elimination	Upside Potential	Cost	Best Used When
No Hedge	None	Full	None	You have a strong view on favorable price movements
Forward Hedge	Complete	None	None*	You need certainty and want to eliminate all price risk
Option Hedge	Downside only	Preserved	Premium	You want protection but also want to benefit from favorable moves

*Forward contracts typically have no upfront cost but may require margin.

Important Notes

Maturity Matching: In these examples, we assume the derivatives’ maturity dates perfectly match when the underlying exposure occurs (November 7th for currency, November 21st for portfolio). In practice, perfect matching may not always be possible.
Contract Specifications: Real derivatives trade in standard contract sizes. Our examples use:
- Currency futures: 125,000 EUR per contract
- Stock options: 100 shares per contract
Transaction Costs: These illustrations focus on profit/loss calculations and don’t include transaction costs, bid-ask spreads, or margin requirements.
Basis Risk: When using futures instead of forwards, there may be basis risk if the futures contract doesn’t perfectly match your exposure.
Credit Risk: Forward contracts involve counterparty credit risk, while exchange-traded futures and options have clearinghouse guarantees.

The choice of hedging strategy depends on your risk tolerance, market view, cost considerations, and regulatory or accounting requirements. Options provide the most flexibility but at a cost, while forwards provide certainty at the expense of upside potential.