That one number decides whether bonds cushion a stock crash or fall right alongside it. Below are the 405 months of data, the inflation pattern behind the flips, what it did to a 60/40 portfolio’s volatility, and a short Python script that rebuilds every number.

If you’re putting this kind of research into a guide for readers or clients, ImagineYourBook is an AI book-writing tool that turns your notes or a prompt into a full text draft with Word and EPUB export. It’s a quick way to turn a finance analysis like this one into an ebook or lead magnet.

The answer in one chart

Correlation runs from −1 (bonds always move opposite to stocks) to +1 (always together). Over the whole 1993–2026 sample, the monthly correlation between SPY and long Treasuries is just −0.05, which sounds like “no relationship.” That average hides three very different regimes:

Out of 370 rolling 36-month windows since January 1996, 69% had a negative correlation. That’s why a whole generation of investors learned that “bonds go up when stocks go down.” The other 31% are concentrated at the two ends of the sample, and we’re living in one of them.

Total-bond funds tell the same story. VBMFX, Vanguard’s Total Bond Market Index fund, shows a 36-month correlation with SPY of +0.44 today, nearly the same as long Treasuries.

What actually happened in losing years

A correlation coefficient is abstract. Calendar-year returns aren’t. Here is every year since 1994 in which SPY lost money, next to what long Treasuries did the same year:

In the four big stock losses of the negative-correlation era (2000, 2001, 2002, 2008), long Treasuries gained between 4.4% and 22.6%. In 2008, SPY lost 36.8% while VUSTX gained 22.6%. That’s the hedge working exactly as advertised.

Then 2022 happened. SPY fell 18.2% and VUSTX fell 29.6%. Bonds lost more than stocks. Only one other year in the sample, 2018, saw both down, and that was a mild −4.6% and −1.9%.

The monthly data show the same shift. From 2000 to 2021, only 11% of months had both stocks and bonds negative. From January 2022 to October 2026 it was 31%, almost one month in three.

Why it flips: inflation

The dashed line is the 36-month average of CPI inflation from FRED. When inflation was low and stable, the correlation sat below zero. When inflation surged in 2021–2023, the correlation jumped. Across all windows, the correlation between the two lines is +0.60.

Grouping the windows by their average inflation makes the pattern blunt:

• Average CPI under 2.5%: mean stock-bond correlation −0.27 (208 windows)
• CPI 2.5% to 4%: +0.04 (126 windows)
• CPI 4% and up: +0.52 (35 windows)

This matches the research. AQR’s analysis finds that growth news pushes stocks and bonds in opposite directions while inflation news pushes them the same way, and that a simple growth-versus-inflation model explains about 70% of the long-term variation in the US stock-bond correlation. AQR also points out that the correlation was more often positive than negative from 1900 to 2000, so the 2000–2021 era, not today, is the historical outlier (AQR perspective).

Where are we now? CPI inflation was 3.7% year over year in September 2026, and the 36-month average is 3.0%. That’s the middle bucket, where history says the correlation is a coin flip. The current +0.42 is still higher than that bucket’s average, so bonds haven’t won back their hedge yet.

A data note: FRED’s CPIAUCSL series has no value for October 2025, so the 36-month averages simply skip that month.

What it costs a 60/40 portfolio

The point of holding 40% bonds is to make the ride smoother. Here’s the annualized volatility of monthly returns for stocks alone and for a 60/40 mix (60% SPY, 40% VUSTX, rebalanced monthly):

From 2000 to 2021, the 60/40 portfolio had 8.8% volatility against 15.0% for stocks alone. It removed about 41% of the swings while keeping 60% of the stock exposure. Since 2022, the same mix has run at 13.3% against 15.6% for stocks. It removed only about 15%.

How much of that is the correlation flip and how much is just jumpier bonds (14.0% volatility since 2022, up from 10.9%)? Plug the 2022–2026 volatilities into the 60/40 formula but keep the old −0.29 correlation, and you get 9.4%. So of the 4.5-point rise in 60/40 volatility, about 3.9 points come from the correlation turning positive. The bonds themselves got riskier, but losing the hedge did most of the damage.

If you want to see how this plays out in drawdowns, our 60/40 portfolio max drawdown post has the peak-to-trough numbers, and how often to rebalance covers the rebalancing side. And if you’re retiring into a positive-correlation regime, the sequence of returns risk example shows why the first few years matter most.

The Python script

The script below downloads nothing by itself. Fetch daily adjusted closes once with yfinance (for example yf.download("SPY", start="1990-01-01", auto_adjust=True).to_pickle("src/SPY.pkl"), and the same for VUSTX and VBMFX), and save FRED’s CPIAUCSL CSV to src/. Then run it:

"""Stock bond correlation over time: SPY vs long-term Treasuries (VUSTX), monthly total returns.
Data: Yahoo Finance adjusted closes via yfinance (dividends reinvested), Feb 1993 - Oct 2026."""
import pandas as pd

def monthly(t, pkl="src/{}.pkl"):
    px = pd.read_pickle(pkl.format(t))["Close"].squeeze()
    return px.resample("ME").last().pct_change().dropna()

def data():
    df = pd.concat({"stocks": monthly("SPY"), "bonds": monthly("VUSTX"), "total": monthly("VBMFX")}, axis=1, sort=True).dropna()
    return df.loc["1993-02":"2026-10"]

def rolling_corr(df, n=36, b="bonds"):
    return df["stocks"].rolling(n).corr(df[b]).dropna()

def cpi_yoy(csv="src/CPIAUCSL.csv"):
    c = pd.read_csv(csv, index_col=0, parse_dates=True).squeeze()
    c.index = c.index + pd.offsets.MonthEnd(0)
    return c.pct_change(12).dropna()

def vol_6040(vs, vb, rho, w=0.6):
    return (w*w*vs*vs + (1-w)**2*vb*vb + 2*w*(1-w)*rho*vs*vb) ** 0.5

def regime_stats(df, start, end, w=0.6):
    d = df.loc[start:end]; p = w * d["stocks"] + (1 - w) * d["bonds"]
    vol = lambda s: s.std() * 12 ** 0.5
    return dict(corr=d["stocks"].corr(d["bonds"]), corr_agg=d["stocks"].corr(d["total"]), vol_s=vol(d["stocks"]), vol_b=vol(d["bonds"]), vol_p=vol(p),
                months=len(d), both_down=((d["stocks"] < 0) & (d["bonds"] < 0)).mean())

if __name__ == "__main__":
    df = data(); rc = rolling_corr(df); ra = rolling_corr(df, b="total")
    print(f"months {len(df)}: {df.index[0]:%Y-%m} to {df.index[-1]:%Y-%m}")
    print(f"full-period corr stocks/long Treasuries {df.stocks.corr(df.bonds):+.2f}, stocks/total bond {df.stocks.corr(df.total):+.2f}")
    print(f"36m rolling: latest {rc.iloc[-1]:+.2f} ({rc.index[-1]:%Y-%m}); min {rc.min():+.2f} ({rc.idxmin():%Y-%m}); max {rc.max():+.2f} ({rc.idxmax():%Y-%m})")
    print(f"share of 36m windows below zero: {(rc < 0).mean():.0%}; latest total-bond 36m {ra.iloc[-1]:+.2f}")
    for a, b in (("1993-02", "1999-12"), ("2000-01", "2021-12"), ("2022-01", "2026-10")):
        s = regime_stats(df, a, b)
        print(f"{a}..{b}: corr {s['corr']:+.2f} (agg {s['corr_agg']:+.2f}), vol stocks {s['vol_s']:.1%} bonds {s['vol_b']:.1%} 60/40 {s['vol_p']:.1%}, both-down months {s['both_down']:.0%}")
    y = (1 + df).groupby(df.index.year).prod() - 1; y = y.loc[1994:2025]
    both = y[(y.stocks < 0) & (y.bonds < 0)]
    print("calendar years both down (1994-2025):", ", ".join(f"{i}: stocks {r.stocks:+.1%} bonds {r.bonds:+.1%}" for i, r in both.iterrows()))
    neg = y[y.stocks < 0]
    print("stock down years:", ", ".join(f"{i}: {r.stocks:+.1%}/{r.bonds:+.1%}" for i, r in neg.iterrows()))
    s22 = regime_stats(df, "2022-01", "2026-10"); s00 = regime_stats(df, "2000-01", "2021-12")
    print(f"2022-26 60/40 vol if corr had stayed {s00['corr']:+.2f}: {vol_6040(s22['vol_s'], s22['vol_b'], s00['corr']):.1%} (actual {s22['vol_p']:.1%})")
    inf = cpi_yoy().reindex(rc.index); inf36 = cpi_yoy().resample("ME").last().rolling(36, min_periods=33).mean().reindex(rc.index)
    print(f"corr of 36m stock-bond correlation with 36m avg CPI inflation: {rc.corr(inf36):+.2f}")
    for lo, hi in ((0, 0.025), (0.025, 0.04), (0.04, 0.2)):
        m = (inf36 >= lo) & (inf36 < hi); print(f"  avg CPI {lo:.1%}-{hi:.1%}: {m.sum()} windows, mean corr {rc[m].mean():+.2f}")
    print(f"latest CPI YoY {cpi_yoy().iloc[-1]:.1%} ({cpi_yoy().index[-1]:%Y-%m}), latest 36m avg {inf36.dropna().iloc[-1]:.1%} ({inf36.dropna().index[-1]:%Y-%m})")
    for d in ("2008-12", "2013-01", "2019-12", "2021-12", "2024-12"):
        print(f"  36m corr at {d}: {rc.loc[d].iloc[0]:+.2f}")

Output (data through October 2026):

months 405: 1993-02 to 2026-10
full-period corr stocks/long Treasuries -0.05, stocks/total bond +0.16
36m rolling: latest +0.42 (2026-10); min -0.78 (2013-01); max +0.68 (2024-12)
share of 36m windows below zero: 69%; latest total-bond 36m +0.44
1993-02..1999-12: corr +0.25 (agg +0.32), vol stocks 12.8% bonds 7.9% 60/40 9.0%, both-down months 17%
2000-01..2021-12: corr -0.29 (agg -0.07), vol stocks 15.0% bonds 10.9% 60/40 8.8%, both-down months 11%
2022-01..2026-10: corr +0.56 (agg +0.61), vol stocks 15.6% bonds 14.0% 60/40 13.3%, both-down months 31%
calendar years both down (1994-2025): 2018: stocks -4.6% bonds -1.9%, 2022: stocks -18.2% bonds -29.6%
stock down years: 2000: -9.7%/+19.8%, 2001: -11.8%/+4.4%, 2002: -21.6%/+16.7%, 2008: -36.8%/+22.6%, 2018: -4.6%/-1.9%, 2022: -18.2%/-29.6%
2022-26 60/40 vol if corr had stayed -0.29: 9.4% (actual 13.3%)
corr of 36m stock-bond correlation with 36m avg CPI inflation: +0.60
  avg CPI 0.0%-2.5%: 208 windows, mean corr -0.27
  avg CPI 2.5%-4.0%: 126 windows, mean corr +0.04
  avg CPI 4.0%-20.0%: 35 windows, mean corr +0.52
latest CPI YoY 3.7% (2026-09), latest 36m avg 3.0% (2026-09)
  36m corr at 2008-12: -0.14
  36m corr at 2013-01: -0.78
  36m corr at 2019-12: -0.34
  36m corr at 2021-12: -0.32
  36m corr at 2024-12: +0.68

A few choices worth knowing about. Monthly returns smooth out daily noise. Thirty-six months is a common window, and a 12-month window swings much harder, while AQR uses 10-year windows in its research. Adjusted closes include dividends and bond interest, so these are total returns. And VUSTX is a long-duration fund, so it reacts more to rate moves than a short-term bond fund would.

To track your own mix of stock and bond ETFs against the S&P 500 without handing your data to anyone, PortfolioTracker24 is a free tracker that runs in your browser, with no account, no broker connection, and Excel backups.

What to do with this

1. Check the regime before trusting the hedge. Re-run the script every few months. A 36-month correlation above zero means your bonds are not a crash hedge right now.
2. Watch inflation, not the headlines. The windows with average CPI under 2.5% averaged a −0.27 correlation. Inflation stabilizing below that level is the clearest historical sign that the old hedge returns.
3. Don’t assume more stocks is the fix. AQR argues that a positive correlation is a bad reason to take more equity risk, because you’re adding exposure to the same shocks that already hit both assets.
4. Hold cash for spending needs. In 2022 both legs fell together. A cash or short-term bucket for near-term withdrawals doesn’t depend on any correlation.

FAQ

What is the stock bond correlation right now?

Using monthly SPY and long-term Treasury (VUSTX) returns, the 36-month correlation is +0.42 as of October 2026. It peaked at +0.68 in December 2024 and has been positive since 2022.

Has the stock bond correlation always been negative?

No. It was +0.25 from 1993 to 1999 and −0.29 from 2000 to 2021. AQR notes it was more often positive than negative from 1900 to 2000, so the negative era was the exception.

Why did stocks and bonds fall together in 2022?

Inflation. Rising inflation and interest rates hurt both. SPY lost 18.2% and long Treasuries lost 29.6%. Windows with average CPI of 4% or more had a mean correlation of +0.52.

Do bonds still diversify a stock portfolio?

Less than before. A 60/40 mix had 8.8% volatility versus 15.0% for stocks in 2000–2021, but 13.3% versus 15.6% since 2022. About 3.9 points of that rise came from the correlation turning positive.

How do I calculate stock bond correlation in Python?

Resample daily adjusted closes to month-end, take pct_change() for monthly returns, then use stocks.rolling(36).corr(bonds) in pandas. The script in this article does that for SPY and VUSTX.

The takeaway

Stock bond correlation over time isn’t a constant you can set and forget. It was +0.25 in the 1990s, −0.29 from 2000 to 2021, and +0.56 since 2022, and it tracks inflation closely. Today’s +0.42 means a 60/40 portfolio is behaving more like 85% of a stock portfolio than the 59% many investors got used to. The script above lets you check where the regime stands in seconds.

If you’ve built up investing knowledge like this and want to share it as a guide, course companion, or newsletter lead magnet, ImagineYourBook can turn your notes into a full book draft. Plans start with a 7-day free trial, and the Author plan is $24.99 a month after that.

Sources (checked November 10, 2026): Yahoo Finance: SPY history · Yahoo Finance: VUSTX history · Yahoo Finance: VBMFX history · yfinance on GitHub · FRED: CPIAUCSL consumer price index · AQR: A Changing Stock-Bond Correlation · AQR: A positive stock-bond correlation is a terrible reason to add equity risk · ImagineYourBook pricing and trial terms. Script: sbcorr.py (shown above). Past correlations don’t predict future ones. Not investment advice.

Same average. Same compound return (7.61% a year). Same $1,342,287 withdrawn. A $3.65 million difference that comes only from the order of the years.

That’s sequence of returns risk: when money is flowing out, losses that hit early do far more damage than the same losses late. Below you’ll see the data, three charts, an animation, a test across 13 different retirement start years, one cheap fix, and the short Python script that produced every number.

If you build tools or write about money, this kind of worked example is also great raw material for a guide. ImagineYourBook is an AI book-writing tool that turns your notes into a complete, editable draft (a 10,000-word book on the free trial) with Word and EPUB export, useful if you want to turn your retirement-planning knowledge into a client guide or lead-magnet ebook.

The setup: one data set, two orders

The data is SPY’s adjusted close from Yahoo Finance (dividends reinvested), turned into calendar-year returns, plus December-to-December CPI inflation from FRED. The assumptions are deliberately simple, and they’re assumptions, not advice:

• $1,000,000 starting balance, 100% in SPY.
• 4% rule: withdraw $40,000 at the start of year one, then raise the withdrawal by last year’s CPI inflation every year.
• No fees, no taxes, no rebalancing.

The forward retiree retires in January 2000. Their first three years are −9.7%, −11.8% and −21.6%, the dot-com bust. The reversed retiree gets 2024 first, so their first three years are +24.9%, +26.2% and −18.2%.

Without withdrawals, the order doesn’t matter at all. $1,000,000 grows to exactly $6,260,930 either way, because multiplication doesn’t care about order. The withdrawals are what break the symmetry.

The result: $119,235 vs $3,773,727

After just three years, the forward retiree is down to $537,830 while the reversed retiree has $1,160,626. From there, the forward retiree is pulling a rising, inflation-adjusted check (the 25th withdrawal is $72,709) out of a balance that never gets back to $1 million. The reversed retiree’s portfolio peaks above $6.2 million before the bad years finally show up, and by then there’s plenty of cushion to absorb them.

Both retirees took out exactly the same $1,342,287. Neither ran out of money within 25 years. But one ends with a balance that covers less than two years of spending and the other ends richer than they started.

Morningstar’s retirement researchers describe the same effect in their State of Retirement Income work: in their simulations, nearly 70% of the retirement “failures” were trials where the portfolio had lost value by the end of year five. Our 2000 retiree lost 46% of their starting balance in the first three years.

It isn’t the average return. It’s the first few years

The cleanest way to prove that sequence risk isn’t just “bad returns” is to compare real retirement start years. I ran the same 4% rule over every 20-year window the SPY data allows, from a 1994 start to a 2006 start (each ending by 2025).

Look at 1999 and 2000. A retiree starting in 1999 earned a lower 20-year compound return (5.51%) than one starting in 2000 (5.97%). Yet the 1999 retiree ended with $647,015 and the 2000 retiree with $318,300, about half as much.

Why? The 1999 retiree banked SPY’s strong 1999 before the crash, so their first three years combined were only −4.1%. The 2000 retiree’s first three years combined were −37.5%. Higher average return, worse order, half the money.

The rest of the chart tells the same story. The 2006 retiree hit the 2008 crash in year three (first three years −23.0%), but the 20-year CAGR of 10.91% was strong enough to end at $3,643,183. Bad years early hurt; very bad years early, with only a middling recovery, is where plans break.

