How we calculate

Every number across the calculator, Labs, and tools is derived from the formulas below. Nothing is a black box. This includes the FIRE calculator, Mutual Fund Audit, SWP tax calculator, expense ratio drag, TMF yield, and other planning tools. If you find an error or disagree with an assumption, open an issue on GitHub.

All calculations run in your browser — no data leaves your device.

FIRE Number

Your FIRE number is the corpus you need so that a sustainable annual withdrawal covers your lifestyle forever. There are two views:

Today's-money FIRE number

How much you would need if you retired today at your current lifestyle cost:

FIRE_today = Annual Expenses / (SWR / 100)

Inflation-adjusted FIRE number (what the calculator targets)

Expenses will be higher by retirement. We project them forward and divide by SWR:

Annual Expenses at Retirement = Annual Expenses × (1 + inflation)^years_to_FIRE

FIRE_target = Annual Expenses at Retirement / (SWR / 100)

Annual Expenses is the sum of your monthly living expenses (×12), annualised sinking fund costs, elder care, and milestones. Each component is inflation-adjusted before summing.

Corpus Projection

We use the standard future-value formula for a lump sum with recurring contributions:

FV = PV × (1 + r)^n  +  PMT × ((1 + r)^n − 1) / r

Where:
  PV  = current corpus (lump sum today)
  r   = annual return rate (decimal)
  n   = years to retirement
  PMT = annual SIP contribution

In Simple mode, PV and PMT come from the corpus and SIP fields directly. In Detailed mode, the calculator runs this formula for each portfolio accountat its own return rate and sums the results — giving you a per-instrument future value.

Safe Withdrawal Rate (SWR)

The SWR is the percentage of your corpus you can withdraw annually without running out of money over your projected life span. It is fully user-controlled via the slider (3% – 5%).

Inflation Adjustment

Every future-rupee amount in this calculator is a nominal figure (not real/constant-rupee). Inflation is applied in two directions:

• Growing withdrawals in drawdown: your withdrawal increases by the inflation rate each year so your purchasing power stays constant throughout retirement.
• Sinking fund costs: the replacement cost of each item is inflated to its future cost before amortising. A ₹15L car today costs ~₹26L in 10 years at 6% inflation — the annual saving amount reflects that.
• FIRE number: annual expenses are inflated to the year you retire before dividing by SWR.

Default: 6% per year— India's approximate long-run CPI average. Urban lifestyle inflation (healthcare, education, eating out) often runs 7–9%; adjust upward if your spending skews that way.

Sinking Funds (Replacement Costs)

Large irregular expenses (car, laptop, fridge) are converted to an annual saving requirement using inflation-adjusted amortisation:

Future Cost = Today's Cost × (1 + inflation)^replacement_years

Annual Saving = Future Cost / replacement_years

Sinking fund annuals are added to your total annual expenses and therefore increase your FIRE number. You can remove any default item or add custom ones.

Tax Drag per Instrument

Each portfolio account is labelled with a tax type. At retirement, we estimate the tax owed on the gain — and how much extra corpus you need so the net-of-tax figure still meets your FIRE number.

Portfolio Weighted Return

When you use Detailed mode and fill in multiple instruments, the calculator derives a single blended return for summary projections:

Rw = Σ (balance_i / Σ balance_j) × return_i

Only accounts with a non-zero balance are included. If no accounts have a balance, the manual "expected return" assumption from the Assumptions section is used instead.

Post-FIRE Drawdown

After you retire, the corpus earns a lower "post-FIRE return" (default 8%) while withdrawals grow with inflation each year. The year-by-year calculation is:

withdrawal_year_i  = Annual Expenses at Retirement × (1 + inflation)^i

growth_year_i      = corpus_year_i × post_FIRE_return

end_corpus_year_i  = corpus_year_i + growth_year_i − withdrawal_year_i

The simulation runs from your retirement age to your projected life span (user-set, default 85). It stops early if the corpus hits zero.

