✦ Free Calculator

Retire on a fixed number, or let your spending flex with the market?

The 4% rule spends the same inflation-adjusted amount every year, market be damned. Guyton-Klinger guardrails let spending move with the portfolio instead. This calculator runs a real 1,000-scenario simulation of both, side by side, against the numbers a reader enters — not a rule of thumb, the actual trade-off. Drop it into your own article in one script tag, and it looks like it was built for your site, not bolted onto it.

Sibling of <retirement-calc-swr> — same engine, different question.

Full explanation: Flexible Spending Guardrails →

See it in context

Here's exactly what that looks like — a live instance embedded inside a sample article, using someone else's fonts and colors, not ours.

drawdownorder.com/blog/should-your-retirement-spending-flex

Withdrawal Strategy · 7 min read

The 4% Rule Isn't Wrong. It's Just Not the Whole Story.

Drawdown Order
Withdrawal strategy & sequencing

Every retiree eventually asks a version of the same question: "Do I really have to spend the exact same amount every year, forever?" The 4% rule says yes — pick a number in year one, adjust it for inflation, and never look at the market again. It's popular because it's simple. Simple isn't the same as optimal.

What the constant rule actually locks in

Bengen's original 4% rule was built to survive the worst historical retirement start years — the ones where the market drops hard right after you stop working. To do that, it has to plan as if every retirement might be that bad one. The cost of that insurance is real: in the years where the market doesn't crash, a retiree following the constant rule is often sitting on far more than they'll ever spend, having quietly underlived their own plan.

The guardrails alternative

Guyton-Klinger guardrails work differently: spending is allowed to rise when the portfolio is comfortably ahead of plan, and required to pull back when it falls behind. Instead of one number picked at retirement and held forever, the withdrawal rate becomes a dial that responds to what's actually happening to the money. The trade-off is variability — some years the guardrails ask for a cut.

The surprising part isn't that guardrails are safer. It's that across most simulated futures, they also let a retiree spend more, on average, than the constant rule — because the constant rule is quietly over-insuring against the worst case every single year, not just the years that turn out bad.

Why this isn't just a "which is safer" question

Success rate alone hides the real decision. A strategy can have a slightly lower success rate and still leave a retiree better off in the years that matter, because it spent more when the market allowed it. The honest comparison has to look at both: how often each strategy survives, and what retirement actually felt like along the way — not just at the finish line.

Try it with your own numbers

Enter a retirement age, a starting portfolio, and a life expectancy on the right, and watch both strategies run against the same 1,000 simulated futures. No signup, and nothing entered leaves the browser.

Try it

That's the exact <retirement-calc-withdrawal> widget, unmodified — same script tag, same math as the full app. See the full picture → · Jump to the embed code ↓

For developers

Everything below is for embedding this calculator on your own site — integration code, theming, and events.

Live demos

Default (single, defaults)

Themed (orange accent, FIRE-leaning household at 4.5% WR)

Preview your theme

Pick colors that match your site, then copy the CSS snippet at the bottom.

Theme colors

Accent color Big number, slider thumb, CTA button

#4f8ec9

Card background Outer surface of the calc

#ffffff

Inner surface Result area + toggle background

#f7f9fc

Text color Title, slider values, result subline

#1a1f2e

retirement-calc-withdrawal {
  --rc-accent: #4f8ec9;
  --rc-bg: #ffffff;
  --rc-surf: #f7f9fc;
  --rc-text: #1a1f2e;
}

Integration code

Drop this into your HTML:

<script src="https://app.retirementscenario.com/embed/v1/withdrawal.js"></script>

<retirement-calc-withdrawal></retirement-calc-withdrawal>

Or pre-seed values relevant to your audience:

<retirement-calc-withdrawal
  plan-type="household"
  retirement-age="50"
  nest-egg="2000000"
  life-expectancy="95"
  initial-wr-pct="4.5">
</retirement-calc-withdrawal>

Attributes

Attribute	Default	Range
`plan-type`	household	`single` or `household`
`retirement-age`	65	45 – 80
`nest-egg`	1000000	100,000 – 10,000,000 (portfolio at retirement)
`life-expectancy`	90	retirementAge + 5 – 105 (defines retirement horizon)
`initial-wr-pct`	4.0	2.5 – 6.0 (% of portfolio withdrawn in year 1)
`refsrc`	(none)	partner attribution tag

Honest scope: Portfolio-only (no Social Security, no pension). The comparison is apples-to-apples with the original Trinity Study + Bengen 4% rule framing. Constant strategy holds spending at initialWRpct × nestEgg / 12 per month (inflation-adjusted). Guyton-Klinger uses ±20% band (engine default) and ±10% spending adjustment when triggered — the FIRE-community canonical GK setup. Both run at 1,000-sim Monte Carlo (same fidelity as the Spend / SWR embeds). Engine assumes 3% inflation; returns 7% nominal pre/post-retirement. For multi-event plans (staggered retirement, lump sums, real estate), use the full app.

Theming

Override CSS custom properties on the host:

retirement-calc-withdrawal {
  --rc-accent: #ff6b35;    /* primary color */
  --rc-bg: #ffffff;        /* card background */
  --rc-surf: #f7f9fc;      /* sub-surface (result area) */
  --rc-text: #1a1f2e;
  --rc-muted: #6a7280;
  --rc-border: rgba(20,30,50,0.10);
  --rc-radius: 12px;
}

Events

The element emits two custom events you can listen to:

document.querySelector('retirement-calc-withdrawal')
  .addEventListener('rc-calculated', (e) => {
    console.log('Constant strategy:', e.detail.constant);   // { successRate, p10End, p50End, p90End, avgRealSpend }
    console.log('GK strategy:', e.detail.gk);              // same + gkPerSimStats { medianCutCount, medianRaiseCount, ... }
    console.log('Monthly starting spend:', e.detail.monthlyStartingSpend);
    console.log('Initial WR:', e.detail.initialWRpct + '%');
  });

document.querySelector('retirement-calc-withdrawal')
  .addEventListener('rc-cta-clicked', (e) => {
    console.log('User clicked CTA to:', e.detail.url);
  });

How it works: the element loads a sibling Web Worker that dispatches the _embedWithdrawalCompare engine wrapper — a single Worker round trip chains 2× (calcRetirement + runMonteCarlo at 1,000 sims) for both strategies. Same engine that powers RetirementScenario.com, locked by automated parity tests on every deploy. The calc forces SS to zero so the comparison is apples-to-apples with Trinity. No data ever leaves the user's browser.