A cheap fix: skip the raise after losing years

Charles Schwab’s guidance on sequence risk lists two practical defenses: keep a cash and short-term bond reserve for the next few years of spending (they suggest about one year in cash and two to four years in short-term bonds), and, if you didn’t prepare, spend less after bad years, for example by giving up inflation adjustments.

I tested the second idea on the unlucky 2000 retiree. The only change: in the year after a losing year, don’t raise the withdrawal for inflation. In 2000 to 2024 that happened six times (after 2000, 2001, 2002, 2008, 2018 and 2022).

That small rule cut total withdrawals from $1,342,287 to $1,199,514 (about $142,773 less over 25 years) and lifted the ending balance from $119,235 to $677,335, a $558,100 improvement. Each skipped raise stays skipped, so spending power drops for good; the trade is a slightly smaller check for a much bigger safety margin.

The Python script

This is the full script behind every number above. It needs pandas, a SPY price file from yfinance (yf.download("SPY", start="1993-01-01", auto_adjust=True) saved as a pickle) and FRED’s CPIAUCSL CSV.

"""Sequence of returns risk example: same 25 SPY years, two orders.
Data: Yahoo Finance SPY adjusted close (yfinance), FRED CPIAUCSL. Assumptions: 100% SPY,
$1,000,000 start, 4% rule ($40,000 in year 1, raised by Dec-to-Dec CPI), withdrawal at start of year, no fees/taxes."""
import pandas as pd

def annual_returns(pkl="src/spy.pkl"):
    px = pd.read_pickle(pkl)["Close"].squeeze()
    ye = px.groupby(px.index.year).last()          # year-end adjusted close
    return ye.pct_change().dropna()                 # calendar-year total return

def cpi_inflation(csv="src/CPIAUCSL.csv"):
    c = pd.read_csv(csv, index_col=0, parse_dates=True).squeeze()
    dec = c[c.index.month == 12]; dec.index = dec.index.year
    return dec.pct_change().dropna()

def simulate(rets, infl, start=1_000_000, rate=0.04, freeze=False):
    """freeze=True: skip the inflation raise in the year after a losing year (a Schwab-style spending fix)."""
    bal, w, path, total = start, start * rate, [start], 0.0
    for r, i in zip(rets, infl):
        take = min(w, bal); bal = (bal - take) * (1 + r); total += take
        path.append(bal); w *= 1 if (freeze and r < 0) else 1 + i
    return path, total

if __name__ == "__main__":
    R, I = annual_returns(), cpi_inflation()
    yrs = list(range(2000, 2025)); r = R.loc[yrs].values; inf = I.loc[[y - 1 for y in yrs]].values  # year-1 raise uses prior Dec-Dec CPI
    cagr = ((1 + R.loc[yrs]).prod()) ** (1 / 25) - 1
    print(f"SPY 2000-2024: CAGR {cagr:.2%}, first 3 years {r[0]:+.1%} {r[1]:+.1%} {r[2]:+.1%}, last 3 {r[-3]:+.1%} {r[-2]:+.1%} {r[-1]:+.1%}")
    nw_f, _ = simulate(r, inf, rate=0); nw_b, _ = simulate(r[::-1], inf, rate=0)
    print(f"no withdrawals: forward ${nw_f[-1]:,.0f}  reversed ${nw_b[-1]:,.0f}")
    f, tf = simulate(r, inf); b, tb = simulate(r[::-1], inf)
    print(f"4% rule forward (retire Jan 2000): end ${f[-1]:,.0f}, withdrawn ${tf:,.0f}, low ${min(f):,.0f}")
    print(f"4% rule reversed (best years first): end ${b[-1]:,.0f}, withdrawn ${tb:,.0f}")
    fz, tz = simulate(r, inf, freeze=True)
    print(f"forward + freeze raise after down years: end ${fz[-1]:,.0f}, withdrawn ${tz:,.0f}")
    print(f"after 3 years: forward ${f[3]:,.0f}  reversed ${b[3]:,.0f}")
    print(f"year-25 withdrawal ${40000*(1+inf[:-1]).prod():,.0f}")
    print("start-year table (20-year windows, ends 2025):")
    for s in range(1994, 2007):
        ys = list(range(s, s + 20)); p, t = simulate(R.loc[ys].values, I.loc[[y - 1 for y in ys]].values)
        c = (1 + R.loc[ys]).prod() ** (1 / 20) - 1
        print(f"  {s}: CAGR {c:.2%}  end ${p[-1]:,.0f}  first3 {(1+R.loc[ys[:3]]).prod()-1:+.1%}")

Output:

SPY 2000-2024: CAGR 7.61%, first 3 years -9.7% -11.8% -21.6%, last 3 -18.2% +26.2% +24.9%
no withdrawals: forward $6,260,930  reversed $6,260,930
4% rule forward (retire Jan 2000): end $119,235, withdrawn $1,342,287, low $119,235
4% rule reversed (best years first): end $3,773,727, withdrawn $1,342,287
forward + freeze raise after down years: end $677,335, withdrawn $1,199,514
after 3 years: forward $537,830  reversed $1,160,626
year-25 withdrawal $72,709
start-year table (20-year windows, ends 2025):
  1994: CAGR 9.10%  end $3,357,508  first3 +69.8%
  1995: CAGR 9.77%  end $4,037,107  first3 +125.7%
  1996: CAGR 8.08%  end $2,540,089  first3 +110.4%
  1997: CAGR 7.60%  end $2,070,276  first3 +106.8%
  1998: CAGR 7.10%  end $1,420,040  first3 +39.8%
  1999: CAGR 5.51%  end $647,015  first3 -4.1%
  2000: CAGR 5.97%  end $318,300  first3 -37.5%
  2001: CAGR 7.41%  end $948,356  first3 -11.3%
  2002: CAGR 9.46%  end $2,207,638  first3 +11.3%
  2003: CAGR 9.69%  end $3,377,857  first3 +48.7%
  2004: CAGR 9.61%  end $2,823,689  first3 +34.4%
  2005: CAGR 10.27%  end $3,082,371  first3 +27.7%
  2006: CAGR 10.91%  end $3,643,183  first3 -23.0%

To try your own numbers, change start, rate, or the year list, or pass freeze=True. If you want to see how your actual holdings have done against the S&P 500 without uploading them anywhere, PortfolioTracker24 is a free tracker that runs in your browser, needs no account or broker connection, and keeps Excel backups.

What this example doesn’t show

• It’s one asset. 100% SPY is the case Morningstar flags as most exposed to sequence risk. A stock-bond mix falls less in a crash; see Finxter’s 60/40 portfolio max drawdown analysis for how much less.
• History isn’t a forecast. The reversed order is a thought experiment, not a scenario anyone lived.
• Real life has taxes, fees, and flexible spending. Most retirees cut back after a crash anyway, which is exactly why the freeze test matters.

For the flip side of the same coin, read missing the best days in the market (the biggest up-days come right after the worst ones) and how long it takes the stock market to recover from a crash. If you’re still in the saving phase, lump sum vs DCA covers the order-of-returns question for money going in.

FAQ

What is a simple example of sequence of returns risk?

Take SPY's 2000–2024 returns, $1M and a 4% inflation-adjusted withdrawal. In real order (crash first) the portfolio ends at $119,235. Reverse the same 25 returns and it ends at $3,773,727, even though both withdrew $1,342,287.

Does sequence of returns risk matter if I'm not withdrawing?

No. With no withdrawals, the same returns in any order give the same result: $1M grows to $6,260,930 either way in this example. Sequence risk appears when money flows in or out.

How many years of retirement does sequence risk affect most?

The first few. Morningstar found nearly 70% of failed retirement simulations had lost value by the end of year five. In this example the 2000 retiree was down 46% after three years.

Is a higher average return always safer?

No. Retiring in 1999 earned a lower 20-year CAGR (5.51%) than retiring in 2000 (5.97%), yet ended with $647,015 versus $318,300, because its first three years were −4.1% combined instead of −37.5%.

How can I reduce sequence of returns risk?

Schwab suggests holding about a year of spending in cash and two to four years in short-term bonds, and spending less after bad years. Skipping the inflation raise after losing years lifted our 2000 retiree's ending balance from $119,235 to $677,335.

The takeaway

Sequence of returns risk turns the same 7.61% a year into either $119,235 or $3.77 million, depending only on which years come first. You can’t choose your first five years of retirement, but you can plan for them: hold a few years of spending outside stocks, and be ready to skip a raise after a losing year.

And if you’ve built a model like this, consider writing it up. ImagineYourBook can turn your notes into a full draft of a retirement-planning guide or lead-magnet ebook that you then edit and publish. The free trial includes one 10,000-word book; a card is required, and the $24.99 Author plan starts after 7 days unless you cancel before day 8.

Sources (checked November 9, 2026): Yahoo Finance: SPY history · yfinance on GitHub · FRED: CPIAUCSL consumer price index · Morningstar: The biggest risk for new retirees · Charles Schwab: What is sequence-of-returns risk? · ImagineYourBook pricing and trial terms. Script: seqrisk.py (shown above). Not investment advice.

The catch most charts leave out: those 10 best days were not random. Eight of them came within 10 trading days of one of the 20 worst days, and nine came while SPY was more than 20% below its peak. You can’t skip the crashes and keep the rebounds, because they happen in the same weeks. I ran the numbers on real Yahoo Finance data with a short Python script you can copy below.

If you’re the friend who always ends up explaining “time in the market” to your family or your investing club, this kind of worked example is exactly what makes a good beginner’s investing guide or newsletter lead magnet. ImagineYourBook is an AI book-writing tool that turns a prompt or your own notes into a complete ~10,000-word draft with a designed cover, exported to Word and EPUB, so your charts and rules of thumb can become a short finance ebook you then edit and fact-check.

What “missing the best days” actually means

The test is simple. Take every trading day of an index fund. Rank the daily returns. Then replay history twice: once fully invested, and once sitting in cash on the N biggest up-days. Everything else stays identical.

My setup, so you can check it:

• Data: SPY daily adjusted closes from Yahoo Finance via the open-source yfinance library, January 29, 1993 (SPY’s first trading day) to November 3, 2026. The adjusted close includes reinvested dividends, so this is total return.
• Cash on missed days earns 0%. This is an assumption, and it’s the same one J.P. Morgan uses. It slightly overstates the damage when T-bills pay 4–5%, but a day of T-bill interest is about 0.02%, nothing next to a +10% day.
• No fees, taxes or trading costs. Real market timers would also pay spreads and, in taxable accounts, capital gains tax on every exit.

The cost of missing the best days, in dollars

Here is the full table. The “last 20 years” rows start on November 3, 2006, for comparison with the famous J.P. Morgan chart.

Missing five days costs 40%. Missing 10 costs 57%. Miss 50 of the best days in the last 20 years and $10,000 turns into $6,917: you would have lost money in a period when the market compounded at 10.93% a year.

The 10-day line is the same −57% in both windows because all 10 of the best days since 1993 fell after 2006: six in the 2008–2009 crash, three in the 2020 COVID crash, one in April 2025.

Note how all four lines move together for 15 years. Then October 2008 hits, and the gap opens in a few weeks and never closes. That is the whole story of missing the best days: years of nothing, then a handful of sessions that decide the result.

My numbers line up with the most-cited version of this chart. J.P. Morgan’s Guide to Retirement 2026 uses the S&P 500 Total Return Index from January 2, 2006 to December 31, 2025: $10,000 became $80,619 (11.0% a year) fully invested, and $35,866 (6.6%) after missing the 10 best days. My SPY window, November 2006 to November 2026, gives $79,634 (10.93%) and $34,554 (6.40%). SPY’s ~0.09% expense ratio and the slightly different dates explain the small gap.

The animation below removes the best days one at a time. Watch how quickly the ending value collapses:

Why you can’t dodge the bad days and keep the good ones

The “missing the best days” chart is often used to say “never sell.” The data supports that, but for a more interesting reason than the chart shows. Look at when the best days happened:

Three numbers from the script tell the story:

• 8 of the 10 best days came within 10 trading days of one of the 20 worst days. October 13, 2008 (+14.5%) came two sessions after the October 9 drop of −7.0%. March 13, 2020 (+8.5%) came one session after March 12 (−9.6%).
• 9 of the 10 best days came while SPY was more than 20% below its previous high. Only 17% of all trading days since 1993 were spent that deep in a drawdown.
• The one exception, April 9, 2025 (+10.5%), came three days after SPY’s −5.9% day on April 4, 2025, while SPY was about 10% below its peak.

So the best days are bear-market days. The person who sold after a −7% day, “to wait until things calm down”, is precisely the person who misses the +14.5% day two sessions later.

The fair version of the experiment cuts both ways. Missing the 10 worst days would have turned $10,000 into $751,970. Missing both the 10 best and the 10 worst ends at $326,292, almost exactly the $313,613 of simply staying invested. In other words, someone who somehow dodged both tails would end up only about 4% ahead after 33.8 years. A real one, who sells after the crash and buys back after the rebound, is in the $136,082 row.

If you’ve already read how long the stock market takes to recover from a crash, this is the other half of that answer: the recovery starts with these violent up-days, often while the headlines are still bad.

The Python script (copy, run, change the ticker)

The whole analysis fits in about 40 lines of pandas. Install yfinance and pandas, then run it. If you’re new to Python, Finxter’s Python crash course covers everything you need for this script.

# bestdays.py - what does missing the best days in the market cost? (pip install yfinance pandas)
import pandas as pd, yfinance as yf

START, END, CASH = "1993-01-29", "2026-11-04", 10_000   # SPY's first close -> last close (Nov 3, 2026)

def load(ticker="SPY", start=START):
    px = yf.download(ticker, start=start, end=END, auto_adjust=True, progress=False)["Close"].squeeze()
    return px.pct_change().dropna()                     # daily total returns (dividends included)

def grow(r, skip=()):
    """$10k path; on skipped days you sit in cash earning 0% (assumption)."""
    path = CASH * (1 + r.where(~r.index.isin(skip), 0.0)).cumprod()
    start = r.index[0] - pd.tseries.offsets.BDay(1)     # day 0 = $10k at the first close
    return pd.concat([pd.Series({start: CASH}), path])

def cagr(path):
    yrs = (path.index[-1] - path.index[0]).days / 365.25
    return (path.iloc[-1] / CASH) ** (1 / yrs) - 1

def report(r, label):
    best, worst = r.nlargest(50).index, r.nsmallest(50).index
    print(f"--- {label}: {len(r):,} trading days to {r.index[-1]:%Y-%m-%d}")
    for n in (0, 5, 10, 20, 30, 50):
        p = grow(r, best[:n])
        print(f"miss best {n:>2}: ${p.iloc[-1]:>9,.0f}  CAGR {cagr(p):.2%}")
    for n in (10, 20):
        p, q = grow(r, worst[:n]), grow(r, best[:n].union(worst[:n]))
        print(f"miss worst {n}: ${p.iloc[-1]:,.0f} ({cagr(p):.2%}) | miss best+worst {n}: ${q.iloc[-1]:,.0f} ({cagr(q):.2%})")
    return best, worst

if __name__ == "__main__":
    r = load()
    best, worst = report(r, "SPY since Jan 29, 1993")
    report(r[r.index > "2006-11-03"], "SPY last 20 years")
    wealth = (1 + r).cumprod(); dd = wealth / wealth.cummax() - 1
    near = [min(abs(r.index.get_loc(b) - r.index.get_loc(w)) for w in worst[:20]) for b in best[:10]]
    print("10 best days:", ", ".join(f"{d:%Y-%m-%d} {r[d]:+.1%}" for d in best[:10]))
    print(f"trading days to nearest top-20 worst day: {near} -> {sum(g <= 10 for g in near)}/10 within 10")
    print(f"best 10 days in a 20%+ drawdown: {(dd[best[:10]] < -0.2).sum()}/10 (all days: {(dd < -0.2).mean():.0%})")

Output on November 4, 2026 (Yahoo data through the November 3 close):

--- SPY since Jan 29, 1993: 8,498 trading days to 2026-11-03
miss best  0: $  313,613  CAGR 10.74%
miss best  5: $  187,437  CAGR 9.07%
miss best 10: $  136,082  CAGR 8.04%
miss best 20: $   78,634  CAGR 6.30%
miss best 30: $   49,189  CAGR 4.83%
miss best 50: $   22,024  CAGR 2.37%
miss worst 10: $751,970 (13.65%) | miss best+worst 10: $326,292 (10.88%)
miss worst 20: $1,350,227 (15.64%) | miss best+worst 20: $338,549 (11.00%)
--- SPY last 20 years: 5,029 trading days to 2026-11-03
miss best  0: $   79,634  CAGR 10.93%
miss best  5: $   47,595  CAGR 8.11%
miss best 10: $   34,554  CAGR 6.40%
miss best 20: $   20,784  CAGR 3.73%
miss best 30: $   13,803  CAGR 1.62%
miss best 50: $    6,917  CAGR -1.83%
miss worst 10: $187,972 (15.80%) | miss best+worst 10: $81,564 (11.06%)
miss worst 20: $324,161 (19.00%) | miss best+worst 20: $84,604 (11.27%)
10 best days: 2008-10-13 +14.5%, 2008-10-28 +11.7%, 2025-04-09 +10.5%, 2020-03-24 +9.1%, 2020-03-13 +8.5%, 2009-03-23 +7.2%, 2008-11-24 +6.9%, 2020-04-06 +6.7%, 2008-11-13 +6.2%, 2008-10-20 +6.0%
trading days to nearest top-20 worst day: [2, 4, 3, 6, 1, 43, 2, 15, 4, 2] -> 8/10 within 10
best 10 days in a 20%+ drawdown: 9/10 (all days: 17%)

Three easy modifications:

1. Another fund: load("QQQ") or load("VT"), and check whether its best days sit in the same crash windows.
2. A cash yield: replace the 0.0 in grow() with a daily T-bill rate, e.g. 0.04 / 252, to test the 0% assumption.
3. Your own exits: pass the dates you were actually out of the market as skip and see what they cost.