Important:the corpus used in drawdown is the calculator's projected corpus at retirement — not the FIRE number. If you retire with more than your FIRE number, the drawdown table shows the actual surplus compounding over time.

Monte Carlo Simulation

The deterministic drawdown table assumes a fixed return every year. In reality, returns are volatile. Monte Carlo runs 500 independent retirement scenarios with randomised annual returns:

annual_return_scenario = Normal(μ = post_FIRE_return, σ = 12%)

For each of 500 scenarios:
  corpus_0 = projected corpus at retirement
  For each year until life expectancy:
    withdrawal_i = expenses × (1 + inflation)^i
    r_i = sample from Normal(μ, σ)
    corpus_i+1 = corpus_i × (1 + r_i) − withdrawal_i
    if corpus_i+1 ≤ 0: scenario failed, record depletion age

Income & SIP Growth

Your income (and SIP contribution) will likely grow over time. The "Annual salary/income growth" slider applies compound growth to your SIP in the corpus projection:

SIP_year_i = SIP_today × (1 + salary_growth)^i

Corpus at year n = FV using growing SIP (step-up SIP)

Internally, the years-to-FIRE calculation iterates year by year with a growing annual contribution until the corpus crosses the FIRE number:

corpus_year_i+1 = corpus_year_i × (1 + r) + SIP_year_i

Stop when corpus_year_i ≥ FIRE_target

Life Events

One-time or recurring income/expense events (home purchase, inheritance, EMI ending) are layered on top of the base projection. In the year-by-year simulation:

life_event_impact_year_i = Σ (event.amountPerYear for all active events in year i)
  — positive for income events, negative for expense events

corpus_year_i+1 = (corpus_year_i + SIP_year_i + life_event_impact_year_i) × (1 + r)

Events with inflation adjusted checked have their amount grown at the inflation rate each year. A one-time event (startAge = endAge) applies only in that single year.

Car TCO Calculator

The Car vs. Cab tool computes the true yearly cost of ownership (TCO):

C_year = D/L + (EMI × 12) + F + M + I − R/L

Where:
  D   = down payment (opportunity cost, invested at Nifty 50 CAGR)
  L   = loan tenure in years
  EMI = monthly EMI
  F   = annual fuel cost  (km/day × 365 × cost_per_km)
  M   = annual maintenance (₹12,000 base, scaled by car age and type)
  I   = annual insurance premium
  R   = residual value at end of period (depreciation curve)

Opportunity cost of down payment

The down payment is not free money — it has an opportunity cost. We compound it at a user-adjustable CAGR (default 12%, Nifty 50 long-run) over the ownership period:

OppCost = DownPayment × ((1 + CAGR)^years − 1)

Break-even km/day

The break-even is the daily kilometres at which annual car fixed costs equal the saving from driving instead of cabbing (the difference in variable cost per km):

fixed_annual = down_payment/years + EMI×12 + maintenance + insurance + parking + cleaning − resale/years

Break_even_km/day = fixed_annual / (365 × (cab_rate_per_km − fuel_cost_per_km))

If you drive more than this per day, the car pays for itself vs. a cab; below this, cabs are cheaper.

NGT Car Scrappage Rules (Metro India)

The National Green Tribunal (NGT) mandates end-of-life vehicle rules for metros. The tool caps effective ownership at the scrappage limit and shows a warning when you will be forced to scrap before your planned period ends.

effective_ownership = min(planned_ownership_years, scrappage_limit − vehicle_age_today)

TCO is computed over effective_ownership, not planned_ownership.

Car Reality Check — 20/4/10 Rule & Veblen Index

The Reality Check tab scores a car purchase against three independent frameworks:

20/4/10 Rule

2× Cash Rule

You should have at least 2× the car price in liquid savings/investments before buying. If you can't buy the car twice in cash, you probably can't afford it.

Veblen Index (0–100)

The Veblen Index scores how much of the purchase is status vs. utility:

Veblen = (price / annual_income × 50) + (price / net_worth × 50)
  capped at 100

