EliconStart a project →
← ALL WORK

CASE 02

Built in phases

LifeOps

Private finance-forecasting SaaS.

  • Next.js
  • Postgres
  • Forecasting
Product
Finance forecasting SaaS
Horizon
Multi-year projections
Model
Scenario + probabilistic
Access
Private, account-gated
Data
User-controlled, no bank scraping

Most personal finance tools are excellent at telling you what you already spent and useless at telling you what happens next. LifeOps is the other way round: a private forecasting product that models income, commitments and scenarios forward over years, and answers questions like whether a decision is survivable — with the uncertainty shown rather than hidden.

THE PROBLEM

What was going wrong.

Budgeting apps categorize the past. The decisions that actually matter — can we take this risk, when does this become affordable, what breaks if income stops — are forward-looking questions no ledger answers.

Spreadsheets are the default tool for this, and they are single-scenario by nature. Modelling an alternative means duplicating the sheet, and comparing three futures means three sheets that immediately diverge in their assumptions.

Existing tools that do forecast tend to project a single confident line into the future, which is the least honest possible representation of something driven by variable income and irregular expenses.

Financial data is the most sensitive category of personal data there is, so anything requiring bank credentials starts from a trust deficit that a small product cannot easily overcome.

CONSTRAINTS WE WORKED UNDER

  • ·Privacy first: no credential-based bank scraping, and the data model has to assume the user is right to be cautious.
  • ·Forecasts must be explainable. A number the user cannot trace back to an assumption will not be trusted or acted on.
  • ·Scenarios need to be cheap to create and compare, or people will keep using spreadsheets.
  • ·Irregular income and lumpy expenses are the normal case, not an edge case to handle later.

WHAT WE DID

The short version.

  1. 01

    Modelled finances as accounts, recurring flows, one-off events and rules, so a forecast is a projection of explicit objects rather than an opaque calculation.

  2. 02

    Built scenario branching — fork the baseline, change assumptions, compare futures side by side without duplicating anything.

  3. 03

    Added probabilistic projection over variable inputs so the output is a range with likelihoods, not a single confident line.

  4. 04

    Made every projected figure traceable back to the assumptions that produced it.

ARCHITECTURE

How it's built.

01

Financial object model

Accounts, recurring flows with schedules, one-off events, and rules that fire on conditions. A forecast is a deterministic walk over these objects, which is what makes any figure explainable — every euro traces to an object and a date.

02

Projection engine

Time-stepped simulation over the object graph, handling schedule irregularity, rule interactions and account interactions. Runs are deterministic given a seed, so a shared projection reproduces exactly.

03

Scenario branching

Scenarios are diffs against a baseline rather than copies. Changing a shared assumption updates every scenario that inherits it, which removes the drift that makes duplicated spreadsheets useless within a month.

04

Probabilistic layer

Variable inputs carry distributions rather than fixed values, and projections run many times to produce percentile bands. The interface shows the range and the likelihood of specific outcomes — the questions people actually have.

05

Privacy posture

Account-gated, no third-party credential storage, data entered and controlled by the user, with export available. The product assumes a user who wants to leave, and is built so leaving is easy.

KEY DECISIONS

What we chose, and what it cost.

Manual and imported data instead of bank credential aggregation

WHY

Aggregation buys convenience at the cost of holding the keys to someone's financial life. For a forecasting tool, the marginal accuracy did not justify the trust and liability burden.

TRADE-OFF

More setup effort for the user, and balances need periodic updating. It also means the product never becomes a breach target for credentials it does not hold.

Scenarios as diffs, not copies

WHY

Copied scenarios drift. If a shared assumption changes and only three of five scenarios get updated, every comparison after that is quietly wrong.

TRADE-OFF

A more complex resolution layer, and inheritance rules the interface has to make visible rather than clever.

Ranges over point forecasts

WHY

A single projected line implies precision that no multi-year financial forecast has. Showing bands changes the user's question from 'what will happen' to 'what am I exposed to', which is the better question.

TRADE-OFF

Harder to present and harder to read at a glance. Worth it — a point forecast that turns out wrong destroys trust in the whole product.

THE HARD PARTS

What nearly broke it.

Irregular income breaks naive models

Monthly-salary assumptions fail immediately for freelance or variable income. The schedule model had to handle genuinely irregular flows with distributions rather than treating them as a monthly average, which is where the probabilistic layer earned its cost.

Explaining a number

Early projections were correct and unconvincing, because the user could not see where a figure came from. Making every projected value expandable into its contributing objects changed how much people trusted the output more than any accuracy improvement did.

Scenario proliferation

Cheap scenarios meant users created a dozen and lost track of what each represented. Naming, inheritance visualisation and archiving turned out to be product features, not housekeeping.

HOW IT RAN

The timeline.

  1. 01

    Object model & projection

    Phase 1

    Accounts, flows, events and rules, plus the deterministic projection walk that turns them into a forecast.

  2. 02

    Scenarios

    Phase 2

    Diff-based branching, inheritance resolution and side-by-side comparison views.

  3. 03

    Probabilistic projection

    Phase 3

    Distributions on variable inputs, repeated simulation, percentile bands and outcome likelihoods.

  4. 04

    Explainability & hardening

    Phase 4

    Traceable figures, export, account security and the privacy posture documented for users.

OUTCOME

What changed.

Multi-year

Forecast horizon with irregular flows handled natively

Ranges

Probabilistic bands instead of a single confident line

Traceable

Every projected figure expands to its assumptions

0

Bank credentials stored

Privacy posture, decided up front.

A forecasting tool that answers forward-looking questions honestly — including how uncertain the answer is.

Scenario diffing is what replaced the spreadsheet. Comparing futures stopped being a copy-paste exercise, which is the moment the tool became worth opening.

The privacy stance simplified the product as much as it protected users: no credential vault, no aggregation vendor dependency, no breach surface for keys the product never holds.

STACK

What it's made of.

APPLICATION

  • Next.js
  • TypeScript
  • Tailwind

DATA

  • Postgres
  • Deterministic projection
  • Scenario diffs

MODELLING

  • Time-stepped simulation
  • Input distributions
  • Percentile bands

SECURITY

  • Account gating
  • User-controlled data
  • Full export

HANDOVER

What they kept.

  • Documented financial object model and the exact semantics of every schedule and rule type.
  • Projection determinism notes — seeds, reproducibility and what makes two runs differ.
  • Privacy and data-handling documentation written for users, not just for developers.