That last one is the honest test. To see what your real trades did against simply buying the index on the same dates, PortfolioTracker24 is a free browser tracker (no account, no broker connection, data stays in your browser with Excel backups) that compares your dated purchases and sales to the same cash flows in the S&P 500 and Bitcoin. For the math behind that comparison, see compare my portfolio to the S&P 500, and for the closely related “wait for a dip” question, lump sum vs DCA in the S&P 500.

What to do with this

If the swings themselves are what make you want to sell, the fix is the allocation, not the timing. A 60/40 mix fell −35.8% at its 2008 low (see the 60/40 portfolio max drawdown analysis), versus −55.2% for SPY in the same data, and is much easier to hold through the weeks where the best days happen.

Limitations. This is one fund, one country, and 33.8 years of history, not a forecast. The cash-at-0% and no-tax assumptions are simplifications. And no investor misses exactly the 10 best days; the point is that the days you’d be most tempted to be out are the days that carry the result.

FAQ

What happens if you miss the 10 best days in the stock market?

In SPY from January 1993 to November 3, 2026, $10,000 grew to $313,613 fully invested but only $136,082 after missing the 10 best days. That is 57% less money, and the annual return falls from 10.74% to 8.04%.

Why do the best days happen near the worst days?

Big up-days come in high-volatility crashes. Eight of SPY's 10 best days since 1993 fell within 10 trading days of one of its 20 worst days, and nine came while SPY was more than 20% below its peak.

Is missing the best days in the market a myth?

No, but the usual chart is one-sided. Missing SPY's 10 worst days would have produced $751,970, and missing both the 10 best and 10 worst gave $326,292. Since nobody can pick either set in advance, staying invested wins in practice.

What did J.P. Morgan find about missing the best days?

J.P. Morgan's Guide to Retirement 2026 shows $10,000 in the S&P 500 Total Return Index from 2006 to 2025 growing to $80,619 fully invested and $35,866 after missing the 10 best days: 11.0% vs 6.6% a year.

Should I sell stocks before a market crash?

History says selling after big drops usually means missing the rebound. October 13, 2008 (+14.5%) came two trading days after a −7.0% day. If volatility worries you, lower your stock allocation instead of trying to time exits.

The takeaway

Missing the best days in the market cost 57% of the ending value since 1993, and those days sit right next to the worst days. The practical rule is boring: pick an allocation you can hold through a −10% session, automate your contributions, and don’t sell in the panic week.

And if you’ve built up your own investing rules, scripts and charts over the years, they’re worth packaging. A short guide like “Stay Invested: What 33 Years of SPY Data Say” makes a solid newsletter lead magnet or Kindle ebook. ImagineYourBook can turn your notes into a ~10,000-word draft with Word and EPUB export. The 7-day trial is $0 today with a card required, includes one 10k-word Small Book, and becomes $24.99/month unless you cancel before day 8. It writes text books with a cover, not picture books, and you still own the job of checking every number.

Sources (checked November 4, 2026): Yahoo Finance: SPY history · yfinance on GitHub · J.P. Morgan Guide to Retirement 2026 (PDF) · Finxter: 60/40 max drawdown · ImagineYourBook pricing and trial terms. Script: bestdays.py (shown above). Not investment advice.

This dividend reinvestment calculator doesn’t assume a smooth 7% return. It replays every real SPY, VYM, SCHD and QQQ dividend from Yahoo Finance, day by day, with and without reinvestment. The Python script is below, so you can run it on your own tickers.

How the calculator works (assumptions labeled)

The script, drip.py, does what a broker’s DRIP does, and labels its simplifications:

• Data: daily closes plus per-share dividends from Yahoo Finance via yfinance, through October 30, 2026.
• Assumption 1: each dividend is reinvested at the close on its ex-date. Real brokers buy on the payment date, a few days later. That’s a small difference over 27 years.
• Assumption 2: in the “no DRIP” case the cash just sits there at 0%. This is the honest version of “I’ll spend it or leave it in the account”.
• Assumption 3: no taxes or fees unless I say so. Taxes get their own section below.

As a sanity check, Yahoo’s dividend-adjusted price series turns the same $10,000 into $83,131. My day-by-day replay lands at $83,195, a 0.1% difference. So the replay matches total return.

The results: DRIP vs cash, five real histories

The SPY row is the headline. Without reinvestment you still owned your original 68.8 shares. With it, quarterly dividends quietly bought another 41 shares, so you finish with 110.1 shares. Each of those shares is now worth about $756 and pays its own dividends.

Go back further and the gap widens. From SPY’s first trading day in January 1993, $10,000 grew to $314,411 with DRIP versus $197,803 without. That’s $116,608 (59%) more, and the only difference is what you did with a 1–2% yield.

Two dials decide how much reinvesting adds:

1. Yield. QQQ paid only 0.45% over the last 12 months, so 27 years of reinvesting added just 14%. VYM, at 2.25%, added 43% in only 20 years.
2. Time. SCHD yields the most (2.95%), but its history only starts in October 2011. Fifteen years of reinvesting added 28% ($15,050). It simply hasn’t had SPY’s 33 years yet.

Napkin rule: the DRIP edge grows roughly with yield × years. A 1% yield over 27 years (SPY) and a 2.25% yield over 20 years (VYM) both landed near +41–43%.

The surprise: reinvesting barely mattered for 12 years

Here’s the part no compound-interest calculator shows you. Reinvesting doesn’t pull ahead in a straight line. In the SPY run that started in 2000, the DRIP account was behind the cash account at the end of 2000, 2001, 2002 and 2008.

The reason is simple. Every dividend reinvested in 2000–2002 bought shares that then fell during the dot-com crash. The cash version held those dollars at full value. At the end of 2008 the DRIP account was 3.2% behind. Its lead was still only 3.2% at the end of 2011.

After that, compounding took over. The lead hit 10% in 2013, 26% in 2020, and 40.7% by October 30, 2026. If you check your DRIP after a few years and see nothing, that’s normal. The payoff comes in the second decade.

It also explains why the 60/40 portfolio’s max drawdown and the time to recover from a crash both matter here. A DRIP buys more shares when prices are low, but it only pays off if you keep holding until the recovery.

The income you end up with

People rarely reinvest for the final balance alone. They want a larger dividend check later. So the calculator multiplies the last 12 months of per-share payouts by the shares you hold now:

From one $10,000 start, SPY now pays $835 a year to the DRIP investor versus $521 to the cash investor, 60% more income from the same original money. SCHD pays $2,038 versus $1,267. With reinvestment, each new share pays dividends too, so the income grows on its own.

With monthly contributions the gap reaches six figures

Most people don’t invest once and walk away. So I ran the calculator again with $10,000 up front plus $500 on the first trading day of every month into SPY from January 2000. That’s $170,500 contributed in total (the same approach as the monthly plan in my lump sum vs DCA on the S&P 500 backtest).

With reinvestment the account crosses $1,049,823. Without it, it reaches $846,717. The difference is $203,106, more than the total amount contributed. Monthly money shrinks the gap in percentage terms (24% vs 41%), because fresh cash hasn’t had time to compound. In dollars, though, the gap grows a lot.

Taxes: reinvesting doesn’t dodge them

In a taxable US account, the IRS treats reinvested dividends exactly like cash dividends. Publication 550 says that if you use your dividends to buy more stock, “you must still report the dividends as income”. So DRIP isn’t a tax strategy. It’s a compounding strategy.

Qualified dividends are taxed at long-term capital gain rates (IRS Topic 404). For 2025 those rates are 0%, 15% or 20% depending on taxable income, and “no higher than 15% for most individuals” (IRS Topic 409).

Assumption: a flat 15% on every SPY dividend, with tax paid out of the dividend before reinvesting. The DRIP result falls from $83,195 to $77,535, a $5,660 drag over 27 years. In a tax-advantaged account like an IRA or 401(k), there’s no yearly drag and the untaxed numbers above apply.

The Python dividend reinvestment calculator

Install yfinance and pandas, then save the prices once (so reruns don’t hit Yahoo every time) and run the script:

import yfinance as yf, pandas as pd
d = {t: yf.Ticker(t).history(start="1993-01-01", end="2026-11-01", auto_adjust=False, actions=True)
     for t in ["SPY", "SCHD", "VYM", "QQQ"]}
pd.to_pickle(d, "src/prices.pkl")

auto_adjust=False keeps the raw (split-adjusted) close and the separate Dividends column. If you replayed dividends on top of the dividend-adjusted close, you’d count them twice.

"""Dividend reinvestment calculator: replay real ETF history (Yahoo Finance closes + dividends),
with vs without reinvesting dividends, optional monthly contributions and dividend tax."""
import pandas as pd

def load(path="src/prices.pkl"):
    d = pd.read_pickle(path)
    return {t: h[["Close", "Dividends"]].tz_localize(None).loc[:"2026-10-30"] for t, h in d.items()}

def drip(h, start, initial=10_000, monthly=0, reinvest=True, tax=0.0):
    """Daily replay. Dividends paid on the ex-date at that day's close (a common approximation)."""
    h = h.loc[start:]
    shares, cash, paid, invested, month, rows = 0.0, 0.0, 0.0, 0.0, None, []
    for day, (px, div) in h.iterrows():
        if month is None:
            shares, invested = initial / px, initial
        elif day.month != month and monthly:
            shares += monthly / px; invested += monthly
        month = day.month
        if div > 0:
            net = shares * div * (1 - tax); paid += net
            if reinvest: shares += net / px
            else: cash += net
        rows.append((day, shares * px + cash, shares * px, cash, invested, paid))
    return pd.DataFrame(rows, columns=["date", "total", "stock", "cash", "invested", "divs"]).set_index("date")

def cagr(s):
    yrs = (s.index[-1] - s.index[0]).days / 365.25
    return (s.iloc[-1] / s.iloc[0]) ** (1 / yrs) - 1

if __name__ == "__main__":
    P = load()
    for t, start in (("SPY", "2000-01-03"), ("SPY", "1993-01-29"), ("SCHD", "2011-10-20"), ("VYM", "2006-11-16"), ("QQQ", "2000-01-03")):
        a, b = drip(P[t], start), drip(P[t], start, reinvest=False)
        yrs = (a.index[-1] - a.index[0]).days / 365.25
        print(f"{t} {a.index[0]:%b %Y}-{a.index[-1]:%b %Y} ({yrs:.1f} yrs) $10k: DRIP ${a.total.iloc[-1]:,.0f} "
              f"(CAGR {cagr(a.total):.2%}) | no DRIP ${b.total.iloc[-1]:,.0f} = ${b.stock.iloc[-1]:,.0f} shares + ${b.cash.iloc[-1]:,.0f} cash "
              f"(CAGR {cagr(b.total):.2%}) | DRIP edge ${a.total.iloc[-1]-b.total.iloc[-1]:,.0f} ({a.total.iloc[-1]/b.total.iloc[-1]-1:.0%}) | "
              f"shares {a.stock.iloc[-1]/P[t].Close.iloc[-1]:.1f} vs {b.stock.iloc[-1]/P[t].Close.iloc[-1]:.1f}")
    a = drip(P["SPY"], "2000-01-03", monthly=500); b = drip(P["SPY"], "2000-01-03", monthly=500, reinvest=False)
    print(f"SPY 2000 $10k + $500/mo (invested ${a.invested.iloc[-1]:,.0f}): DRIP ${a.total.iloc[-1]:,.0f} | no DRIP ${b.total.iloc[-1]:,.0f}")
    t15 = drip(P["SPY"], "2000-01-03", tax=0.15)
    print(f"SPY 2000 $10k DRIP with 15% dividend tax: ${t15.total.iloc[-1]:,.0f}")
    # annual dividend income at the end (last 12 months of per-share payouts x shares held)
    for t, start in (("SPY", "2000-01-03"), ("VYM", "2006-11-16"), ("SCHD", "2011-10-20"), ("QQQ", "2000-01-03")):
        ttm = P[t].Dividends.loc["2025-10-31":].sum(); px = P[t].Close.iloc[-1]
        a, b = drip(P[t], start), drip(P[t], start, reinvest=False)
        print(f"{t} trailing-12m payout ${ttm:.3f}/share = {ttm/px:.2%} yield; yearly income DRIP ${ttm*a.stock.iloc[-1]/px:,.0f} vs no DRIP ${ttm*b.stock.iloc[-1]/px:,.0f}")

Output on October 30, 2026 data:

SPY Jan 2000-Oct 2026 (26.8 yrs) $10k: DRIP $83,195 (CAGR 8.22%) | no DRIP $59,123 = $51,962 shares + $7,161 cash (CAGR 6.85%) | DRIP edge $24,072 (41%) | shares 110.1 vs 68.8
SPY Jan 1993-Oct 2026 (33.7 yrs) $10k: DRIP $314,411 (CAGR 10.76%) | no DRIP $197,803 = $171,999 shares + $25,804 cash (CAGR 9.25%) | DRIP edge $116,608 (59%) | shares 416.0 vs 227.6
SCHD Oct 2011-Oct 2026 (15.0 yrs) $10k: DRIP $69,132 (CAGR 13.73%) | no DRIP $54,081 = $42,970 shares + $11,111 cash (CAGR 11.89%) | DRIP edge $15,050 (28%) | shares 1932.1 vs 1201.0
VYM Nov 2006-Oct 2026 (20.0 yrs) $10k: DRIP $59,485 (CAGR 9.35%) | no DRIP $41,668 = $32,449 shares + $9,218 cash (CAGR 7.41%) | DRIP edge $17,818 (43%) | shares 363.3 vs 198.2
QQQ Jan 2000-Oct 2026 (26.8 yrs) $10k: DRIP $86,575 (CAGR 8.38%) | no DRIP $75,786 = $72,875 shares + $2,911 cash (CAGR 7.84%) | DRIP edge $10,789 (14%) | shares 125.4 vs 105.5
SPY 2000 $10k + $500/mo (invested $170,500): DRIP $1,049,823 | no DRIP $846,717
SPY 2000 $10k DRIP with 15% dividend tax: $77,535
SPY trailing-12m payout $7.583/share = 1.00% yield; yearly income DRIP $835 vs no DRIP $521
VYM trailing-12m payout $3.676/share = 2.25% yield; yearly income DRIP $1,335 vs no DRIP $728
SCHD trailing-12m payout $1.055/share = 2.95% yield; yearly income DRIP $2,038 vs no DRIP $1,267
QQQ trailing-12m payout $3.091/share = 0.45% yield; yearly income DRIP $388 vs no DRIP $326

To use it for your own holdings, change the ticker, start, initial, monthly and tax. If you also want to see whether your picks beat the index after dividends, my guide to comparing your portfolio to the S&P 500 uses the same total-return logic.

What to do with this

1. Turn DRIP on in tax-advantaged accounts unless you need the income now. Across these five histories, that one setting was worth 14–59% more money.
2. In taxable accounts, reinvest anyway if you were going to reinvest by hand. The tax is the same either way. DRIP just stops cash from sitting idle.
3. Judge it after 10+ years, not 3. The SPY run was behind or within about 3% of the cash version for its first 12 years.
4. Don’t chase yield for the DRIP edge alone. QQQ’s tiny 0.45% yield still finished with a higher DRIP balance than SPY ($86,575 vs $83,195), because price growth did the work.

Limitations: ex-date reinvestment, 0% on idle cash, no fees, and one 15% tax assumption. SCHD and VYM have shorter histories. This is history, not a forecast, and not investment advice.

From calculator to finance ebook

If you’ve worked through numbers like these, you already have the outline of a short, useful ebook: “DRIP vs cash, with real data”. You could use it as a lead magnet for a finance newsletter or sell it on KDP. ImagineYourBook is an AI book-writing tool that turns a prompt or your notes into a complete draft with a designed cover and Word and EPUB downloads. It also has a Manuscript Rewrite feature for updating an existing book, for example when next year’s dividend data comes in.

Takeaway: reinvesting SPY’s roughly 1% yield turned $10,000 into $83,195 instead of $59,123. The edge was invisible for 12 years and worth 41% after 27. Run the script on your own tickers, keep DRIP on, and give it a decade.

If you want to package what you learned into a book, ImagineYourBook‘s trial is $0 today with a card required. It includes one 10,000-word Small Book, the first $29.99 charge comes after 7 days, and you can cancel any time before day 8. Treat the result as a draft: check every number before you publish.

Sources (checked November 2, 2026): Yahoo Finance: SPY · VYM · SCHD · QQQ · yfinance on GitHub · IRS Publication 550 · IRS Topic 404 · IRS Topic 409 · ImagineYourBook pricing and trial terms. Script: drip.py (shown above). Not investment advice.

That cushion is not a constant, though. In 2008 bonds rose while stocks fell, and the 60/40 lost 19.5 points less than stocks. In 2022 both fell together, and the gap shrank to just 3.7 points (−20.9% vs −24.6%). The 60/40 even took longer than stocks to get back to a new high that time.

(If you turn your own investing rules into something you can share, an AI book-writing tool like ImagineYourBook can turn your notes into a draft finance ebook or lead magnet with Word and EPUB export. More on that at the end.)

How I measured the 60/40 max drawdown

“Max drawdown” is the largest drop from a running high to a later low, before a new high is set. The setup, kept simple and reproducible:

• Stocks: Vanguard 500 Index Fund Investor Shares (VFINX), which tracks the S&P 500.
• Bonds: Vanguard Total Bond Market Index Fund Investor Shares (VBMFX), which tracks the broad US investment-grade bond market.
• Data: daily adjusted closes from Yahoo Finance (dividends and interest reinvested, fund fees included), December 11, 1986 to October 30, 2026. That’s nearly 40 years and five big stock declines.
• Rebalancing: back to target weights on the first trading day of each month. No taxes, no trading costs.

I used index mutual funds instead of ETFs because they go back further. As a cross-check, I reran 2008 and 2022 with SPY and AGG (the ETF versions, AGG starts in 2003). The 60/40 drawdowns came out at −35.8% and −20.8%, within 0.1 points of the mutual-fund results.