Score < 30 → utility purchase
Score 30–60 → aspirational
Score > 60 → primarily status-driven

Should You Buy It? — Purchase Scoring + EMI Decoder

The Should You Buy It? tool is now a two-in-one decision tool. It first checks affordability (5 rules + 2 honest questions producing a 0–100 score), then — when you select EMI as the payment method — it embeds the full EMI decoder and shows a combined verdict.

Affordability scoring (0–100, lower = more affordable)

Score = 0 means the purchase is financially sound; higher score = riskier. The score also powers 5 binary rule checks (pass/fail) shown in the rules panel. Final score determines the verdict:

EMI decoder (when financing)

When "EMI / financed" is selected, the tool embeds the full EMI decoder (same math as the standalone EMI tool). It extracts the effective annual rate, computes opportunity cost, and renders:

Not modelled: processing fees levied by the bank after disbursement, GST on processing fees (18%), pre-closure penalties, or subvention schemes where the manufacturer pre-pays interest to the lender.

Remote Life Index

The Remote Life Index (in the FIRE results panel) scores your corpus against the cost of living in 16 Indian cities — 10 Tier 2 cities and 6 major metros.

Monthly surplus calculation

monthly_withdrawal = (FIRE_corpus × SWR) / 12

surplus_city = monthly_withdrawal − city.totalMonthly2p

Lifestyle match

City data sources

Monthly cost estimates are compiled from NoBroker/MagicBricks rent surveys (2025), Numbeo cost-of-living data, CPCB annual AQI averages, and Ookla internet speed data. All costs are for a couple sharing rent and utilities. Figures are updated annually.

Emergency Fund Check

The Protection section shows your emergency fund status relative to a 6-month expense target.

target = monthly_expenses × 6

gap = target − liquid_savings   (positive = shortfall, negative = surplus)

status:
  ≥ 6 months → Good (green)
  3–6 months → Build up (amber)
  < 3 months → Urgent (red)

What counts as liquid savings? Savings account, liquid mutual funds, and short-term FDs you can break in ≤1 week. EPF, PPF, NPS, and equity MFs do not count — they cannot be liquidated quickly in a genuine emergency.

Insurance Health Check

Adequate insurance is a prerequisite for FIRE — one uninsured health event can wipe out years of savings. The tool checks two covers:

Term Life Insurance

recommended_cover = annual_income × 10  (minimum for dependants)

status: adequate if term_cover ≥ recommended_cover

The 10× rule ensures your family can replace your income stream for at least 10 years (invested at 8–10% CAGR). If you have dependants, young children, or a home loan, consider 15–20× annual income.

Health Insurance

minimum_cover = ₹10,00,000 (₹10 lakhs) per family

status: adequate if health_cover ≥ ₹10,00,000

₹10L is the minimum family floater for a metro in 2025. Medical inflation is ~12%/year — a ₹5L policy bought today covers significantly less in 10 years. Early retirees should target ₹25–50L or a super top-up on a base policy.

Part-Time Income in Retirement

Many early retirees earn some income post-FIRE (consulting, freelance, rental, creative work). The Assumptions section lets you model this as a monthly figure. Crucially:

net_withdrawal_year_i = base_withdrawal_i + healthcare_withdrawal_i − post_FIRE_annual_income

where base_withdrawal_i = annual_expenses × (1 + inflation)^i

If post-FIRE income exceeds annual expenses, net withdrawal becomes zero (corpus is untouched that year). The corpus then continues compounding at the post-FIRE return rate.

Healthcare Inflation in Retirement

Healthcare costs inflate significantly faster than general CPI. The drawdown model separates healthcare into its own expense stream with a distinct inflation rate:

total_withdrawal_year_i =
  (base_expenses × (1 + general_inflation)^i)
  + (healthcare_monthly × 12 × (1 + healthcare_inflation)^i)
  − post_FIRE_income

LTCG Harvesting

Under Budget 2024, equity LTCG up to ₹1,25,000/year is tax-free. The Investments section shows a harvesting tip to quantify this benefit during your accumulation phase:

