How the simulation works

The FIRE simulator doesn't apply a closed formula to an average return. It runs thousands of Monte Carlo simulations, each with a different market sequence and a different lifespan, and reports how often the plan held.

Methodology updated — August 2026. The engine now simulates each asset separately, month by month, with per-asset cost basis and forward rebalancing (it used to collapse the portfolio into one return series). If you saved a result before this change, re-running it may give a slightly different success probability.

Monte Carlo simulations

Each simulation resamples your portfolio's real historical returns, asset by asset, and projects them forward. These aren't invented returns or a theoretical distribution: they are the months your assets actually lived through, recombined.

Sampling happens in continuous 3-year blocks (block bootstrapping) rather than month by month, and each block is a slice of the whole portfolio at once — the same calendar months for every asset. This preserves two things that matter:

• Serial correlation. Crisis sequences stay intact, with the consecutive months of decline and recovery typical of 2008 or COVID.
• Cross-asset correlation. Stocks and bonds moved together (or apart) in specific months; drawing them jointly keeps that relationship, so a block where equities crashed still carries whatever bonds actually did alongside.

Why it matters: sampling independent months would produce markets that are too kind. Real crashes aren't scattered bad months, they're consecutive bad months, and for a withdrawal plan the difference is enormous. That's the whole point of sequence risk.

The engine, step by step

The shape of one simulation: from today to your FIRE age the portfolio accumulates — contributions go in, it's rebalanced at your cadence. From FIRE age to a sampled age of death it decumulates — monthly withdrawals come out, funded by selling whichever asset is overweight, with only a drift backstop keeping the allocation in line.

Within every month the order is: market returns → wealth tax (December) → inflation → cash flows → rebalance.

Each simulation is run month by month, per asset. Every holding carries its own share count $q_i$ and its own cost basis; portfolio value is the sum across holdings. One row is reported per year, but the mechanics underneath are monthly:

1. Market. Each asset's drawn monthly return is applied to its own price: $p_{i,m} = p_{i,m-1}\,(1 + r_{i,m})$, so portfolio value is $V_m = \sum_i q_i\, p_{i,m}$.
2. Wealth tax (bollo). At year end, 0.2% of portfolio value is deducted: every holding is scaled by the factor $1 - 0.002$.
3. Cash flows. Active income and expense rows for the month are netted. A surplus buys toward the target allocation; a deficit triggers a withdrawal.
4. Withdrawal. Funded by selling from the assets that are above their target weight, in proportion to how far above. If that isn't enough, the rest is sold pro-rata across everything. Capital-gains tax is grossed up on the specific mix sold (see Taxes).
5. Rebalancing. During accumulation, the portfolio is realigned to target at your chosen cadence. During the FIRE phase there is no scheduled rebalance — only a drift backstop that fires if an asset strays too far from target.

Because withdrawals already sell the overweight asset, the FIRE phase mostly rebalances itself without a separate taxable event.

Mortality sampling

Each simulation draws an age of death $X$ from official ISTAT mortality tables, based on your current age and sex. Every simulation therefore runs a different horizon.

Italian tables show life expectancy at birth of roughly 81.5 years for men and 85.6 for women, but with wide individual variability, and it's that variability the model captures.

The stochastic approach is more realistic than a fixed horizon. Planning for "until 95" means sizing capital against a scenario that statistically occurs rarely, and concluding you need to work more years than you do.

If you prefer a deterministic horizon anyway, the Simulation end field lets you fix one age for all simulations.

Two-phase model

Accumulation phase (current age → FIRE):

• Each asset's historical monthly returns are applied
• Contributions buy toward the target allocation
• The portfolio is rebalanced at your chosen cadence
• Unexpected events, if enabled, can reduce value

Recurring expense rows (rent, everyday costs) don't touch the portfolio during this phase: the model assumes your salary covers them. Only portfolio contributions and one-time costs (a black swan event, a specific-age expense) actually move money in or out before FIRE.

FIRE phase (FIRE → death):

• Monthly withdrawals cover expenses, adjusted for inflation
• Withdrawals sell the overweight assets first, then pro-rata
• Pension income, if enabled, reduces the withdrawals needed
• Capital-gains tax applies to withdrawals; a drift backstop keeps the allocation in line
• Market returns keep acting on remaining capital

Rebalancing and glide paths

The rebalancing cadence you set acts forward, on each simulated path — not on a pre-computed return series. With Never, weights follow buy & hold and drift over time; with a periodic or drift-based cadence the portfolio returns to target. The capital-gains tax on each rebalance is charged per asset, on that asset's realised gain. Covered in depth in Rebalancing.