One detail matters more than people think: daily vs month-end data. Measured on month-end values, the same 60/40 portfolio’s worst drawdown is only −32.5%. That’s the number you’ll see in most monthly backtests, including my rebalancing study. The real intraday-close low on March 9, 2009 was 3.3 points deeper. If you want to know how bad it actually felt, use daily data.

The answer, crash by crash

Across all five episodes, the 60/40 portfolio’s drawdown was between 54% and 85% of the stock fund’s drawdown. Four of the five cluster at 54–66%. The outlier is 2022, where the 60/40 still fell 85% as far as stocks did.

Here’s the napkin math for a real account. Say you hold $500,000 (an example, not a recommendation):

• 100% stocks at the 2008–09 low: −55.3%, so about $276,500 gone on paper.
• 60/40 at the same low: −35.8%, about $179,000 gone.
• In 2022: −24.6% for stocks ($123,000) vs −20.9% for the 60/40 ($104,500). The “safe” mix saved you only $18,500 that year.

Why 2022 broke the cushion

The 60/40 works when bonds zig while stocks zag. That depends on the correlation between the two, and it isn’t fixed. From the same daily data:

• 2008: the daily correlation between the stock and bond funds was −0.35. The stock fund lost 37.0% for the calendar year while the bond fund gained 5.1%.
• 2022: the correlation flipped to +0.27. The stock fund lost 18.2% and the bond fund lost 13.2% in the same year.

The reason was inflation and rate hikes. The Federal Reserve raised its target range from near zero in March 2022 to 4.25–4.50% by December 2022, and existing bonds lose value when rates jump. A bond fund that falls 13% can’t cushion a stock fund that falls 18%.

The bond side still hasn’t fully healed. VBMFX peaked on August 4, 2020, and on October 30, 2026 it was still 4.4% below that high on a total-return basis. Its max drawdown of −18.8% (October 2022) is the deepest in the fund’s history in this data.

That’s also why the 60/40 took 2.1 years to reach a new high after 2022, while stocks needed 1.9 years. In 2008 it was the other way round: 3.2 years for the 60/40 vs 4.9 years for stocks.

What the cushion costs you

Lower drawdowns aren’t free. Over the full period, every 20 points you move from stocks to bonds cuts the worst drawdown by roughly 9 to 12 points and costs about 1.0 to 1.2 points of annual return:

The dollar gap compounds. $10,000 in the stock fund in December 1986 grew to about $661,000. The same $10,000 in the 60/40 grew to about $298,000. That’s the price of a portfolio whose worst day was −35.8% instead of −55.3%.

Whether that’s worth it depends on one question: would you have sold at −55%? An investor who holds through −55% does better with stocks. An investor who panics at −40% and sells does much worse than a 60/40 holder who stays put. For more on that recovery side, see how long the stock market takes to recover from a crash.

The Python script

This is the whole backtest. It needs pandas and yfinance (pip install pandas yfinance). Download the prices once, save them, and run it:

import yfinance as yf
yf.download(["VFINX", "VBMFX"], start="1986-01-01", auto_adjust=True)["Close"].to_pickle("src/prices.pkl")

"""60/40 portfolio max drawdown: VFINX (S&P 500 index fund) + VBMFX (US total bond index fund),
daily adjusted closes from Yahoo Finance, rebalanced to target on the first trading day of each month."""
import pandas as pd

def load(path="src/prices.pkl"):
    px = pd.read_pickle(path)[["VFINX", "VBMFX"]].dropna()
    return px.loc[:"2026-10-30"]

def portfolio(px, w_stock):
    r = px.pct_change().dropna()
    value, vals, w = 1.0, [], None
    month = None
    for day, row in r.iterrows():
        if day.month != month:                    # rebalance at start of each month
            month, w = day.month, {"VFINX": w_stock, "VBMFX": 1 - w_stock}
            hold = {k: value * v for k, v in w.items()}
        hold = {k: hold[k] * (1 + row[k]) for k in hold}
        value = sum(hold.values()); vals.append(value)
    return pd.Series(vals, index=r.index)

def drawdown(v):
    return v / v.cummax() - 1

def episode(v, start, end):
    """Max drawdown inside [start, end], peak date, trough date, recovery date."""
    dd = drawdown(v)
    trough = dd.loc[start:end].idxmin()
    peak = v.loc[:trough].idxmax()
    after = v.loc[trough:]
    rec = after[after >= v.loc[peak]]
    return dict(depth=dd.loc[trough], peak=peak, trough=trough,
                recovered=rec.index[0] if len(rec) else None)

def cagr(v):
    yrs = (v.index[-1] - v.index[0]).days / 365.25
    return (v.iloc[-1] / v.iloc[0]) ** (1 / yrs) - 1

if __name__ == "__main__":
    px = load()
    eps = {"1987 crash": ("1987-08-01", "1987-12-31"), "Dot-com 2000-02": ("2000-01-01", "2003-03-31"),
           "2008 crisis": ("2007-10-01", "2009-06-30"), "COVID 2020": ("2020-02-01", "2020-04-30"),
           "2022 bear": ("2022-01-01", "2022-12-31")}
    for w in (1.0, 0.8, 0.6, 0.4):
        v = portfolio(px, w)
        print(f"\n{int(w*100)}/{int(round((1-w)*100))}: CAGR {cagr(v):.2%}, max DD {drawdown(v).min():.1%}, "
              f"$10k -> ${10000*v.iloc[-1]:,.0f} ({v.index[0]:%b %Y}-{v.index[-1]:%b %Y})")
        for name, (a, b) in eps.items():
            e = episode(v, a, b)
            rec = e["recovered"]
            yrs = f"{(rec - e['peak']).days/365.25:.1f} yrs to new high" if rec is not None else "not recovered"
            print(f"  {name:16s} {e['depth']:7.1%}  peak {e['peak']:%Y-%m-%d} trough {e['trough']:%Y-%m-%d}  {yrs}")
    bonds = px["VBMFX"] / px["VBMFX"].iloc[0]
    e = episode(bonds, "2020-08-01", "2023-12-31")
    print(f"\nBonds alone (VBMFX): max DD {drawdown(bonds).min():.1%}, 2020-23 drawdown {e['depth']:.1%} trough {e['trough']:%Y-%m-%d} recovered {e['recovered']}")

Output (October 30, 2026 data):

100/0: CAGR 11.09%, max DD -55.3%, $10k -> $661,370 (Dec 1986-Oct 2026)
  1987 crash        -33.1%  peak 1987-08-25 trough 1987-10-19  1.7 yrs to new high
  Dot-com 2000-02   -47.5%  peak 2000-09-01 trough 2002-10-09  6.1 yrs to new high
  2008 crisis       -55.3%  peak 2007-10-09 trough 2009-03-09  4.9 yrs to new high
  COVID 2020        -33.8%  peak 2020-02-19 trough 2020-03-23  0.5 yrs to new high
  2022 bear         -24.6%  peak 2022-01-03 trough 2022-10-12  1.9 yrs to new high

80/20: CAGR 10.04%, max DD -46.3%, $10k -> $452,010 (Dec 1986-Oct 2026)
  1987 crash        -27.4%  peak 1987-08-25 trough 1987-10-19  1.7 yrs to new high
  Dot-com 2000-02   -37.5%  peak 2000-09-01 trough 2002-10-09  5.3 yrs to new high
  2008 crisis       -46.3%  peak 2007-10-09 trough 2009-03-09  3.5 yrs to new high
  COVID 2020        -27.9%  peak 2020-02-19 trough 2020-03-23  0.5 yrs to new high
  2022 bear         -22.6%  peak 2021-12-27 trough 2022-10-14  2.0 yrs to new high

60/40: CAGR 8.89%, max DD -35.8%, $10k -> $297,508 (Dec 1986-Oct 2026)
  1987 crash        -21.7%  peak 1987-08-25 trough 1987-10-19  1.4 yrs to new high
  Dot-com 2000-02   -25.9%  peak 2000-09-01 trough 2002-10-09  4.2 yrs to new high
  2008 crisis       -35.8%  peak 2007-10-09 trough 2009-03-09  3.2 yrs to new high
  COVID 2020        -21.6%  peak 2020-02-19 trough 2020-03-23  0.4 yrs to new high
  2022 bear         -20.9%  peak 2021-12-27 trough 2022-10-14  2.1 yrs to new high

40/60: CAGR 7.65%, max DD -23.8%, $10k -> $188,700 (Dec 1986-Oct 2026)
  1987 crash        -16.0%  peak 1987-08-25 trough 1987-10-19  1.1 yrs to new high
  Dot-com 2000-02   -13.0%  peak 2001-02-01 trough 2002-07-23  2.3 yrs to new high
  2008 crisis       -23.8%  peak 2007-12-06 trough 2009-03-09  2.3 yrs to new high
  COVID 2020        -15.1%  peak 2020-02-19 trough 2020-03-23  0.3 yrs to new high
  2022 bear         -19.2%  peak 2021-12-27 trough 2022-10-14  2.4 yrs to new high

Bonds alone (VBMFX): max DD -18.8%, 2020-23 drawdown -18.8% trough 2022-10-24 recovered None

Two things to try:

1. Change w_stock to your own mix, or swap in your own funds.
2. Change the rebalance rule. Monthly rebalancing is what this script does. My rebalancing study found annual rebalancing gave similar risk-adjusted results with far fewer trades.

If you’d rather see the observed drawdown of your actual holdings without writing code, PortfolioTracker24 is a free tracker that runs in your browser with no account or broker connection. It shows observed drawdown, Sharpe and Sortino, and compares your returns with the S&P 500 and Bitcoin, with Excel backups (prices are entered manually). For the risk-adjusted side, see Sharpe vs Sortino ratio and how to compare your portfolio to the S&P 500.

Summary: what to expect from a 60/40

Limitations

• This is US-only: one S&P 500 fund and one US bond fund. Global or inflation-linked bonds would behave differently.
• 40 years is still a small sample: five big stock declines, and only one with stocks and bonds falling hard together.
• No taxes or trading costs. Monthly rebalancing in a taxable account would cost something.
• Past drawdowns are history, not a forecast. The next −35% could come from a different mix of stock and bond moves.

The takeaway

The honest answer to “what is the 60/40 portfolio max drawdown” is −35.8% in daily data since 1987, about two-thirds of the stock market’s −55.3%. Plan for that number, not the −20% people assume. And remember that the bond cushion depends on bonds and stocks moving in opposite directions. In 2022 they didn’t, and the 60/40 lost almost as much as stocks.

If this kind of analysis is how you think about money, you could package your own rules into a short investing guide or lead magnet for readers or clients. ImagineYourBook turns a prompt or notes into a complete draft with a cover and Word/EPUB export. The trial is $0 today with a card and includes one 10,000-word book; the first $29.99 payment starts after 7 days unless you cancel before day 8. Check the numbers in any draft yourself, same as you would with this backtest.

Sources (checked November 1, 2026): Yahoo Finance: VFINX history · Yahoo Finance: VBMFX history · Yahoo Finance: AGG (cross-check) · Federal Reserve: FOMC target rate history · yfinance on GitHub · ImagineYourBook pricing and trial terms. Script: dd6040.py (shown above). Not investment advice.

I measured every crash from daily closing prices with a short pandas script, which is included below so you can rerun it on any index or fund. The main pattern: how deep a crash goes tells you more about the wait than anything else. The four crashes that took five or more years to recover all fell 48% or more. Every crash shallower than 40% was back at a record within 3.3 years.

(If you end up with a sharp investing framework of your own, an AI book-writing tool like ImagineYourBook can turn your notes into a draft finance ebook or lead magnet with Word and EPUB export. More on that at the end.)

How I measured “recovery”

“Recovered” can mean three different things, and articles on this question often mix them up. Here is the definition I used, kept strict:

• Crash: the S&P 500 closes at least 20% below its all-time closing high.
• Peak: the last record close before the drop.
• Trough: the lowest close before the index makes a new record.
• Recovered: the first close at or above the old record.

The data is the S&P 500 price index (^GSPC) from Yahoo Finance, daily closes from December 30, 1927 to October 29, 2026, loaded with yfinance. The finding itself is a cummax() one-liner: divide the price by its running maximum, and every value below 1.0 is time spent “under water.”

One consequence of measuring from all-time highs: a slump that happens while the market is still below an older record counts as part of the bigger episode, not as a separate crash. The 1937–38 slide (−54.5% from its March 1937 high) sits inside the 1929 recovery, and 2011’s −19.4% dip came while the index was still below its 2007 record. If you count every bear market from its own local peak, you get more episodes and shorter typical waits.

All 12 S&P 500 crashes since 1928

The median crash fell 33.7%. Measured from the old peak, the median wait for a new record was 2.1 years. Measured from the bottom, the median climb back took just 1.5 years. Both views matter. The first is what someone who bought at the top went through. The second is what a buyer at the bottom saw, or anyone who kept investing on the way down.

Excluding the Great Depression barely moves the number: for the 11 crashes that started in 1946 or later, the median peak-to-new-high time was 2.0 years, and the median trough-to-old-high time was 1.3 years.

Why depth matters more than anything else

A loss and the gain needed to undo it are not symmetric. That is plain arithmetic, not a market forecast:

A 20% drop needs a 25% gain to get back to even. A 57% drop, like 2007–09, needs +133%. The 1929 crash, at −86.2% on daily closes, needed +614%. Because the required gain grows faster than the loss, recovery time grows faster than depth, which is why the scatter chart above uses a log scale. Below about −40%, the S&P 500’s history has been a matter of months to a few years. Past roughly −45%, every recovery took at least 5.5 years.

The speed of the fall matters too. In 2020 the index took 33 calendar days to fall 33.9% (from 3,386.15 on February 19 to 2,237.40 on March 23) and had a new record close of 3,389.78 by August 18. The 2000 crash was shallower than 2007’s at the bottom (−49.1% vs −56.8%) yet took longer overall (7.2 vs 5.5 years), because the decline itself dragged on for 2.5 years.

The animation lines up six post-war crashes on the same clock, with each record high set to 100:

Three of the six had recovered before the three-year mark. The other three needed 5.5 to 7.5 years.

Smaller drops: corrections of 10% to 20%

Most of the scary headlines are about corrections, not crashes. Using the same rules, the S&P 500 had 14 declines of 10% to just under 20% from a record close that never turned into a full crash. The median time from peak to new high was 7 months, and the longest took 1.5 years. That list includes 2025: the index fell 18.9% from its February 19 record to its April 8 low and set a new record on June 27, 2025.

The famous “25 years” is a price-only number

The price index ignores dividends, and dividends do a lot of the work in a recovery. For crashes since 1988 I reran the same test on the S&P 500 Total Return index (^SP500TR, Yahoo Finance). For 1929 I used Robert Shiller’s monthly S&P data, which includes dividends and the CPI (monthly averages, so its dates are a little coarser):

• 2000 crash: 7.2 years on price, 6.1 years with dividends reinvested.
• 2007 crash: 5.5 years on price, 4.5 years with dividends.
• 2020 and 2022: dividends hardly matter over 0.5 to 2 years (0.5 and 1.9 years with dividends).
• 1929 crash: 25.0 years on price (September 1929 to September 1954), 15.3 years with dividends reinvested (January 1945). Adjusted for the 1930s deflation as well, a dividend-reinvesting investor was whole in real terms by November 1936, 7.2 years after the peak.

That doesn’t make 1929 painless. Even with dividends, the real loss at the bottom was about 77%. But “it took 25 years to recover” describes a price chart, not the experience of someone who held the index and reinvested its income.

The Python script

This script finds every crash, prints the table above, and compares price-only recovery with total-return recovery since 1988. Change the ticker argument to "^IXIC", "QQQ", or any fund you own to run the same test on it. The 1929 dividend check lives in a separate helper (shiller_1929.py) because it reads Shiller’s spreadsheet instead of Yahoo data.

"""How long does it take the stock market to recover from a crash?
Every S&P 500 decline of 20%+ since 1928, measured peak -> trough -> back to the old peak.
Data: Yahoo Finance daily closes (^GSPC price index, ^SP500TR total return) via yfinance.
pip install yfinance pandas"""
import pandas as pd

END = "2026-10-29"   # last full trading day when this was written

def load(ticker="^GSPC"):
    try:
        s = pd.read_pickle(f"src/{ticker.strip('^').lower()}.pkl")["Close"][ticker]
    except FileNotFoundError:
        import yfinance as yf
        s = yf.download(ticker, start="1927-12-01", auto_adjust=False, progress=False)["Close"][ticker]
    return s.loc[:END].dropna()

def crashes(s, threshold=0.20):
    """One row per decline of at least `threshold` from a record close, until a new record."""
    peak = s.cummax(); dd = s / peak - 1
    rows, start = [], None
    for date, d in dd.items():
        if d < 0 and start is None:
            start = date                                  # first close below the old record
        elif d == 0 and start is not None:
            seg = dd.loc[start:date]
            if seg.min() <= -threshold:
                p = s.loc[:start].index[-2]               # the record close itself
                t = seg.idxmin()
                rows.append(dict(peak=p, trough=t, recovered=date, depth=seg.min()))
            start = None
    if start is not None and dd.loc[start:].min() <= -threshold:   # still under water
        seg = dd.loc[start:]
        rows.append(dict(peak=s.loc[:start].index[-2], trough=seg.idxmin(), recovered=pd.NaT, depth=seg.min()))
    df = pd.DataFrame(rows)
    yrs = lambda a, b: (b - a).dt.days / 365.25
    df["down_yrs"] = yrs(df.peak, df.trough)
    df["up_yrs"] = yrs(df.trough, df.recovered)            # trough back to the old peak
    df["total_yrs"] = yrs(df.peak, df.recovered)           # peak to new record
    return df

def recover_date(s, peak, trough):
    """First close at or above the peak level after the trough (None if not yet)."""
    after = s.loc[trough:]
    hit = after[after >= s.loc[peak]]
    return hit.index[0] if len(hit) else pd.NaT