annual_tax_saved = ₹1,25,000 × 12.5% = ₹15,625/year

total_saved_over_n_years = ₹15,625 × years_to_FIRE

How to harvest: Each year, sell equity MF units with ₹1.25L of accumulated gains and immediately repurchase (same fund or switch to a similar one). This resets your cost basis, permanently eliminating tax on those gains. The actual amount is tax-saved, not additional returns — but it compounds over the accumulation period.

NPS Annuity in Drawdown

At retirement, NPS rules force a portion of your corpus into an annuity — a fixed lifelong pension. This affects your drawdown in two ways: it reduces your liquid corpus and adds regular income.

PFRDA December 2025 rules (non-govt subscribers)

nps_annuity_corpus = nps_corpus_at_retirement × 0.20   (if corpus > ₹8L, else 0)

annuity_gross_income = nps_annuity_corpus × 6%        (current market annuity rate)

annuity_post_tax     = annuity_gross_income × (1 − 0.30)  (30% slab for FIRE retirees)
                     ≈ 4.2% of annuity corpus per year

liquid_corpus_for_drawdown = projected_corpus − nps_annuity_corpus

net_withdrawal_year_i = base_withdrawal_i − annuity_post_tax − post_fire_income

Old vs New Tax Regime

The Income Tax card in the results panel computes both regimes using your actual portfolio contributions and shows which saves more tax this year.

New Regime (Budget 2025, FY 2025-26)

taxable = gross_income − ₹75,000 (standard deduction)

Slabs:
  0%   up to ₹4L
  5%   ₹4L–₹8L
  10%  ₹8L–₹12L
  15%  ₹12L–₹16L
  20%  ₹16L–₹20L
  25%  ₹20L–₹24L
  30%  above ₹24L

87A rebate: if taxable ≤ ₹12L → rebate up to ₹60,000 (effective zero tax)

Surcharge (on tax after rebate):
  10%  taxable > ₹50L
  15%  taxable > ₹1Cr
  25%  taxable > ₹2Cr
  25%  taxable > ₹5Cr  (capped at 25% in new regime)

Final tax = (slab_tax − rebate + surcharge) × 1.04 (4% cess)

Old Regime (FY 2025-26)

deductions = ₹50,000 (std ded)
           + min(EPF_annual + PPF_annual, ₹1,50,000)   [80C]
           + min(NPS_annual, ₹50,000)                  [80CCD(1B) — old regime only]
           + ₹25,000                                   [80D health insurance, approximated]

taxable = gross_income − deductions

Slabs:
  0%   up to ₹2.5L
  5%   ₹2.5L–₹5L
  20%  ₹5L–₹10L
  30%  above ₹10L

87A rebate: if taxable ≤ ₹5L → rebate up to ₹12,500

Surcharge (on tax after rebate):
  10%  taxable > ₹50L
  15%  taxable > ₹1Cr
  25%  taxable > ₹2Cr
  37%  taxable > ₹5Cr  (37% in old regime)

Final tax = (slab_tax − rebate + surcharge) × 1.04 (4% cess)

Family FIRE Mode

The Family FIRE tab projects a household corpus — two people potentially retiring at different ages, with shared expenses and combined portfolios.

Spouse corpus projection

spouse_years_to_fire = max(1, spouse_retirement_age − spouse_current_age)

spouse_corpus = FV(
  PV  = spouse_portfolio_balance,
  r   = weighted_return_of_spouse_accounts,
  n   = spouse_years_to_fire,
  PMT = spouse_monthly_sip × 12
)

Household corpus

household_corpus = your_projected_corpus + spouse_projected_corpus

Each person is projected to their own retirement age using the standard FV formula. If retirement ages differ, the corpus values are added directly — no bridging adjustment is made to the corpus total, but the UI notes the bridge period.

Children cost tiers

Children are added in the Family section with a cost tier. Their monthly cost is added to total annual expenses and therefore increases your FIRE number. Three tiers:

