Axiomatic BI Showcase

Financial independence forecaster

This case study shows how a local financial forecasting prototype was migrated into a publishable web app while maintaining parity in calculation behaviour.

Open website View repository

Quick overview

At a glance

Problem

FIRE planning questions are hard to answer with static spreadsheets when assumptions change frequently.

What was built

A browser-based forecasting app that lets users vary income, spending, assets, mortgage terms, and growth assumptions.

Why it matters

Users can compare realistic life choices, such as property decisions, and see how those choices shift FI timing.

Implementation focus

Clear assumptions, transparent calculations, and fast scenario recompute for iterative decision-making.

Model design

Forecast logic model

This section uses a conceptual model to show how user assumptions are transformed into forecast outputs. It is the application equivalent of a traditional data model diagram.

The app models household finances month by month so users can test how savings, investments, pension, and housing choices affect FI timing.

The model is scenario-driven: users set assumptions once, then the engine projects trajectories and FI signals across the selected forecast horizon.

Model decisions

  • Monthly simulation is used so mortgage amortisation, contributions, and growth effects stay temporally consistent.
  • FI status is evaluated from liquid investable assets (ISA and non-ISA) against projected expenses using a configurable extraction rate.
  • Pension and home equity are projected for net-worth context but excluded from the core FI trigger to keep the signal conservative and comparable.
flowchart TD inputs["Scenario inputs<br/>income, spending, assets, mortgage, rates"] --> monthly["Monthly projection engine"] monthly --> fi["FI signal calculation<br/>FI date, years until FI, passive income"] monthly --> vm["Presentation model<br/>cards, charts, comparison views"]
Component Role Resolution Purpose
forecast_input_contract Input contract module One scenario payload per run Captures assumptions for income, expenses, rates, contributions, inflation, and property or mortgage context.
monthly_projection_series Projection engine output One monthly state per step in the forecast horizon Tracks ISA, non-ISA, pension, home equity, income, expenses, and savings over time.
fi_signal_outputs FI signal calculator One summary output per scenario run Summarises FI date, years-until-FI, and passive-income indicators based on extraction-rate assumptions.
chart_view_model Presentation view model One chart or table-ready element Shapes trend lines, comparison views, and metrics cards for the UI.

Data quality and validation

  • Deterministic calculations produce repeatable outputs for the same scenario inputs.
  • Tests cover core financial rules including pension growth, mortgage progression, and output shape.
  • UI-level checks verify that view models and summary metrics remain consistent when assumptions change.

Delivery architecture

Architecture

The delivery flow keeps Python as the calculation baseline and uses fixture snapshots to validate migration parity in the web implementation.

This improves confidence that published outputs match the reference model, while still enabling faster iteration in the frontend.

flowchart LR input["User assumptions<br/>income, expenses, growth, rates"] --> python["Python forecast engine baseline"] python --> fixtures["Parity fixtures"] fixtures --> web["TypeScript forecast model"] web --> view["View-model layer"] view --> outputs["Charts, metrics, and FI date outputs"]

Outputs

Reporting outputs

The published app demonstrates how forecast assumptions translate into FI date estimates, passive income projections, and long-horizon trend views.

Published web app

Open FI Forecaster website

Reproducibility

Run and verify locally

Local verification steps

Assumptions

  • Forecast outputs are nominal GBP values and depend entirely on user-provided assumptions.
  • Scenario comparisons are deterministic and intended for planning exploration.
  • GitHub Actions is configured as the Pages source for deployment.

Commands

python -m venv .venv && .venv\Scripts\activate && pip install -e ".[dev]"
python scripts/generate_forecast_fixtures.py
cd web && npm install && npm run test
cd web && npm run build

Limitations

  • This is a forecasting tool, not regulated financial advice.
  • FI timing is based on a simplified extraction-rate method and excludes taxes on withdrawals.
  • Outputs do not include probabilistic market simulation or stochastic stress testing.

Technical delivery detail

Delivery intent, modelling, and implementation decisions

This case study documents a financial independence planning app built to answer a practical question: when could a household reach FIRE under different real-life choices. The core use case is scenario comparison, including how property decisions can accelerate or delay the FI timeline.

Problem and decision context

The project started from a personal planning need rather than a technology migration objective. I wanted a tool that could quickly answer “what happens if…” questions across savings rate, investment growth, pension contributions, and housing choices.

  • Typical scenario questions include:
    • Should we buy a more expensive house now or later?
    • How does mortgage size change years-until-FI?
    • What is the trade-off between current spending and projected passive income at FI?

Architecture and model flow

The app uses a deterministic projection engine and a browser UI optimised for rapid parameter changes. Inputs are translated into a monthly projection series, then summarised into FI signals and chart-ready outputs.

  • Core modelling and app evidence:
    • Forecast logic: src/financial_forecaster/forecast.py
    • Fixture generation and validation support: scripts/generate_forecast_fixtures.py
    • UI-facing view model checks: web/src/application/buildForecastViewModel.test.ts
    • Published app: https://axiomatic-bi.github.io/financial-independence-forecaster/

Transformation approach and validation

Transformation here means turning raw assumptions into decision-ready indicators. The pipeline is: assumptions -> monthly simulation -> FI signal calculation -> chart and metric view models.

  • Validation approach:
    • deterministic output checks for identical input scenarios
    • tests for pension and mortgage rule behaviour
    • checks that FI date, years-until-FI, and passive-income signals remain coherent under scenario changes

Results and trade-offs

The app provides a practical planning surface for FIRE exploration, not just a technical demonstration.

  • Results:
    • faster comparison of household scenarios than manual spreadsheet recalculation
    • clearer visibility of how housing choices affect FI timing
    • publicly shareable implementation with transparent assumptions
  • Trade-offs:
    • deterministic modelling is intentionally simple and explainable
    • outputs are sensitive to user assumptions and are not predictive guarantees