if __name__ == "__main__":
    s = load()
    C = crashes(s)
    print(f"S&P 500 price index, {s.index[0]:%b %d %Y} to {s.index[-1]:%b %d %Y}: {len(C)} declines of 20%+")
    print(f"{'peak':>11} {'trough':>11} {'recovered':>11} {'depth':>7} {'down':>6} {'up':>6} {'total':>6}  (years)")
    for _, r in C.iterrows():
        rec = f"{r.recovered:%Y-%m-%d}" if pd.notna(r.recovered) else "not yet"
        print(f"{r.peak:%Y-%m-%d} {r.trough:%Y-%m-%d} {rec:>11} {r.depth:>7.1%} {r.down_yrs:>6.1f} {r.up_yrs:>6.1f} {r.total_yrs:>6.1f}")
    done = C.dropna(subset=["recovered"])
    post = done[done.peak >= "1946-01-01"]
    print(f"\nMedian peak-to-new-high: all {done.total_yrs.median():.1f} yrs, since 1946 {post.total_yrs.median():.1f} yrs")
    print(f"Median trough-to-old-high: all {done.up_yrs.median():.1f} yrs, since 1946 {post.up_yrs.median():.1f} yrs")
    print(f"Median depth: {done.depth.median():.1%};  current close {s.iloc[-1]:,.2f} ({s.iloc[-1]/s.max()-1:.1%} from record)")
    c = crashes(s, 0.10); c = c[(c.depth > -0.20)].dropna(subset=["recovered"])
    print(f"Corrections of 10-20% from a record: {len(c)}, median {c.total_yrs.median()*12:.0f} months peak to new high, "
          f"longest {c.total_yrs.max():.1f} yrs")
    for d in (0.10, 0.20, 0.34, 0.50, 0.57, 0.86):
        print(f"  a -{d:.0%} fall needs +{1/(1-d)-1:.0%} to get back")
    tr = load("^SP500TR")                                  # dividends reinvested, starts 1988
    print("\nSince 1988, price-only vs dividends reinvested (years from peak to a new high):")
    for _, r in done[done.peak >= "1988-01-04"].iterrows():
        p2 = tr.loc[r.peak - pd.Timedelta(days=10):r.trough].idxmax()
        t2 = tr.loc[p2:r.recovered].idxmin()
        rec2 = recover_date(tr, p2, t2)
        print(f"  {r.peak:%Y} crash: price {r.total_yrs:.1f} yrs, total return {(rec2 - p2).days/365.25:.1f} yrs "
              f"(depth {tr.loc[t2]/tr.loc[p2]-1:.1%})")

Output (data through October 29, 2026):

S&P 500 price index, Dec 30 1927 to Oct 29 2026: 12 declines of 20%+
       peak      trough   recovered   depth   down     up  total  (years)
1929-09-16 1932-06-01  1954-09-22  -86.2%    2.7   22.3   25.0
1956-08-03 1957-10-22  1958-09-24  -21.5%    1.2    0.9    2.1
1961-12-12 1962-06-26  1963-09-03  -28.0%    0.5    1.2    1.7
1966-02-09 1966-10-07  1967-05-04  -22.2%    0.7    0.6    1.2
1968-11-29 1970-05-26  1972-03-06  -36.1%    1.5    1.8    3.3
1973-01-11 1974-10-03  1980-07-17  -48.2%    1.7    5.8    7.5
1980-11-28 1982-08-12  1982-11-03  -27.1%    1.7    0.2    1.9
1987-08-25 1987-12-04  1989-07-26  -33.5%    0.3    1.6    1.9
2000-03-24 2002-10-09  2007-05-30  -49.1%    2.5    4.6    7.2
2007-10-09 2009-03-09  2013-03-28  -56.8%    1.4    4.1    5.5
2020-02-19 2020-03-23  2020-08-18  -33.9%    0.1    0.4    0.5
2022-01-03 2022-10-12  2024-01-19  -25.4%    0.8    1.3    2.0

Median peak-to-new-high: all 2.1 yrs, since 1946 2.0 yrs
Median trough-to-old-high: all 1.5 yrs, since 1946 1.3 yrs
Median depth: -33.7%;  current close 7,720.39 (-1.3% from record)
Corrections of 10-20% from a record: 14, median 7 months peak to new high, longest 1.5 yrs
  a -10% fall needs +11% to get back
  a -20% fall needs +25% to get back
  a -34% fall needs +52% to get back
  a -50% fall needs +100% to get back
  a -57% fall needs +133% to get back
  a -86% fall needs +614% to get back

Since 1988, price-only vs dividends reinvested (years from peak to a new high):
  2000 crash: price 7.2 yrs, total return 6.1 yrs (depth -47.4%)
  2007 crash: price 5.5 yrs, total return 4.5 yrs (depth -55.3%)
  2020 crash: price 0.5 yrs, total return 0.5 yrs (depth -33.8%)
  2022 crash: price 2.0 yrs, total return 1.9 yrs (depth -24.5%)

What this means for your own portfolio

Three practical takeaways from the data:

1. Plan for the median, but survive the tail. Two years is the typical wait. Waits of 5.5 to 7.5 years have happened three times since 1973. Money you need within five years arguably shouldn’t depend on a quick rebound.
2. Keep contributing. The trough-to-old-high leg (median 1.5 years) is shorter than the full episode because shares bought near the bottom recover first. Our lump sum vs DCA test looks at what happens to a cash pile that waits on the sidelines instead.
3. Rebalancing helps in practice. Selling bonds to buy stocks during a crash shortens your personal recovery. The how often to rebalance backtest shows annual rebalancing was enough. For judging how bumpy a fund’s ride is beyond its drawdown, see Sharpe ratio vs Sortino ratio.

For context on today: the S&P 500 closed at 7,720.39 on October 29, 2026, 1.3% below its record close of 7,818.93 on October 6, 2026. That’s nowhere near crash territory. This is history, not a forecast, and not investment advice.

Limitations

• Only 12 crashes. The median moves if you add or drop one episode, and four of the 12 come from very different eras (pre-war, 1970s inflation, dot-com, 2008).
• Index, not your portfolio. A single stock, a sector fund, or a leveraged ETF can take far longer. The Nasdaq Composite took about 15 years to regain its March 2000 closing peak (April 2015, per Yahoo Finance ^IXIC), and plenty of individual stocks never did.
• Nominal for most rows. Apart from the 1929 check, the numbers ignore inflation, and inflation can flip the story. In Shiller’s monthly data the 1973 crash took 7.5 years on price, only 3.5 years with dividends reinvested (July 1976), but 12.0 years with dividends after inflation (January 1985).
• Closing prices. Intraday lows were slightly deeper, and the 20% line is a convention, not a law (1990 and 2018 both stopped just short at −19.9% and −19.8%).

Turn your crash notes into something people read

If you’ve been building this kind of analysis for yourself (drawdown rules, a rebalancing checklist, a crash playbook for a nervous spouse), it is close to being a short finance guide or a lead magnet for a newsletter. ImagineYourBook turns a prompt or your notes into a complete text draft with a cover, exported as Word and EPUB. If you already have a long write-up, its Manuscript Rewrite can reshape it into a shorter edition. The trial is $0 today but requires a card. It includes one 10,000-word Small Book, and the Author plan ($29.99/month) starts after 7 days unless you cancel before day 8. Check every number in the draft against your own script before you publish it.

Sources (checked October 30, 2026): Yahoo Finance: S&P 500 (^GSPC) history · Yahoo Finance: S&P 500 Total Return (^SP500TR) · Yahoo Finance: Nasdaq Composite (^IXIC) · Robert Shiller, U.S. stock market data (ie_data.xls) · yfinance on GitHub · ImagineYourBook pricing and trial terms. Scripts: recovery.py (shown above), shiller_1929.py. Not investment advice.

That difference is not academic. On ten years of real monthly data, Bitcoin and the Nasdaq-100 ETF QQQ finished with practically the same Sharpe ratio (0.98 vs 0.97), yet the Sortino ratio rated Bitcoin 2.08 and QQQ 1.65. Same “quality” on one ruler, a 0.43 gap on the other, and Bitcoin still fell −75.6% from peak along the way.

Below are the formulas, the numbers for eight assets, a short pandas script you can run on your own portfolio, and the one Sortino mistake that shows up in a lot of copy-paste code. (If your analysis ends up worth sharing, an AI book tool like ImagineYourBook can turn your notes into a draft investing ebook or lead magnet with Word/EPUB export; more on that at the end.)

The two formulas, side by side

Both ratios share the same numerator: the average return minus the risk-free rate (here, the 3-month Treasury bill from FRED’s TB3MS series, which averaged 2.43% a year over the test period).

• Sharpe ratio = average excess return ÷ standard deviation of excess returns. William Sharpe’s own 1994 restatement defines it this way.
• Sortino ratio = average excess return ÷ downside deviation. Downside deviation is the root-mean-square of the shortfalls below the target, where every month at or above the target counts as a shortfall of zero but still counts in the average (Rollinger and Hoffman, “Sortino: A ‘Sharper’ Ratio”).

I use monthly returns and annualize the usual way: multiply the monthly mean by 12 and the monthly deviation by √12.

A worked example: QQQ

For QQQ, October 2016 to September 2026:

• Average excess return: 18.47% a year
• Standard deviation of excess returns: 18.99%
• Downside deviation: 11.21%

So Sharpe = 18.47 ÷ 18.99 = 0.97, and Sortino = 18.47 ÷ 11.21 = 1.65. Same numerator, smaller denominator. That’s why Sortino ratios are almost always bigger than Sharpe ratios for assets that made money, and why “a Sortino of 1.6” and “a Sharpe of 1.0” can describe the same fund.

The data: 8 assets, 120 months

I pulled month-end adjusted closes (dividends reinvested) from Yahoo Finance via yfinance for SPY, QQQ, BTC-USD, GLD, SPLV (low-volatility S&P 500), AGG and TLT, plus a 60/40 SPY/AGG mix rebalanced monthly. The window covers 120 months, October 2016 to September 2026.

Three things stand out.

1. The Sortino-to-Sharpe multiple is different for every asset. It ranges from 1.32x (AGG) to 2.12x (Bitcoin). There is no conversion factor, so a fund page quoting Sortino can’t be lined up against another quoting Sharpe.

2. Skew drives the multiple. Bitcoin’s monthly returns had a positive skew of 0.62: its big months were up months. Sortino doesn’t penalize those, so its denominator shrinks much more than QQQ’s (skew −0.21) or SPY’s (skew −0.44). Gold, with a mildly positive skew (0.11), got the second-highest multiple, 1.72x.

3. Rankings can flip. By Sharpe, the 60/40 portfolio beats gold, 0.718 to 0.641. By Sortino, gold edges ahead, 1.105 to 1.098. Same data, same months, different winner.

Why Bitcoin and QQQ tie on Sharpe but not on Sortino

Bitcoin’s Sharpe beat QQQ’s by just 0.006. Its Sortino beat QQQ’s by 0.43. Here’s what each ratio is looking at:

Bitcoin’s volatility (74.1%) is almost four times QQQ’s (19.0%), and much of it comes from huge up months. Sharpe charges Bitcoin for every one of those grey bars. Sortino charges nothing for them, so Bitcoin’s risk measure drops from 74.1% to 34.9%, while QQQ’s drops from 19.0% to 11.2%.

Interesting detail: Bitcoin actually had more months below the T-bill rate, 53 of 120 versus 41 for QQQ. Sortino still likes it more, because downside deviation measures how deep the shortfalls are relative to the return, not how often they happen.

And here’s the catch that neither ratio shows: Bitcoin’s maximum drawdown was −75.6%, QQQ’s −32.6%. A high Sortino is not a promise of shallow losses. It says the typical monthly downside was small relative to the average return, not that the worst stretch was survivable.

Does the disagreement last? 85 rolling 3-year windows

One 10-year number can be a fluke, so I recomputed both ratios for Bitcoin and QQQ in every rolling 36-month window (85 windows, ending September 2019 to September 2026).

• Bitcoin beat QQQ on Sharpe in 41 of 85 windows.
• Bitcoin beat QQQ on Sortino in 56 of 85 windows.
• The two ratios disagreed on the winner in 15 windows, and in all 15, Sortino picked Bitcoin.

That’s the pattern you’d expect from a positively skewed asset. Sortino isn’t wrong here; it’s answering a different question. If upside surprises are fine with you, Sortino is the more honest score. If you’d have sold in a 75% crash, look at drawdown, not either ratio.

The Sortino mistake in a lot of Python code

A common shortcut is to take returns[returns < 0].std() as the downside risk. That’s not Sortino’s formula. It drops the good months from the average entirely (instead of counting them as zero shortfall) and measures spread around the mean of the bad months instead of distance below the target. The Red Rock paper linked above walks through this exact error.

How much does it matter on real data? With the shortcut, Bitcoin’s Sortino rises from 2.08 to 2.27 (+9.2%), while SPY’s falls from 1.34 to 1.21 (−9.1%). So the shortcut flatters one asset and penalizes another, in the same table.

If you build returns with pandas, Finxter’s guide to pandas pct_change() covers the first step; the script below does the rest correctly.

The Python script

It downloads the prices (or uses a cached copy), builds the 60/40 mix, and prints the full table, both rankings and the rolling comparison. Requirements: pip install yfinance pandas.

"""Sharpe ratio vs Sortino ratio on 10 years of real monthly returns (Oct 2016 to Sep 2026).
Prices: Yahoo Finance adjusted closes (dividends reinvested) via yfinance. Cash rate: FRED TB3MS.
pip install yfinance pandas"""
import numpy as np, pandas as pd

TICKERS = ["SPY", "QQQ", "BTC-USD", "GLD", "SPLV", "AGG", "TLT"]
START, END = "2016-09-30", "2026-09-30"

def load():
    try:  # cached copies used for the article
        adj = pd.read_pickle("src/raw_yf.pkl")["Adj Close"][TICKERS]
        tb = pd.read_csv("src/tb3ms.csv", parse_dates=[0], index_col=0).iloc[:, 0]
    except FileNotFoundError:
        import yfinance as yf
        adj = yf.download(TICKERS, start="2016-01-01", end="2026-10-01", auto_adjust=False, progress=False)["Adj Close"]
        tb = pd.read_csv("https://fred.stlouisfed.org/graph/fredgraph.csv?id=TB3MS", parse_dates=[0], index_col=0).iloc[:, 0]
    r = adj.resample("ME").last().loc[START:END].pct_change().iloc[1:]
    r["60/40"] = 0.6 * r["SPY"] + 0.4 * r["AGG"]          # rebalanced monthly
    tb.index = tb.index + pd.offsets.MonthEnd(0)
    rf = (tb / 100 / 12).reindex(r.index).ffill()           # monthly T-bill return
    return r, rf

def sharpe(r, rf):
    ex = r.sub(rf, axis=0)
    return ex.mean() / ex.std() * np.sqrt(12)

def downside_dev(r, rf):
    """Sortino's target downside deviation: RMS of the shortfalls below the target, over ALL months."""
    ex = r.sub(rf, axis=0)
    return np.sqrt((ex.clip(upper=0) ** 2).mean()) * np.sqrt(12)

def sortino(r, rf):
    return r.sub(rf, axis=0).mean() * 12 / downside_dev(r, rf)

def sortino_wrong(r, rf):
    """Common shortcut: std() of only the negative months. Not Sortino's formula."""
    ex = r.sub(rf, axis=0)
    return ex.mean() * 12 / (ex[ex < 0].std() * np.sqrt(12))

def rolling(r, rf, a="BTC-USD", b="QQQ", months=36):
    """Sharpe and Sortino of two assets in every rolling window (end month as index)."""
    rows = []
    for i in range(months, len(r) + 1):
        w, f = r.iloc[i - months:i][[a, b]], rf.iloc[i - months:i]
        sh, so = sharpe(w, f), sortino(w, f)
        rows.append({"end": w.index[-1], "sh_a": sh[a], "sh_b": sh[b], "so_a": so[a], "so_b": so[b]})
    return pd.DataFrame(rows).set_index("end")

def table(r, rf):
    wealth = (1 + r).cumprod()
    return pd.DataFrame({
        "CAGR": wealth.iloc[-1] ** (12 / len(r)) - 1,
        "Vol": r.std() * np.sqrt(12),
        "DownDev": downside_dev(r, rf),
        "Sharpe": sharpe(r, rf),
        "Sortino": sortino(r, rf),
        "Sortino/Sharpe": sortino(r, rf) / sharpe(r, rf),
        "Skew": r.skew(),
        "MaxDD": (wealth / wealth.cummax() - 1).min(),
        "Shortcut": sortino_wrong(r, rf),
    }).sort_values("Sharpe", ascending=False)