Each child progresses through 4 phases as they age (costs sourced from Metro India 2025 data):

child_annual_cost = current_phase_monthly × 12

total_family_expenses = base_expenses + Σ child_annual_cost + elder_care + dependents + healthcare

Rent vs Buy Analysis

The Rent vs Buy tool runs two analyses: affordability (can you take this loan?) and worth (should you?).

EMI calculation

r   = annual_rate / 12   (monthly rate)
n   = tenure_months

EMI = P × r × (1 + r)^n / ((1 + r)^n − 1)

Affordability rules

True monthly cost of ownership

true_monthly_cost = EMI
  + (maintenance_rate × property_value / 12)
  + (property_tax_rate × property_value / 12)
  + society_charges
  − tax_benefit_per_month   (Section 24b interest up to ₹2L/yr, old regime only)

Rent vs buy break-even

For each year y:
  buying_cost_y   = cumulative EMIs + maintenance − equity_built
  renting_cost_y  = cumulative_rent × (1 + rent_inflation)^y
                  − opportunity_cost_of_down_payment

Break-even year = first y where buying_cost_y < renting_cost_y

Couples Finance Split

The Couples Split tool models three philosophies for dividing shared household expenses between two partners. All three models take the same inputs — each partner's monthly take-home income and total shared monthly expenses — and produce different contribution splits.

Model 1 — 50/50 Split

The simplest model: each partner pays exactly half the shared expenses, regardless of income.

Each partner pays = Expenses ÷ 2

Left over (A) = Income_A − (Expenses ÷ 2)
Left over (B) = Income_B − (Expenses ÷ 2)

Where
  Expenses = total shared monthly household expenses
  Income_A, Income_B = each partner's monthly take-home

Warning triggered if either partner's contribution > 80% of their income.

Model 2 — Proportional Split (Income-Ratio)

Each partner contributes their income-share fraction of total expenses. The higher earner pays more in absolute terms but the same percentage of income.

Income ratio (A) = Income_A ÷ (Income_A + Income_B)
Income ratio (B) = Income_B ÷ (Income_A + Income_B)

Contribution_A = Expenses × Income_ratio_A
Contribution_B = Expenses × Income_ratio_B

Left over (A) = Income_A − Contribution_A
Left over (B) = Income_B − Contribution_B

Where
  Income_ratio_A + Income_ratio_B = 1 (they sum to 100%)

Model 3 — Equal Guilt-Free Money

The most equitable model for large income gaps. The total household surplus (income minus expenses) is split equally so both partners end up with the samediscretionary money — eliminating the "I earn more so I have more fun money" dynamic.

Surplus        = (Income_A + Income_B) − Expenses
Equal fun money = Surplus ÷ 2

Contribution_A = Income_A − Equal_fun_money
Contribution_B = Income_B − Equal_fun_money

Left over (A) = Left over (B) = Equal_fun_money

Where
  Surplus = total household money remaining after all shared expenses
  Equal_fun_money = each partner's equal share of discretionary income

Model is feasible only when Income_A ≥ Equal_fun_money
                         and Income_B ≥ Equal_fun_money
(i.e. neither partner contributes more than 100% of their income)

Coast FIRE

Coast FIRE is the corpus you need today such that, with zero further contributions, it grows to your full FIRE number by your target retirement age through compounding alone.

Coast FIRE number = FIRE_number ÷ (1 + r)^n

Where
  FIRE_number = target corpus (25× annual expenses at your SWR)
  r           = annual investment return (decimal)
  n           = years to retirement (retirementAge − currentAge)

Barista FIRE

Barista FIRE is a reduced corpus target for people who plan to earn part-time income in retirement. The part-time income covers a portion of expenses, so the corpus only needs to fund the remaining gap.

Barista FIRE number = (Annual_expenses − Part_time_annual_income) × (100 ÷ SWR)

Where
  Annual_expenses        = total annual spending (base + sinking funds + milestones)
  Part_time_annual_income = expected annual income from gig/consulting/freelance work
  SWR                    = safe withdrawal rate (%)