During the FIRE phase — and always in drift mode — there is no calendar: the backstop fires as soon as a single holding leaves its band, when $\lvert w_i - w_i^{*} \rvert > \text{threshold}$, expressed in percentage points.

The target allocation can also change with age (a glide path — e.g. more bonds as you approach and enter retirement). The engine supports this; there is no dedicated input for it yet, so today the target weights are constant unless the underlying allocation changes.

Taxes

On rebalancing. When a rebalance sells part of an appreciated asset, the realised gain is taxed at your capital-gains rate, per asset. The amount sold from a holding above target is $\Delta_i = \max(0,\; V_i - V\,w_i^{*})$, so:

$$T = \tau \sum_i \Delta_i\, g_i$$

where $g_i$ is asset $i$'s gain fraction (see below) and $\tau$ the rate.

On withdrawals. A withdrawal has to sell more than the cash you need, because part of what you sell is taxable gain. The engine grosses it up in one step:

$$\text{Gross withdrawal} = \frac{\text{Expenses} - \text{Income}}{1 - \bar{g}\,\tau}$$

where $\bar{g}$ is the embedded gain of the specific mix of assets being sold, not a whole-portfolio average:

$$\bar{g} = \frac{\sum_i v_i\, g_i}{\sum_i v_i}, \qquad g_i = \max\!\left(0,\; \frac{V_i - CB_i}{V_i}\right)$$

with $v_i$ the amount of asset $i$ actually sold, $V_i$ its value and $CB_i$ its cost basis. Selling the asset that ran up the most realises more gain; selling a flat one realises less.

Worked example. Two assets, 50/50 target. Asset A is worth €70,000 and you paid €35,000 for it (so half of it, €35,000, is gain); asset B is worth €30,000 with no gain. You need to withdraw €10,000, tax rate 26%.

• A is €25,000 above its €45,000 target, B is on target, so the whole sale comes from A.
• Gain ratio of what's being sold: 50% (A is half gain).
• Gross withdrawal = 10,000 ÷ (1 − 0.5 × 0.26) = €11,494. Of that, €1,494 is capital-gains tax; €10,000 covers the spending.
• Afterwards A is €58,506, B is unchanged at €30,000.

Wealth tax (bollo). 0.2% of portfolio value, deducted once a year.

Definition of success

A simulation is a success if the portfolio survives to the sampled age of death; a failure if it runs out first.

The probability of success is the share of successful runs:

$$P(\text{success}) = \frac{1}{N} \sum_{k=1}^{N} \mathbf{1}\!\left[\min_{t \le T_k} V_k(t) > 0\right]$$

where $N$ is the number of simulations, $T_k$ the sampled age of death of path $k$ and $V_k(t)$ the portfolio value along that path.

There's no universally correct threshold. Above 80% a plan is generally considered robust; 100% almost always means you're accumulating more than necessary and therefore working longer than necessary. Your flexibility matters too: someone who can cut spending in a bad year tolerates a lower probability than someone with a rigid cost structure.

How much to trust your result

The simulation resamples your portfolio's real history. If that history is short, there are only a handful of genuinely distinct 3-year blocks to draw from, so every simulated path is built from the same few pieces — the results look more precise than they really are.

• With ~10+ years of history, the resampling has real variety and the fan chart is a fair picture of the range.
• With only 3–6 years, treat the numbers as directional. The true uncertainty is wider than the chart shows, because a few years can't contain every kind of market.

The reliability score shown with the results captures exactly this — it's a function of how long and how continuous the window is (the same metric as the backtester's Dani Score, applied to the simulation's historical window). A low score doesn't mean the plan is bad; it means you're extrapolating from thin data and should lean on the conservative end.

Also read the failure-age distribution chart, not just the headline number. A plan that fails only at 92 in its bad scenarios is very different from one that fails at 68 — the first needs a little more capital, the second needs a buffer against a bad first decade.

What the model doesn't capture

• Structural regime changes with no precedent in the historical series.
• Tax-lot optimisation: selling specific lots, or banking capital losses to offset future gains (minusvalenze). The engine uses a weighted-average cost basis per asset and doesn't harvest losses.
• Your emotional reaction: the model assumes you follow the plan even after a −40%.
• Changes to taxation or state pensions over the coming decades.
• The fact that real spending is rarely a smooth line indexed to inflation.

A 90% plan isn't a promise. It's a way to understand how much margin you have, and which levers (contributing more, working one more year, spending slightly less) actually move the needle.