if __name__ == "__main__":
    r, rf = load()
    T = table(r, rf)
    print(f"{len(r)} months, {r.index[0]:%b %Y} to {r.index[-1]:%b %Y}; risk-free = 3-month T-bill (avg {rf.mean()*12:.2%}/yr)")
    print(f"{'':8}{'CAGR':>7}{'Vol':>7}{'DownDev':>8}{'Sharpe':>7}{'Sortino':>8}{'So/Sh':>6}{'Skew':>6}{'MaxDD':>7}{'Shortcut':>9}")
    for k, s in T.iterrows():
        print(f"{k:8}{s.CAGR:>7.1%}{s.Vol:>7.1%}{s.DownDev:>8.1%}{s.Sharpe:>7.2f}{s.Sortino:>8.2f}"
              f"{s['Sortino/Sharpe']:>6.2f}{s.Skew:>6.2f}{s.MaxDD:>7.1%}{s.Shortcut:>9.2f}")
    print("\nRank by Sharpe :", " > ".join(T.index))
    print("Rank by Sortino:", " > ".join(T.sort_values("Sortino", ascending=False).index))
    ex = r["QQQ"] - rf
    print(f"QQQ worked: mean excess {ex.mean()*12:.2%}/yr, std of excess {ex.std()*np.sqrt(12):.2%}, "
          f"downside dev {T.loc['QQQ', 'DownDev']:.2%} -> {ex.mean()*12/(ex.std()*np.sqrt(12)):.2f} and {T.loc['QQQ', 'Sortino']:.2f}")
    g, s = T.loc["GLD"], T.loc["60/40"]
    print(f"GLD vs 60/40: Sharpe {g.Sharpe:.3f} vs {s.Sharpe:.3f}, Sortino {g.Sortino:.3f} vs {s.Sortino:.3f}")
    b, q = T.loc["BTC-USD"], T.loc["QQQ"]
    print(f"BTC vs QQQ: Sharpe gap {b.Sharpe - q.Sharpe:.3f}, Sortino gap {b.Sortino - q.Sortino:.2f}, "
          f"down months {(r['BTC-USD'] < rf).sum()} vs {(r['QQQ'] < rf).sum()} of {len(r)}")
    R = rolling(r, rf)
    print(f"\n{len(R)} rolling 36-month windows (ending {R.index[0]:%b %Y} to {R.index[-1]:%b %Y}):")
    print(f"  BTC beats QQQ on Sharpe in {(R.sh_a > R.sh_b).sum()}, on Sortino in {(R.so_a > R.so_b).sum()}")
    dis = (R.sh_a > R.sh_b) != (R.so_a > R.so_b)
    print(f"  Sharpe and Sortino disagree on the winner in {dis.sum()} windows; Sortino picks BTC in {(dis & (R.so_a > R.so_b)).sum()} of them")

Output, as run for this article:

120 months, Oct 2016 to Sep 2026; risk-free = 3-month T-bill (avg 2.43%/yr)
           CAGR    Vol DownDev Sharpe Sortino So/Sh  Skew  MaxDD Shortcut
BTC-USD   63.6%  74.1%   34.9%   0.98    2.08  2.12  0.62 -75.6%     2.27
QQQ       20.9%  19.0%   11.2%   0.97    1.65  1.69 -0.21 -32.6%     1.55
SPY       15.2%  15.3%    9.7%   0.85    1.34  1.58 -0.44 -23.9%     1.21
60/40      9.6%  10.2%    6.7%   0.72    1.10  1.53 -0.42 -20.0%     1.02
GLD       11.7%  15.5%    8.9%   0.64    1.10  1.72  0.11 -23.8%     1.12
SPLV       7.7%  12.8%    8.8%   0.45    0.66  1.45 -0.62 -21.4%     0.62
AGG        1.1%   5.2%    3.9%  -0.23   -0.30  1.32 -0.03 -17.1%    -0.32
TLT       -2.8%  13.6%   10.0%  -0.32   -0.44  1.36  0.28 -47.6%    -0.54

Rank by Sharpe : BTC-USD > QQQ > SPY > 60/40 > GLD > SPLV > AGG > TLT
Rank by Sortino: BTC-USD > QQQ > SPY > GLD > 60/40 > SPLV > AGG > TLT
QQQ worked: mean excess 18.47%/yr, std of excess 18.99%, downside dev 11.21% -> 0.97 and 1.65
GLD vs 60/40: Sharpe 0.641 vs 0.718, Sortino 1.105 vs 1.098
BTC vs QQQ: Sharpe gap 0.006, Sortino gap 0.43, down months 53 vs 41 of 120

85 rolling 36-month windows (ending Sep 2019 to Sep 2026):
  BTC beats QQQ on Sharpe in 41, on Sortino in 56
  Sharpe and Sortino disagree on the winner in 15 windows; Sortino picks BTC in 15 of them

To use it on your own holdings, replace TICKERS with your funds, or swap r for your portfolio’s own monthly returns. If you want the benchmark side too, the earlier post on how to compare your portfolio to the S&P 500 builds a cash-flow-adjusted S&P 500 twin in Python.

Prefer not to maintain a script? PortfolioTracker24 is a free browser-based tracker that reports observed Sharpe and Sortino ratios and drawdown for your own trades, plus an S&P 500 and Bitcoin comparison. It needs no account or broker connection, keeps data in your browser and backs it up to Excel. Prices are entered manually, and it states that Sharpe and Sortino need a regular return series to be meaningful.

Which one should you use?

My rule of thumb after running these numbers:

1. Comparing diversified portfolios or index funds? Use Sharpe. Their returns are close enough to symmetric that the extra complexity of Sortino rarely changes the ranking. If you’re tuning a portfolio’s mix, rebalancing matters more; the how often to rebalance backtest found once a year enough on a 40-year 60/40.
2. Comparing skewed assets (crypto, trend-following, option-selling, single stocks)? Report both. A big Sortino-over-Sharpe gap tells you the return distribution is lopsided, which is information in itself.
3. Always add max drawdown. Neither ratio warned that Bitcoin’s worst fall was 2.3 times deeper than QQQ’s.
4. Use one convention throughout: same frequency, same risk-free rate, same window. A monthly Sharpe and a daily Sharpe of the same fund won’t match.
5. Be careful with negative ratios. AGG and TLT lost to cash over this decade, and their Sortino ratios (−0.30, −0.44) look “worse” than their Sharpe ratios. With a negative numerator, a smaller denominator makes the number more negative, so don’t read much into the ranking below zero.

Limitations

This is a 10-year sample that includes Bitcoin’s 2017 and 2020-21 booms and a sharp bond sell-off; another decade could rank things differently. Yahoo’s adjusted closes include fund fees and dividends, but not taxes or trading costs. The risk-free rate is the monthly T-bill, used both as the Sharpe baseline and the Sortino target; using 0% as the target would change the Sortino values. Past ratios don’t predict future returns. Nothing here is investment advice.

Takeaway

The Sharpe ratio vs Sortino ratio question has a short answer. Sharpe treats every swing as risk, while Sortino only counts the bad months. That’s why they agree on boring, symmetric portfolios and drift apart on lopsided ones, by 0.43 on the same Sharpe for Bitcoin and QQQ in this test. Calculate both with the right formula, quote them with max drawdown, and you’ll catch what a single number hides.

If you’ve got a spreadsheet full of analysis like this and want to turn it into something shareable, like a short investing guide, a newsletter lead magnet or a family-finance handbook, ImagineYourBook turns a prompt or notes into a complete text draft with a cover, which you then edit and export to Word or EPUB. The trial is $0 for 7 days and includes one 10,000-word Small Book; a card is required, and the Author plan is $29.99 a month after day 7 unless you cancel before day 8. Check the numbers in your draft against your own data before you publish.

Sources (checked October 29, 2026): Yahoo Finance price histories (SPY, QQQ, BTC-USD, GLD, SPLV, AGG, TLT) via yfinance · FRED: 3-Month Treasury Bill rate (TB3MS) · William F. Sharpe, The Sharpe Ratio (1994) · Rollinger & Hoffman, Sortino: A ‘Sharper’ Ratio (Red Rock Capital, PDF) · yfinance on GitHub · PortfolioTracker24 (features as described on its site) · ImagineYourBook pricing and trial terms. Script: sharpe_sortino.py (shown above). Not investment advice.

Never rebalancing is the one choice that really changes the result. Leave a “60/40” alone for 40 years and it ends up 93.9% stocks. You get a higher return, but you’re also holding a much riskier portfolio than the one you picked.

Below you’ll find the numbers, the charts, and the full Python script, so you can rerun it on your own funds.

The setup: two real funds, five rules

I wanted to test funds you could actually have owned, not idealized indexes:

• Stocks: VFINX (Vanguard 500 Index Fund, tracks the S&P 500)
• Bonds: VBMFX (Vanguard Total Bond Market Index Fund)

Both series are Yahoo Finance adjusted closes, so dividends and interest are reinvested and fund fees are already included. Each test starts with $10,000 at 60% stocks and 40% bonds on December 31, 1986, and runs on month-end data for 477 months through September 30, 2026. The 3-month T-bill rate from FRED is the cash rate for the Sharpe ratio.

The only thing that changes between tests is the rebalancing rule:

1. Never (buy and hold)
2. Monthly, back to 60/40 at every month-end
3. Quarterly, every March, June, September and December
4. Once a year, every December
5. 5-point band: check every month, but only trade when stocks drift more than 5 percentage points from 60% (below 55% or above 65%)

Here is the script. It needs pip install yfinance pandas. If you’re new to time-series resampling, Finxter’s pandas DataFrame resample() guide explains the resample("ME").last() line that turns daily prices into month-end prices.

"""How often to rebalance a 60/40 portfolio? Backtest on real fund data, Dec 1986 to Sep 2026.
Stocks: VFINX (Vanguard 500 Index, S&P 500). Bonds: VBMFX (Vanguard Total Bond Market Index).
Yahoo Finance adjusted closes (dividends reinvested, fund fees included), month-ends.
Cash rate for Sharpe: FRED TB3MS (3-month T-bill).  pip install yfinance pandas"""
import pandas as pd

START, END, W = "1986-12-31", "2026-09-30", 0.60

def load():
    try:  # cached copies used for the article
        adj = pd.read_pickle("src/raw_yf.pkl")["Adj Close"][["VFINX", "VBMFX"]]
        tb = pd.read_csv("src/tb3ms.csv", parse_dates=[0], index_col=0).iloc[:, 0]
    except FileNotFoundError:
        import yfinance as yf
        adj = yf.download(["VFINX", "VBMFX"], start="1986-12-01", auto_adjust=False, progress=False)["Adj Close"]
        tb = pd.read_csv("https://fred.stlouisfed.org/graph/fredgraph.csv?id=TB3MS", parse_dates=[0], index_col=0).iloc[:, 0]
    px = adj.resample("ME").last().loc[START:END]
    tb.index = tb.index + pd.offsets.MonthEnd(0)
    rf = (tb / 100 / 12).reindex(px.index).ffill()
    return px.pct_change().dropna(), rf.iloc[1:]

def backtest(r, rule, w=W, band=0.05, start_value=10_000):
    """rule: 'never' | 'monthly' | 'quarterly' | 'annual' | 'band'. Rebalance at month-end after returns."""
    s, b = start_value * w, start_value * (1 - w)
    vals, wts, n_reb, turnover = [], [], 0, 0.0
    for d, (rs, rb) in r.iterrows():
        s *= 1 + rs; b *= 1 + rb; v = s + b; eq = s / v
        due = {"never": False, "monthly": True, "quarterly": d.month in (3, 6, 9, 12),
               "annual": d.month == 12, "band": abs(eq - w) > band}[rule]
        if due and abs(eq - w) > 1e-12:
            turnover += abs(eq - w) * v; n_reb += 1
            s, b = v * w, v * (1 - w); eq = w
        vals.append(v); wts.append(eq)
    return pd.DataFrame({"value": vals, "equity_w": wts}, index=r.index), n_reb, turnover

def stats(df, rf, n_reb, turnover):
    v = df.value; m = v.pct_change().fillna(v.iloc[0] / 10_000 - 1); yrs = len(v) / 12
    ex = m - rf.values
    return dict(end=v.iloc[-1], cagr=(v.iloc[-1] / 10_000) ** (1 / yrs) - 1, vol=m.std() * 12 ** 0.5,
                max_dd=(v / v.cummax() - 1).min(), dd_at=(v / v.cummax() - 1).idxmin(),
                sharpe=ex.mean() / m.std() * 12 ** 0.5, rebalances=n_reb,
                turnover_yr=turnover / v.mean() / yrs, max_eq=df.equity_w.max(), end_eq=df.equity_w.iloc[-1])

RULES = {"never": "Never (buy & hold)", "monthly": "Monthly", "quarterly": "Quarterly",
         "annual": "Once a year (Dec)", "band": "When off by 5 points"}

def run():
    r, rf = load()
    res = {k: backtest(r, k) for k in RULES}
    return r, rf, res, {k: stats(df, rf, n, t) for k, (df, n, t) in res.items()}

def rolling(r, rf, years=10):
    """CAGR and max drawdown of each rule in every rolling `years` window (monthly starts)."""
    n, rows = years * 12, []
    for i in range(0, len(r) - n + 1):
        sub = r.iloc[i:i + n]; row = {"start": sub.index[0]}
        for k in ("never", "monthly", "annual", "band"):
            v = backtest(sub, k)[0].value
            row[k] = (v.iloc[-1] / 10_000) ** (1 / years) - 1; row[k + "_dd"] = (v / v.cummax() - 1).min()
        rows.append(row)
    return pd.DataFrame(rows).set_index("start")

def napkin_cost(turnover_yr, cost=0.002, value=100_000):
    """ASSUMPTION: each dollar traded costs `cost` (spread, fees or tax drag). Annual drag in $ on `value`."""
    return turnover_yr * cost * value

if __name__ == "__main__":
    r, rf, res, S = run()
    print(f"60/40 VFINX/VBMFX, $10,000 on {START}, month-end data to {END} ({len(r)} months)")
    print(f"{'Rule':<22}{'End value':>11}{'CAGR':>7}{'Vol':>7}{'MaxDD':>8}{'Sharpe':>7}{'Trades':>7}{'Turn/yr':>8}{'Max stock%':>11}")
    for k, s in S.items():
        print(f"{RULES[k]:<22}{s['end']:>11,.0f}{s['cagr']:>7.2%}{s['vol']:>7.2%}{s['max_dd']:>8.1%}{s['sharpe']:>7.2f}"
              f"{s['rebalances']:>7}{s['turnover_yr']:>8.1%}{s['max_eq']:>11.1%}")
    w, a = res["never"][0].equity_w, res["annual"][0].equity_w
    print(f"\nBuy & hold ends at {S['never']['end_eq']:.1%} stocks; it entered the Oct 2007 peak at {w.loc['2007-10-31']:.1%} stocks.")
    print(f"Buy & hold first passed 70% stocks in {w[w > .7].index[0]:%b %Y} and 80% in {w[w > .8].index[0]:%b %Y}.")
    print(f"Annual rebalancing still drifted between {a.min():.1%} ({a.idxmin():%b %Y}) and {a.max():.1%} stocks between Decembers.")
    print(f"All five rules hit their worst drawdown in {S['never']['dd_at']:%b %Y}.")
    R = rolling(r, rf)
    print(f"\n{len(R)} rolling 10-year windows (starts {R.index[0]:%b %Y} to {R.index[-1]:%b %Y}):")
    for k in ("monthly", "band"):
        g = R[k] - R["annual"]
        print(f"  {RULES[k]} minus annual CAGR: median {g.median()*100:+.2f} pts, range {g.min()*100:+.2f} to {g.max()*100:+.2f}")
    g = R["never"] - R["annual"]; dd = R["never_dd"] - R["annual_dd"]
    print(f"  Never minus annual CAGR: median {g.median()*100:+.2f} pts; never had the deeper drawdown in {(dd < 0).mean():.0%} of windows")
    print(f"\nNapkin (assumption: 0.2% cost per dollar traded, $100,000 portfolio):")
    for k in ("monthly", "quarterly", "annual", "band"):
        print(f"  {RULES[k]:<22} {napkin_cost(S[k]['turnover_yr']):>6,.0f} $/yr")

The result: how often matters less than whether

Output of python3 rebalance.py:

60/40 VFINX/VBMFX, $10,000 on 1986-12-31, month-end data to 2026-09-30 (477 months)
Rule                    End value   CAGR    Vol   MaxDD Sharpe Trades Turn/yr Max stock%
Never (buy & hold)        442,046 10.00% 11.75%  -38.7%   0.61      0    0.0%      93.9%
Monthly                   304,242  8.97%  9.54%  -32.5%   0.63    477    9.2%      60.0%
Quarterly                 313,794  9.06%  9.50%  -32.0%   0.64    159    6.1%      63.6%
Once a year (Dec)         312,520  9.05%  9.53%  -30.8%   0.64     39    3.3%      67.9%
When off by 5 points      325,566  9.16%  9.62%  -31.9%   0.65     26    3.6%      65.0%

Buy & hold ends at 93.9% stocks; it entered the Oct 2007 peak at 78.6% stocks.
Buy & hold first passed 70% stocks in Nov 1995 and 80% in Dec 1998.
Annual rebalancing still drifted between 47.9% (Nov 2008) and 67.9% stocks between Decembers.
All five rules hit their worst drawdown in Feb 2009.

358 rolling 10-year windows (starts Jan 1987 to Oct 2016):
  Monthly minus annual CAGR: median -0.11 pts, range -0.38 to +0.12
  When off by 5 points minus annual CAGR: median +0.03 pts, range -0.35 to +0.31
  Never minus annual CAGR: median -0.09 pts; never had the deeper drawdown in 73% of windows

Napkin (assumption: 0.2% cost per dollar traded, $100,000 portfolio):
  Monthly                    18 $/yr
  Quarterly                  12 $/yr
  Once a year (Dec)           7 $/yr
  When off by 5 points        7 $/yr

The three calendar rules are almost identical: 8.97% to 9.06% a year, about 9.5% volatility, and Sharpe ratios of 0.63 to 0.64. Rebalancing 12 times more often bought you nothing. Monthly came out a hair behind because it held exactly 60% stocks all the time. The yearly portfolio averaged 60.6% stocks because it drifted a little between Decembers, and in a market where stocks win, that small extra share earns a bit more.

The 5-point band came out slightly ahead, with the highest end value ($325,566), the best Sharpe (0.65) and the fewest trades (26). That edge is small and depends on the period. The steadier way to say it: a band rule gets you yearly-level risk control with even fewer trades.

This matches Vanguard’s much longer study (1926 to 2009). Its monthly-rebalanced 60/40 needed 1,008 rebalancing events and its annual one 83, with average returns of 8.5% and 8.6%. Vanguard’s conclusion was that annual or semiannual monitoring, with rebalancing at 5% thresholds, is a reasonable balance for most broadly diversified stock and bond portfolios.

The real choice: rebalance or let it drift