Note: if Part_time_annual_income ≥ Annual_expenses, corpus = 0 (fully self-funded).

Illiquid Asset Bridge

EPF, PPF, NPS Tier 1, SCSS, and APY are locked until specific ages (EPF/NPS until ~58, PPF until 15 years from account opening). If you plan to retire earlier than 58, your liquid assets must bridge the gap.

Bridge gap (years) = max(0, 58 − retirementAge)

Annual liquid needed = Annual_expenses × (1 + inflation)^yearsToRetirement
Liquid bridge corpus = Annual_liquid_needed × bridge_gap_years
                     (simplified; actual = PV of inflation-adjusted expenses over bridge period)

Liquid needed at retirement ≥ Liquid bridge corpus + ongoing liquid withdrawals after 58

Dynamic Withdrawal — Guyton-Klinger Guardrails

The classic 4% SWR uses a fixed inflation-adjusted withdrawal every year regardless of portfolio performance. The Guyton-Klinger guardrails strategy starts at a higher initial rate but applies rules to cut or raise withdrawals dynamically, improving portfolio survival and allowing a higher starting spend.

Initial withdrawal rate: w₀ = 5% (or user-configured)

Each year:
  Current rate = annual_withdrawal / portfolio_value

Guard check (cut):
  if current_rate > w₀ × 1.20 → cut withdrawal by 10%
  ("Prosperity Rule" — spending too high relative to portfolio)

Guard check (raise):
  if current_rate < w₀ × 0.80 → raise withdrawal by 10%
  ("Poverty Rule" — portfolio outperforming; can spend more)

Inflation adjustment:
  if portfolio return last year < 0 → skip inflation adjustment that year
  ("Capital Preservation Rule" — preserve corpus in down years)

Should You EMI It? — EMI Cost Decoder

The Should You EMI It? tool decodes the true cost of any EMI offer — whether a zero-cost EMI, a standard loan, or a Buy Now Pay Later scheme.

What is included in the calculation

The tool models three EMI types:

Zero-cost EMI: finding the effective rate

A "0% interest" EMI is not free — the lender charges a processing fee upfront that functions as prepaid interest. To find the true annual rate, we solve Newton-Raphson iteration on the loan equation:

Price = ProcessingFee + Σ [EMI / (1 + r)^t]   for t = 1 to n

Where:
  Price          = product price (loan principal)
  ProcessingFee  = upfront fee paid at purchase
  EMI            = Price / n  (equal instalments, no stated interest)
  n              = number of months
  r              = monthly effective rate (what we solve for)

Annualised effective rate = (1 + r)^12 − 1

Standard EMI: reducing-balance rate

r   = annual_interest_rate / 12  (monthly rate)
n   = tenure_months

EMI = P × r × (1 + r)^n / ((1 + r)^n − 1)

Total interest = (EMI × n) − P
Total cost     = P + total interest

Opportunity cost of capital

If you have the cash to buy outright, using EMI has two costs: the interest/fees paid, and the returns foregone on the cash you keep invested. The tool models both:

FV_lump   = cash_price × (1 + r_invest)^(n/12) − (cash_price − total_emi_payments)
  [future value of investing the difference upfront]

FV_sip    = Σ [monthly_saving × (1 + r_invest)^(months_remaining)]
  [future value of investing EMI payments as a SIP]

Opportunity cost = max(FV_lump, FV_sip) − 0
  [approximate benefit of staying liquid vs paying cash]

EMI verdict thresholds

Portfolio Simulator

The Portfolio Simulator (fourth tab in the calculator) is a standalone sandbox for modelling retirement drawdown. It does not write to your main plan — changes are local to the simulator tab only.

Deterministic projection

Each year in retirement:

withdrawal_yr = annualWithdrawal × (1 + inflation)^yr   // inflation-adjusted
afterWithdrawal = max(0, corpus − withdrawal_yr)
growth = afterWithdrawal × blendedReturn
corpus_next = afterWithdrawal + growth

