Back to the world

Personal & Family Financial Management

2026 · Ongoing

BudgetX

BudgetX is a personal and family finance application covering accounts, expenses, budgets, categories, analytics and financial goals. It turns scattered transactions into a single, calm picture of where money actually goes.

Problem

Households juggle multiple accounts and mental models of their finances. Existing tools are either too simplistic to model shared family spending or too heavy to keep up with day to day. The result is budgeting apps that get abandoned within weeks.

Solution

A focused product built around the core loop: record an expense in seconds, see it reflected instantly across budgets, category analytics and goal progress. Family members share a household space while keeping individual accounts, and every view is designed to answer one question — are we on track?

  • Multi-account tracking with per-member permissions inside a shared household
  • Envelope-style budgets with rollover rules and live remaining amounts
  • Category analytics with month-over-month trends and drill-downs
  • Financial goals with contribution scheduling and progress projections
  • FastAPI backend with typed request/response contracts

System architecture

  • frontend

    React Client

    Typed API client with optimistic updates for instant feedback.

  • backend

    FastAPI Server

    Versioned REST interface, Pydantic validation at every boundary.

  • backend

    Auth & Users

    Session-based auth with household scoping enforced in queries.

  • backend

    Domain Logic

    Budget engine: allocations, rollovers, goal contributions.

  • data

    PostgreSQL

    Normalized ledger schema; constraints guard financial invariants.

  • data

    Redis

    Analytics caching and rate limiting for hot endpoints.

Data flow

  • React ClientFastAPI Server
  • FastAPI ServerAuth & Users
  • FastAPI ServerDomain Logic
  • Auth & UsersPostgreSQL(users)
  • Domain LogicPostgreSQL(ledger)
  • FastAPI ServerRedis(cache)

Technology

  • React
  • TypeScript
  • FastAPI
  • PostgreSQL
  • Redis
  • Docker

Engineering challenges

  • Budget recalculations became slow once a household accumulated thousands of transactions.

    Moved aggregation into SQL with materialized monthly rollups and invalidated them through targeted events instead of recomputing on read.

  • Concurrent edits by family members produced confusing overwrites.

    Introduced row versioning on mutable records and last-write-wins only on non-financial fields; monetary mutations are append-only entries.

Decisions & trade-offs

  • Append-only transaction ledger

    Financial data should be auditable; corrections are reversing entries, not edits.

  • Server-side budget engine

    Money rules belong next to the database so clients stay thin and consistent.

  • Redis only for cache and limits

    No second source of truth for financial state — Postgres remains authoritative.

Result

  • A complete product loop from expense entry to goal tracking, deployed via Docker Compose.
  • Analytics views respond from cached rollups instead of scanning raw transactions.
  • The codebase doubles as my reference implementation for typed full-stack architecture.

What I learned

  • Design the ledger first — everything else in a finance app is a view over it.
  • Optimistic UI is only trustworthy when the server contract is strict.
  • Caching is an optimization pass, not an architectural afterthought.