The never-rebalanced portfolio ended with $442,046, about $116,500 more than the best rebalanced one. So why rebalance at all?

Because by the end it wasn’t a 60/40 portfolio anymore. Stocks grow faster than bonds, so with no rebalancing the stock share keeps climbing:

It passed 70% stocks in November 1995 and 80% in December 1998. It went into the October 2007 market peak at 78.6% stocks, so the 2008 crash hit far harder than a 60/40 should. The worst drawdown was −38.7%, against −30.8% for the yearly rebalancer. Volatility was 11.75% vs 9.53%. On a risk-adjusted basis buy and hold came last (Sharpe 0.61).

Vanguard found the same pattern over 1926 to 2009. Its never-rebalanced 60/40 drifted to a maximum of about 99% stocks and earned a higher average return (9.1% vs 8.5% for monthly), with more risk (14.4% vs 12.1% standard deviation). The extra return is mostly payment for holding more stock than you signed up for.

Rolling 10-year windows: no lucky period

One 40-year run could just be luck, so the script also tests every rolling 10-year window: 358 of them, starting each month from January 1987 to October 2016.

• Monthly minus yearly: median −0.11 percentage points a year, never more than +0.12 better. Monthly almost never wins, and when it does, it wins by a rounding error.
• 5-point band minus yearly: median +0.03 points, range −0.35 to +0.31. That’s a coin flip.
• Never minus yearly: median −0.09 points, with swings from about −0.6 to +1.6. Buy and hold also had the deeper drawdown in 73% of the windows.

So over a typical decade, never rebalancing didn’t even reliably earn more. It took more risk for an uncertain reward. The 40-year advantage comes from the drift compounding over a very long bull run in stocks.

What about trading costs?

At these frequencies, the cost of trades is small. Annual rebalancing traded about 3.3% of the portfolio per year, and monthly about 9.2%. The napkin math below rests on a labeled assumption that each traded dollar costs 0.2% (spread, commissions or tax drag). Then a $100,000 portfolio pays about $18 a year for monthly rebalancing and $7 for yearly.

Taxes are the cost that actually matters. In a taxable account, every rebalance sells winners and can trigger capital gains, which is why Vanguard says annual rebalancing is likely preferred when taxes or substantial costs are involved. Three practical fixes:

1. Rebalance with cash flows. Put new contributions, dividends and interest into whichever side is underweight. Vanguard specifically recommends this to cut costs.
2. Rebalance inside tax-advantaged accounts (401(k), IRA or your country’s equivalent) where selling doesn’t create a tax bill.
3. Use the 5-point band so you only trade when the drift is big enough to matter.

A simple rebalancing routine

1. Pick a date you’ll remember, for example your birthday or the first weekend of January.
2. Check your current weights. If you track holdings by hand, PortfolioTracker24 is a free browser tracker that keeps your data on your machine (no account, no broker connection), shows allocation by value, and exports Excel backups.
3. If stocks are more than 5 points off target, rebalance, starting with new cash and then tax-advantaged accounts.
4. If they’re inside the band, do nothing. That’s the rule working, not you being lazy.

To check whether your mix is really beating the index, see how to compare your portfolio to the S&P 500 (with Python). If you’re about to put a lump sum to work before your first rebalance, the backtest in lump sum vs DCA on the S&P 500 is the companion read.

Turn your backtest into something you can share

Once you’ve run this on your own funds, you have original analysis: real numbers, charts and a clear rule. That’s good material for a short guide, a newsletter lead magnet, or a small ebook. ImagineYourBook is an AI book-writing tool that turns a prompt or your notes into a complete ~10,000-word draft with its own cover, with Word and EPUB export on paid plans. Paste in your results table and rules, then edit the draft so every number matches your script. If you plan to sell it on Kindle, run the price through Finxter’s KDP royalty calculator in Python first.

Limitations

• One stock fund, one bond fund, US only. International stocks, small caps or other bond types will drift at different speeds.
• Month-end data. A band rule checked daily would trade at slightly different points. Vanguard notes that threshold-only rules need daily monitoring.
• No taxes or trading costs in the backtest itself; the cost section above is assumption-based napkin math.
• The past isn’t a forecast. Stocks returned much more than bonds over 1987 to 2026. In a period where bonds keep up, the drift (and the gap from never rebalancing) would be smaller. Not investment advice.

The takeaway

How often to rebalance a portfolio: once a year, or whenever an asset class drifts more than 5 points off target. Monthly and quarterly rebalancing only added trades in 40 years of real fund data. Never rebalancing turned a 60/40 into a 94/6 portfolio and gave it the deepest crash. Set one date a year and use new cash first. And if your backtest turns into a guide worth sharing, ImagineYourBook can turn your notes into a first draft: the $0 trial includes one 10,000-word book, requires a card, and becomes $29.99 a month unless you cancel before day 8.

Sources (checked October 27, 2026): Yahoo Finance: VFINX historical data (via yfinance) · Yahoo Finance: VBMFX historical data (via yfinance) · Yahoo Help: adjusted close · FRED: 3-Month Treasury Bill rate (TB3MS) · Vanguard: Best practices for portfolio rebalancing (PDF) · AAII Journal: Best practices for portfolio rebalancing (Vanguard summary) · yfinance on GitHub · PortfolioTracker24 (features checked on its site) · ImagineYourBook pricing and trial terms. Script: rebalance.py (shown above). Napkin math is labeled as assumptions. Not investment advice.

That is the non-obvious part of the lump sum vs DCA S&P 500 question, and it changes what DCA is actually for. The short answer first: across 453 rolling start months (January 1988 to September 2025, dividends reinvested, idle cash earning T-bill interest), investing the lump sum at once beat DCA 64.7% of the time against a 3-month plan and 77.7% of the time against a 12-month plan. DCA did not lower your odds of a losing year in any meaningful way. What a long DCA did buy was a thinner tail: a 12-month plan cut the share of years that lost more than 20% from 4.4% to 1.5%. The median price of that was $4,677 per $100,000.

The numbers below come from a short Python script you can run yourself (full code further down). It builds on the shadow-benchmark idea from how to compare your portfolio to the S&P 500 the right way: same index, same dollars, only the timing changes.

A side note for readers who turn analyses like this into something publishable: a clean backtest plus your own rules is the skeleton of a short investing ebook or a newsletter lead magnet. If that’s your next step, ImagineYourBook is the AI book-writing tool I’d start with: it turns a prompt or your notes into a complete 10,000-word draft with its own cover, and paid plans export Word and EPUB for editing. You still check every number yourself, which you already do.

The setup: what “lump sum” and “DCA” mean here

Imagine $100,000 lands in your account at a month-end: a bonus, an inheritance, the sale of a business.

• Lump sum: buy the S&P 500 total-return index with all of it that day.
• DCA (dollar-cost averaging): invest 1/3, 1/6 or 1/12 of it at each month-end, starting that day. The cash still waiting earns the 3-month T-bill rate (FRED series TB3MS), so DCA is not handicapped by idle cash earning zero.
• Scorecard: compare both after exactly 12 months, the same horizon Vanguard’s 2023 study uses.

Data: Yahoo Finance’s ^SP500TR, the S&P 500 with dividends reinvested, month-end closes from January 1988 to September 2026. That gives 453 start months, each with a full year to measure. One useful detail: once the DCA plan is fully invested, both portfolios hold the same index, so whatever percentage gap exists at month 12 stays locked in for good. Measuring at one year is not a short-term trick. It is the permanent result.

Result 1: lump sum wins most of the time, and the gap grows with DCA length

The 3-month row is the one Vanguard uses as its base case. Vanguard found that lump sum beat cost averaging 68% of the time on the MSCI World index (1976–2022), with a range of 61.6% to 73.7% across markets and split lengths. My 64.7% on the S&P 500 sits inside that range, which is a good sanity check for the script.

The pattern is simple: every extra month in cash is a month without the equity risk premium. Stretch the DCA from 3 to 12 months and lump sum’s win rate climbs from 64.7% to 77.7%, while the median edge grows from 1.08% to 4.24%.

The chart also shows that DCA’s wins are not rare flukes. They cluster in exactly the years you remember: 2000–2002 and 2007–2008. Start a 12-month DCA in August 2008 and your $100,000 was worth $112,829 a year later, while the lump sum sat at $81,747, a $31,082 difference. Start in February 2009, near the bottom, and the lump sum was ahead by $36,295.

On average the two sides win by similar amounts: $7,895 per $100,000 when lump sum wins, $7,190 when DCA wins. So the decision is about how often, and lump sum wins about three times out of four over 12 months.

Result 2: DCA does not lower the odds of a losing year

This is the convention-breaking part. The usual pitch for DCA is “you won’t lose money if the market drops right after you invest.” Count the losing years:

• Lump sum: down after one year in 74 of 453 windows (16.3%).
• 3-month DCA: down in 75 (16.6%).
• 6-month DCA: down in 74 (16.3%).
• 12-month DCA: down in 72 (15.9%).

That’s a difference of one or two windows out of 453, which is noise. The reason is simple once you look at it: a bear market that lasts a year (2001, 2008) pulls down money invested in month 3 almost as much as money invested in month 1. And in flat years, DCA can buy after a small rise and end slightly below zero while the lump sum ends slightly above it.

The animation builds the 12-month comparison start month by start month. Watch the running win rate: it climbs to about 85% by the end of the 1990s, slides to about 71% by 2002 as the dot-com and 2008 starts pile up (lump sum won only 57.5% of the 2000s starts), then recovers to 77.7%.

Result 3: what DCA actually buys is a thinner tail

If DCA doesn’t prevent losing years, what does it do? It makes the bad losing years less bad, but only if you spread it out long enough.

• The worst lump-sum year (start February 2008) lost 43.3%. The worst 12-month DCA year lost 33.3%.
• Lump sum lost more than 20% in 4.4% of windows (20 of 453). The 12-month DCA did so in 1.5% (7 windows).
• A 3-month DCA barely moved the tail: 4.0%, and its worst year (−43.9%) was no better than the lump sum’s.

So think of DCA as an insurance policy against the one-in-twenty disaster year, with a premium you pay in the other nineteen. The premium is not small.

The compounding napkin math: what the premium costs over 20 years

The median 12-month DCA trailed the lump sum by $4,677 per $100,000 after one year. Because both portfolios are fully invested from then on, that gap compounds along with everything else.

The two right-hand columns rest on an assumption, not data: both portfolios then grow at 7% a year with no taxes, fees or new deposits. Under that assumption the median 12-month DCA costs about $16,915 by year 20. The 3-month version costs about $4,317. Neither is a forecast. The point is the ratio: you pay roughly four times more for the 12-month plan, and it’s the only one that meaningfully cut the tail.

If you’re doing similar planning for a fixed goal, the same compounding logic is in this Python plan for having $70k for a kid at 21.

The Python script

It uses only pandas and yfinance. Month-end resampling is one line (see Finxter’s pandas resample() guide if that’s new). Swap ^SP500TR for any ticker, or change n to test a 9-month plan.

"""Lump sum vs DCA on the S&P 500 (total return), every rolling start month since 1988.
Data: Yahoo Finance ^SP500TR (dividends reinvested) month-end closes; FRED TB3MS (3-month T-bill) for idle DCA cash.
pip install yfinance pandas"""
import pandas as pd

def load(end="2026-09-30"):
    try:  # cached copies used for the article
        px = pd.read_pickle("src/SP500TR.pkl")["Close"].squeeze()
        tb = pd.read_csv("src/tb3ms.csv", parse_dates=[0], index_col=0)["TB3MS"]
    except FileNotFoundError:
        import yfinance as yf
        px = yf.download("^SP500TR", start="1988-01-01", auto_adjust=False, progress=False)["Close"].squeeze()
        tb = pd.read_csv("https://fred.stlouisfed.org/graph/fredgraph.csv?id=TB3MS", parse_dates=[0], index_col=0)["TB3MS"]
    m = px.resample("ME").last().loc[:end]
    tb.index = tb.index + pd.offsets.MonthEnd(0)
    rf = (tb / 100 / 12).reindex(m.index).ffill()      # monthly T-bill yield on cash waiting to be invested
    return m, rf

def simulate(m, rf, n=12, horizon=12):
    """$1 at month-end t. Lump sum: all in at t. DCA: 1/n at t, t+1, ..., t+n-1; the rest earns T-bills.
    Both are valued at t+horizon (horizon >= n, so the DCA is fully invested by then)."""
    P, R, rows = m.values, rf.values, []
    for t in range(len(P) - horizon):
        cash, units = 1.0, 0.0
        for k in range(n):
            units += (1 / n) / P[t + k]; cash -= 1 / n
            cash *= 1 + R[t + k]
        rows.append((m.index[t], P[t + horizon] / P[t], units * P[t + horizon] + cash))
    df = pd.DataFrame(rows, columns=["start", "lump", "dca"]).set_index("start")
    df["gap"] = df.lump / df.dca - 1          # > 0: lump sum ended ahead
    return df

def summary(df):
    return dict(windows=len(df), lump_wins=(df.gap > 0).mean(), median_gap=df.gap.median(), mean_gap=df.gap.mean(),
                lump_down=(df.lump < 1).mean(), dca_down=(df.dca < 1).mean(),
                lump_down20=(df.lump < 0.8).mean(), dca_down20=(df.dca < 0.8).mean(),
                lump_worst=df.lump.min() - 1, dca_worst=df.dca.min() - 1, lump_worst_at=df.lump.idxmin(),
                best_dca_win=-df.gap.min(), best_dca_win_at=df.gap.idxmin(), best_lump_win=df.gap.max(), best_lump_win_at=df.gap.idxmax(),
                avg_lump_win=df.gap[df.gap > 0].mean(), avg_dca_win=-df.gap[df.gap < 0].mean())

def napkin(df, amount=100_000, growth=0.07, years=20):
    """ASSUMPTION-BASED: median dollar gap after year 1, then both portfolios grow at an assumed `growth` a year.
    After the DCA is fully invested both hold the same index, so the percentage gap never closes."""
    gap1 = ((df.lump - df.dca) * amount).median()
    return gap1, gap1 * (1 + growth) ** (years - 1)

def run():
    m, rf = load()
    out = {n: simulate(m, rf, n=n, horizon=12) for n in (3, 6, 12)}
    return m, rf, out, {n: summary(d) for n, d in out.items()}