Blended return

blendedReturn = (equity% × equityReturn) + (debt% × debtReturn) + (alt% × altReturn)

Glide path (optional)

When enabled, equity allocation decreases by 1 percentage point per year in retirement (floor: 20%), with debt absorbing the shift. Allocation is renormalised to 100% each year before computing the blended return.

Monte Carlo survival probability

500 simulated retirement sequences are run. Each sequence applies normally-distributed annual returns (mean = blended return, std dev = 14% for equity-heavy / 10% balanced / 7% defensive) with inflation-adjusted withdrawals. Survival % = fraction of runs where corpus stays positive through the planned lifespan.

Withdrawal modes

Ultra-safe floor

ultraSafeFloor = corpus × 2.5% / 12   // monthly equivalent at 2.5% SWR

The 2.5% SWR represents the maximum historically-resilient withdrawal rate across all global market conditions since 1900.

Family simulation

When spouse data is present (Family FIRE mode), the simulator shows a second strip with the combined household corpus (your projected corpus + spouse projected corpus) and runs 300 Monte Carlo simulations on the combined corpus using the same withdrawal and allocation settings as the individual simulation.

Real Rate of Return

The Real Rate of Return lab strips out both tax drag and inflation so you can see the actual change in purchasing power.

after_tax_return = nominal_rate × (1 − tax_rate)

real_return = ((1 + after_tax_return) / (1 + inflation_rate)) − 1

Where:
  nominal_rate      = quoted FD / PPF / MF / bond return
  tax_rate          = instrument-specific effective tax
  inflation_rate    = expected CPI / personal inflation
  real_return       = purchasing-power growth

Tax treatment is instrument-specific: PPF and SGB maturity gains are modelled as tax-free, equity funds use long-term capital gains assumptions, and fully taxable instruments such as FDs and savings accounts use your slab rate.

Expense Ratio Drag

The Expense Ratio Drag lab compares two identical portfolios where only the fund fee differs.

net_return_low_fee  = gross_return − ER_low
net_return_high_fee = gross_return − ER_high

FV = iterate yearly:
  corpus_next = corpus_current × (1 + net_return) + annual_sip

fee_drag = corpus_low_fee − corpus_high_fee

Post-Tax Safe Money

The Post-Tax Safe Money lab ranks low-risk instruments by what you actually keep after tax, then translates that into a real return.

post_tax_return_i = gross_rate_i × (1 − effective_tax_i)

real_return_i = ((1 + post_tax_return_i) / (1 + inflation_rate)) − 1

corpus_growth_i = ₹10,00,000 × (1 + post_tax_return_i)^years − ₹10,00,000

This is a ranking tool, not a risk-adjusted optimizer. The lab compares safe-money options on after-tax math alone; lock-in, liquidity, and mark-to-market volatility still matter in the final decision.

TMF Yield Lock-in

The TMF Yield Lock-in lab estimates what happens if you buy a Target Maturity Fund and hold it all the way to maturity.

maturity_value = investment × (1 + YTM)^years
gain = maturity_value − investment
tax_payable = gain × slab_rate
after_tax_value = maturity_value − tax_payable

post_tax_CAGR = (after_tax_value / investment)^(1 / years) − 1
real_CAGR = ((1 + post_tax_CAGR) / (1 + inflation_rate)) − 1

The lab also computes an FD comparator taxed annually at the same gross rate, so the displayed edge is primarily the value of tax deferral, not an assumption that TMFs are intrinsically higher-return products.

SWP Tax Deconstructor

The SWP Tax Deconstructor models a withdrawal stream as partial redemptions, where only the gain portion of each withdrawal is taxed.

gain_fraction = (NAV_withdrawal − purchase_NAV) / NAV_withdrawal
gain_on_withdrawal = withdrawal_amount × gain_fraction

Equity MF:
  year 1  → STCG tax = gain_on_withdrawal × 20%
  year 2+ → LTCG tax = max(0, gain_on_withdrawal − ₹1,25,000) × 12.5%