if __name__ == "__main__":
    m, rf, out, S = run()
    print(f"S&P 500 total return, month-ends {m.index[0]:%b %Y} to {m.index[-1]:%b %Y}; idle cash earns 3-month T-bills")
    print(f"{'DCA over':<10}{'windows':>8}{'LS wins':>9}{'LS edge':>8}{'LS down':>9}{'DCA down':>9}{'LS<-20%':>9}{'DCA<-20%':>9}{'LS worst':>10}{'DCA worst':>10}")
    for n, s in S.items():
        print(f"{n:>2} months {s['windows']:>8}{s['lump_wins']:>9.1%}{s['median_gap']:>8.2%}{s['lump_down']:>9.1%}{s['dca_down']:>9.1%}"
              f"{s['lump_down20']:>9.1%}{s['dca_down20']:>9.1%}{s['lump_worst']:>10.1%}{s['dca_worst']:>10.1%}")
    d = out[12]
    print("\n12-month DCA, lump-sum win rate by start decade:")
    for dec, g in d.groupby(d.index.year // 10 * 10).gap:
        print(f"  {dec}s: {(g > 0).mean():.1%} of {len(g)} starts")
    s = S[12]
    diff = (d.lump - d.dca) * 100_000
    for label, t in (("Best DCA start", diff.idxmin()), ("Best lump-sum start", diff.idxmax())):
        r = d.loc[t]
        print(f"{label} ({t:%b %Y}), $100,000: lump sum ${r.lump*1e5:,.0f} vs DCA ${r.dca*1e5:,.0f}")
    g1, g20 = napkin(d)
    print(f"Napkin ($100,000, median start): 12-month DCA trails by ${g1:,.0f} after year 1; at an assumed 7%/yr that is ${g20:,.0f} by year 20")
    print(f"Average edge per $100,000: ${diff[diff > 0].mean():,.0f} when lump sum wins, ${-diff[diff < 0].mean():,.0f} when DCA wins")

Output on data through September 30, 2026:

S&P 500 total return, month-ends Jan 1988 to Sep 2026; idle cash earns 3-month T-bills
DCA over   windows  LS wins LS edge  LS down DCA down  LS<-20% DCA<-20%  LS worst DCA worst
 3 months      453    64.7%   1.08%    16.3%    16.6%     4.4%     4.0%    -43.3%    -43.9%
 6 months      453    68.9%   2.20%    16.3%    16.3%     4.4%     2.2%    -43.3%    -43.2%
12 months      453    77.7%   4.24%    16.3%    15.9%     4.4%     1.5%    -43.3%    -33.3%

12-month DCA, lump-sum win rate by start decade:
  1980s: 75.0% of 24 starts
  1990s: 87.5% of 120 starts
  2000s: 57.5% of 120 starts
  2010s: 85.0% of 120 starts
  2020s: 84.1% of 69 starts
Best DCA start (Aug 2008), $100,000: lump sum $81,747 vs DCA $112,829
Best lump-sum start (Feb 2009), $100,000: lump sum $153,618 vs DCA $117,323
Napkin ($100,000, median start): 12-month DCA trails by $4,677 after year 1; at an assumed 7%/yr that is $16,915 by year 20
Average edge per $100,000: $7,895 when lump sum wins, $7,190 when DCA wins

Three choices in the script matter. If you change them, your numbers will move:

1. Total return, not price. ^GSPC ignores dividends: over this period it compounded at 9.2% a year versus 11.5% with dividends, and a lower stock return flatters DCA.
2. Cash earns T-bills. Leaving DCA cash at 0% makes it look worse than it is.
3. Same 12-month scorecard. Comparing DCA after 12 months with the lump sum after 3 is the most common mistake in DCA backtests.

So which should you do?

My reading of the data:

• If you can stomach a 40% drop in year one without selling, invest the lump sum. It won 65–78% of the time, and the median edge compounds.
• If the honest answer is “I would panic-sell,” a 6- to 12-month DCA is a rational premium. A plan you stick with beats a better plan you abandon in month four. Vanguard makes the same point: cost averaging beat staying in cash 69% of the time.
• Skip the 3-month compromise if your goal is protection. It cost $1,194 per $100,000 at the median and did not cut losing years or the worst case. It mostly buys a feeling.

Whatever you pick, track it against a same-dates S&P 500 benchmark so you see the real cost of your timing. The free browser-based PortfolioTracker24 does this with an “S&P Equivalent” built from your own purchase dates. It needs no account or broker connection, your trades stay in your browser, and it keeps Excel backups.

Limits: one index, one country, 38 years of starts that overlap heavily (453 windows are not 453 independent trials), and no taxes or fees. Past returns don’t guarantee future ones, and this is not investment advice.

The takeaway

Lump sum beat DCA on the S&P 500 in roughly three of four start months, and DCA did not reduce the chance of a losing year at all. Its only real job is shrinking the worst case, and that takes 6–12 months of spreading, at a median cost of $2,442–$4,677 per $100,000. Pick it deliberately, as insurance, or not at all.

And if your notes on this are turning into a guide of your own, say an investing primer for your newsletter, you can draft it with ImagineYourBook. The trial is $0 today with a card on file and includes one 10,000-word book; the first $29.99 charge comes after 7 days unless you cancel before day 8. Then check every figure against your own script before anyone reads it.

Sources (checked October 25, 2026): Yahoo Finance: S&P 500 Total Return (^SP500TR) history · Yahoo Finance: S&P 500 price index (^GSPC) · FRED: 3-Month Treasury Bill secondary market rate (TB3MS) · Vanguard Research (Feb 2023): Cost averaging: invest now or temporarily hold your cash? · Vanguard UK: The truth about cost averaging (61.6%–73.7% range) · yfinance on GitHub · PortfolioTracker24 (features checked on its site) · ImagineYourBook pricing and trial terms. Script: lump_sum_vs_dca.py (shown above). Not investment advice.

The catch: the two most common ways people run that comparison give the wrong answer. I tested both on five years of real price data, from October 22, 2021 to October 22, 2026, using Yahoo Finance closes and a short pandas script. In the worked example below, a portfolio that looks 1.5 points ahead of the S&P 500 is really 3.7 points a year behind it.

Below you’ll find the three traps, the fix (a “shadow S&P 500” that buys the index with your exact deposits on your exact dates), and a Python script you can point at your own trades.

One side note for readers who write about money: once you’ve run this analysis, you already have the outline of a useful investing guide or newsletter lead magnet. ImagineYourBook is an AI book-writing tool that turns a prompt or your notes into a ~10,000-word draft with Word and EPUB export, so your findings can become a short ebook you then fact-check and edit.

The setup: one example portfolio, five real years

To keep the numbers concrete, I used an example three-fund portfolio. These weights are an assumption for illustration, not a recommendation:

• 60% VTI (US total stock market)
• 20% VXUS (international stocks)
• 20% BND (US bonds)

The benchmark is SPY, an S&P 500 ETF, using Yahoo’s Adjusted Close. Yahoo documents that adjusted close is “the closing price after adjustments for all applicable splits and dividend distributions”, so it behaves like a dividends-reinvested total-return series. For the risk-free rate in the Sharpe ratio, I used the daily 3-month Treasury bill yield (FRED series DTB3), which averaged about 3.8% over the window.

Here is what the script printed:

Period: 2021-10-22 to 2026-10-22 (1255 trading days)
                          Total    CAGR     Vol  Sharpe  Sortino   Max DD
60/20/20 portfolio        52.2%    8.8%   13.9%    0.40     0.58   -24.0%
S&P 500 (SPY, TR)         80.3%   12.5%   17.2%    0.55     0.80   -24.5%
S&P 500 price only        68.6%   11.0%   17.0%    0.48     0.68   -25.4%
Bitcoin                   34.0%    6.0%   51.7%    0.30     0.44   -76.6%
Dividend gap (SPY TR - price index): +11.6% points
Beta vs SPY: 0.79, correlation: 0.98; portfolio max DD on 2022-10-14, SPY on 2022-10-12
$500/month x 61 = $30,500 deposited
  portfolio $43,385 (gain/deposits 42.2%, IRR 14.0%)
  shadow SPY $47,523 (gain/deposits 55.8%, IRR 17.7%)

Trap 1: comparing against the price-only S&P 500

The number most people Google is the S&P 500 index level (ticker ^GSPC). It ignores dividends.

Over these five years, the price index rose 68.6%. SPY with dividends reinvested rose 80.3%. That is an 11.6-point gap, and it’s almost entirely dividends (SPY’s small fund fee is already netted out of its adjusted close, so the true index-with-dividends gap is slightly larger).

If your brokerage statement counts your dividends but you compare it with the bare index level, you hand yourself 11.6 free points. Always benchmark against a total-return series.

Trap 2: comparing your money-weighted return to the index’s lump-sum return

Most real investors don’t drop one lump sum on day one. They add money every month. So let’s assume $500 on the first trading day of every month, split 60/20/20, for 61 months. That’s $30,500 deposited.

By October 22, 2026, the portfolio was worth $43,385. Its internal rate of return (IRR, a money-weighted return that accounts for when each dollar went in) was 14.0% a year.

Now the common mistake: you look up “S&P 500 five-year annualized return”, find something like SPY’s 12.5% CAGR from our table, and conclude you won by 1.5 points.

But that 12.5% belongs to a single lump sum invested in October 2021, right before the 2022 bear market. Your monthly deposits bought a lot of cheap shares during that drop, which is why your money-weighted figure looks so good. The comparison mixes two different cash-flow patterns. Wikipedia’s time-weighted return article walks through exactly this “problem of external flows”: deposits and withdrawals distort a naive return.

The fix: a shadow S&P 500

Give the S&P 500 the same deal you got. Every time you bought, pretend you bought the same dollar amount of SPY on the same day. Then compare ending values and IRRs.

The shadow S&P 500 ended at $47,523, an IRR of 17.7% a year. Your real gap is −3.7 points a year, or $4,139 on $30,500 of deposits. The fake +1.5-point win was really a 3.7-point loss.

The animation shows the gap opening up month by month: both lines got the same 61 deposits, so the only difference is what the money bought.

Trap 3: ignoring risk (and why “lower risk” didn’t help here)

Return alone isn’t the whole story. A portfolio with 20% bonds should be steadier than 100% stocks, so a fair comparison also looks at risk.

• Volatility: 13.9% for the portfolio vs 17.2% for SPY.
• Beta vs SPY: 0.79, correlation 0.98. The portfolio moved with the market, just a bit less.
• Max drawdown: −24.0% vs −24.5% for SPY, both bottoming in mid-October 2022.
• Sharpe ratio: 0.40 vs 0.55. Sortino: 0.58 vs 0.80.

That drawdown result surprised me. The bonds barely cushioned the crash because BND itself fell 13.1% in calendar 2022 in this data, and VXUS fell 16.1%. So in this particular window the portfolio had nearly the same worst drop and a lower return. Even risk-adjusted, SPY won.

Treat that as a statement about this five-year window, not a law. William Sharpe’s own 1994 paper on the Sharpe ratio separates the ex post (historic) ratio from the ex ante (expected) one. What we computed is ex post: a description of this sample, not a promise about the next five years.

For completeness, the script also runs Bitcoin over the same trading days: +34.0% total with a −76.6% max drawdown. The October 2021 start date sits close to a peak, which shows how much your start date shapes any “vs. benchmark” claim.

The napkin math: why a 3.7-point gap matters more than it sounds

Five years in, the gap is “only” $4,139. Compounding turns that into real money. Assumptions (not forecasts): $500 a month for 20 years, a constant 7% baseline return, and a gap that stays the same every year.

A persistent 3.7-point shortfall on a 7% baseline leaves you about $138,000 (54%) behind after 20 years on the same $120,000 of deposits. That’s why the shadow benchmark is worth the 10 minutes.

The Python script

This is the exact script that produced every number and chart in this post. It needs pandas, numpy and yfinance; save the FRED DTB3 CSV next to it in src/dtb3.csv. If you’re new to time-series tricks in pandas, the Finxter guide on pandas rolling windows pairs well with the drawdown code (value / value.cummax() - 1).

"""Compare a portfolio to the S&P 500 the right way (Finxter, 2026-10-23).
Data: Yahoo Finance daily closes via yfinance (Adj Close = dividends reinvested), FRED DTB3 3-month T-bill."""
import os, numpy as np, pandas as pd
HERE = os.path.dirname(os.path.abspath(__file__))
START, END = "2021-10-22", "2026-10-22"          # five years, last full close before publishing
WEIGHTS = {"VTI": 0.60, "VXUS": 0.20, "BND": 0.20}  # ASSUMPTION: an example three-fund portfolio
MONTHLY = 500                                       # ASSUMPTION: $500 bought on the first trading day of each month

def load():
    p = os.path.join(HERE, "src", "raw_yf.pkl")
    if os.path.exists(p): raw = pd.read_pickle(p)
    else:
        import yfinance as yf
        raw = yf.download(["SPY", "VTI", "VXUS", "BND", "^GSPC", "BTC-USD"], start="2021-10-01", auto_adjust=False, progress=False)
    adj, close = raw["Adj Close"], raw["Close"]
    days = adj["SPY"].dropna().index                      # stock-market trading days only
    adj, close = adj.loc[days].loc[START:END], close.loc[days].loc[START:END]
    adj["BTC-USD"] = raw["Adj Close"]["BTC-USD"].reindex(adj.index)
    rf = pd.read_csv(os.path.join(HERE, "src", "dtb3.csv"), index_col=0, parse_dates=True, na_values=".")["DTB3"]
    rf = rf.reindex(adj.index).ffill() / 100              # annual T-bill yield
    return adj, close, rf

def portfolio_index(adj, weights=WEIGHTS):
    """Buy-and-hold: invest weights once at START, never rebalance. Value of $1."""
    norm = adj[list(weights)] / adj[list(weights)].iloc[0]
    return sum(w * norm[t] for t, w in weights.items())

def stats(value, rf):
    r = value.pct_change().dropna()
    years = (value.index[-1] - value.index[0]).days / 365.25
    total = value.iloc[-1] / value.iloc[0] - 1
    cagr = (1 + total) ** (1 / years) - 1
    excess = r - rf.loc[r.index] / 252
    sharpe = excess.mean() / r.std() * np.sqrt(252)
    downside = np.sqrt((np.minimum(excess, 0) ** 2).mean()) * np.sqrt(252)
    sortino = excess.mean() * 252 / downside
    dd = value / value.cummax() - 1
    return dict(total=total, cagr=cagr, vol=r.std() * np.sqrt(252), sharpe=sharpe, sortino=sortino,
                max_dd=dd.min(), dd_date=dd.idxmin(), drawdown=dd)

def beta(value, bench):
    a, b = value.pct_change().dropna(), bench.pct_change().dropna()
    return a.cov(b) / b.var(), a.corr(b)

def contributions(adj, weights=WEIGHTS, monthly=MONTHLY):
    """Buy $monthly on the first trading day of each month; same dollars, same dates into SPY (the 'shadow S&P 500')."""
    firsts = adj.groupby(adj.index.to_period("M")).head(1).index
    port_sh = {t: 0.0 for t in weights}; spy_sh = 0.0; flows = []
    for d in firsts:
        for t, w in weights.items(): port_sh[t] += monthly * w / adj.at[d, t]
        spy_sh += monthly / adj.at[d, "SPY"]; flows.append((d, -monthly))
    last = adj.index[-1]
    port_val = sum(s * adj.at[last, t] for t, s in port_sh.items()); spy_val = spy_sh * adj.at[last, "SPY"]
    return dict(deposits=monthly * len(firsts), n=len(firsts), port_val=port_val, spy_val=spy_val, flows=flows, last=last)

def xirr(flows, final_date, final_value):
    cf = flows + [(final_date, final_value)]
    t0 = cf[0][0]; ts = np.array([(d - t0).days / 365.25 for d, _ in cf]); v = np.array([x for _, x in cf])
    lo, hi = -0.99, 1.0
    for _ in range(200):
        mid = (lo + hi) / 2
        if (v / (1 + mid) ** ts).sum() > 0: lo = mid
        else: hi = mid
    return mid

def run():
    adj, close, rf = load()
    port = portfolio_index(adj); spy = adj["SPY"] / adj["SPY"].iloc[0]
    gspc = close["^GSPC"] / close["^GSPC"].iloc[0]; btc = adj["BTC-USD"] / adj["BTC-USD"].iloc[0]
    S = {k: stats(v, rf) for k, v in dict(portfolio=port, spy=spy, gspc=gspc, btc=btc).items()}
    b, c = beta(port, spy)
    C = contributions(adj)
    C["port_irr"] = xirr(C["flows"], C["last"], C["port_val"]); C["spy_irr"] = xirr(C["flows"], C["last"], C["spy_val"])
    return dict(adj=adj, close=close, rf=rf, port=port, spy=spy, gspc=gspc, btc=btc, S=S, beta=b, corr=c, C=C)

if __name__ == "__main__":
    R = run(); S, C = R["S"], R["C"]
    print(f"Period: {R['adj'].index[0].date()} to {R['adj'].index[-1].date()} ({len(R['adj'])} trading days)")
    print(f"{'':22}{'Total':>9}{'CAGR':>8}{'Vol':>8}{'Sharpe':>8}{'Sortino':>9}{'Max DD':>9}")
    for k, lab in (("portfolio", "60/20/20 portfolio"), ("spy", "S&P 500 (SPY, TR)"), ("gspc", "S&P 500 price only"), ("btc", "Bitcoin")):
        s = S[k]; print(f"{lab:22}{s['total']:>9.1%}{s['cagr']:>8.1%}{s['vol']:>8.1%}{s['sharpe']:>8.2f}{s['sortino']:>9.2f}{s['max_dd']:>9.1%}")
    print(f"Dividend gap (SPY TR - price index): {S['spy']['total']-S['gspc']['total']:+.1%} points")
    print(f"Beta vs SPY: {R['beta']:.2f}, correlation: {R['corr']:.2f}; portfolio max DD on {S['portfolio']['dd_date'].date()}, SPY on {S['spy']['dd_date'].date()}")
    print(f"${MONTHLY}/month x {C['n']} = ${C['deposits']:,} deposited")
    print(f"  portfolio ${C['port_val']:,.0f} (gain/deposits {C['port_val']/C['deposits']-1:.1%}, IRR {C['port_irr']:.1%})")
    print(f"  shadow SPY ${C['spy_val']:,.0f} (gain/deposits {C['spy_val']/C['deposits']-1:.1%}, IRR {C['spy_irr']:.1%})")

def napkin_fv(annual_rate, years, monthly=MONTHLY):
    """ASSUMPTION-only napkin math: $monthly at the start of each month, constant annual_rate. Not a forecast."""
    m = (1 + annual_rate) ** (1 / 12) - 1
    return sum(monthly * (1 + m) ** (years * 12 - k) for k in range(years * 12))

To use your own trades, replace WEIGHTS and contributions() with your real buy dates and dollar amounts. The shadow logic stays the same: same dollars, same days, into SPY.

The no-code option

If you’d rather not maintain a script, PortfolioTracker24 is a free, private, browser-based stock and ETF tracker that uses the same idea: its “S&P Equivalent” and “BTC Equivalent” figures replay your dated purchases and sale proceeds into the benchmark. Trades stay in your browser (no account, no broker connection), backups are Excel files, and it reports observed Sharpe, Sortino and drawdown. Be aware of its stated limits: you update prices manually, and cash, dividends, tax and FX aren’t modeled. A $39 one-time Windows edition exists for offline use. For a broader comparison, see Finxter’s roundup of free investment portfolio trackers.

Your 5-step checklist

1. Use a total-return benchmark (SPY or VOO adjusted close), never the bare ^GSPC level.
2. List every deposit and withdrawal with its date and amount.
3. Build the shadow S&P 500: buy the benchmark with the same dollars on the same dates.
4. Compare like with like: your IRR vs the shadow’s IRR, your ending value vs the shadow’s ending value.
5. Add risk: volatility, max drawdown, Sharpe and beta, and say which window you measured.

Limitations

• One example portfolio and one five-year window. A different start date can flip the result.
• Taxes, trading costs and FX aren’t modeled. Bitcoin is sampled on stock-market trading days only.
• Yahoo adjusted closes assume dividends are reinvested on the ex-date at that day’s price.
• Nothing here is investment advice.

Want more Python-for-money projects? The KDP royalty calculator in Python applies the same “script the real rules” approach to book income, and buying and holding tech stocks runs a longer buy-and-hold thought experiment.

The takeaway

To compare your portfolio to the S&P 500 honestly, give the index the same deal you got: same dollars, same dates, dividends included. In this five-year test, that one change turned a “+1.5-point win” into a 3.7-point-a-year loss. Run the shadow benchmark once a year, and you’ll know whether your stock picking is earning its keep.

And if your analysis turns into a story worth sharing, say a “What I learned benchmarking my portfolio” guide for your newsletter, you can draft it with ImagineYourBook. The 7-day trial is $0 today with a card required and includes one 10,000-word Small Book; the first $29.99 charge comes after 7 days unless you cancel before day 8. Check the numbers, add your own charts, and publish it as yours.

Sources (checked October 23, 2026): Yahoo Finance: SPY historical data (daily prices via yfinance) · Yahoo Help: what is the adjusted close? · FRED: 3-Month Treasury Bill secondary market rate (DTB3) · yfinance on GitHub · Wikipedia: time-weighted return and the problem of external flows · William F. Sharpe: The Sharpe Ratio (1994) · PortfolioTracker24 (feature claims checked on its site) · ImagineYourBook pricing and FAQ. Script: compare_to_sp500.py (shown above). Not investment advice.