Debt / non-equity:
  tax = gain_on_withdrawal × slab_rate

net_withdrawal = withdrawal_amount − tax

VPF vs ELSS

The VPF vs ELSS lab compares the after-tax outcome of putting the same annual 80C amount into guaranteed provident-fund compounding versus equity-linked compounding with LTCG at redemption.

VPF corpus:
  corpus_next = (corpus_current + annual_80C) × (1 + EPF_rate)

ELSS corpus:
  corpus_next = (corpus_current + annual_80C) × (1 + equity_return)

ELSS after-tax corpus:
  total_gain   = gross_corpus − total_invested
  taxable_gain = max(0, total_gain − ₹1,25,000)
  LTCG_tax     = taxable_gain × 12.5%
  after_tax    = gross_corpus − LTCG_tax

Because both VPF and ELSS compete for the same Section 80C deduction, the tax-saving benefit at contribution stage cancels out in the comparison. The question the tool answers is: what is left at the end, after compounding and redemption tax?

Mutual Fund Audit

The Mutual Fund Audit lab combines live AMFI NAV history with return and fee math so you can inspect a fund before trusting the headline story.

Point-to-point CAGR

CAGR_n = (NAV_today / NAV_n_years_ago)^(1 / actual_years) − 1

Where:
  NAV_n_years_ago = nearest available NAV to the target lookback date
  actual_years    = exact year fraction between the two NAV points

The 1Y, 3Y, and 5Y figures are point-to-point returns from historical NAV series. They are not rolling returns, and they are not SIP returns.

Fee drag vs index

fund_FV  = investment × (1 + gross_return − TER_fund)^years
index_FV = investment × (1 + gross_return − 0.20%)^years

fee_drag = index_FV − fund_FV

Advanced FIRE SIP outcome inside MF Audit

For each month:
  corpus = (corpus + monthly_sip) × (1 + monthly_return)

Every 12 months:
  monthly_sip = monthly_sip × (1 + step_up)

real_corpus = nominal_corpus / (1 + inflation)^years

FIRE month = first month where:
  nominal_corpus ≥ target        [future-rupee mode]
  or
  real_corpus ≥ target           [today's-money mode]

When historical mode is used, the tool simulates a ₹10,000 monthly SIP using the loaded fund's NAV history, builds dated cash flows, and solves XIRR from those cash flows.

XNPV(r) = Σ cashflow_i / (1 + r)^(days_i / 365.25)

Solve for r such that XNPV(r) = 0

Historical SIP assumptions:
  contribution date = nearest available NAV on or after the 5th of each month
  window            = trailing ~5 years from latest NAV
  output            = annualised SIP XIRR

Averaging Down

The Averaging Down lab solves a position-sizing question: how many more shares do you need to buy at the current lower price to bring your average cost down to a target?

target_avg × (shares_owned + x) = current_investment + current_price × x

Solve for x:
  x = (current_investment − target_avg × shares_owned) / (target_avg − current_price)

Where:
  current_investment = avg_buy_price × shares_owned
  x                  = additional shares required

The tool then rounds shares up to a whole number, computes the additional capital required, and shows how much the break-even recovery percentage falls after the new purchase.

Lumpsum vs STP

The Lumpsum vs STP lab compares immediate deployment into equity with parking the money in a liquid fund and transferring it gradually.

Lumpsum:
  final_value = amount × (1 + equity_monthly_return)^(horizon_months)

STP:
  monthly_transfer = amount / stp_months

For each month:
    liquid_balance = liquid_balance − transfer
    equity_balance = equity_balance + transfer
    liquid_balance = liquid_balance × (1 + liquid_monthly_return)
    equity_balance = equity_balance × (1 + equity_monthly_return)

stp_final = liquid_balance + equity_balance

advantage = lumpsum_final − stp_final

Default Assumptions

Every default is a deliberate choice. Here is what we use and why:

Limitations & Disclaimers