Initial Bone Budget Features

[reedlauber]

I was thinking about the stuff listed in #32 and thought it would be fun to try to break it all out into more detail to see what it looked like. Here's a quick sketch of what a possible set of features and requirements for an MVP might look like.

UI Features

• Home
  • See balance
  • See recent transactions
  • See budgeting summaries
  • [post-MVP] See jobs to do (e.g. repair transactions or budgeting exceptions)
• Translations
  • Sort by date created, descending (others?)
  • Filter by: description text, transaction type, category, tag, date range, etc
  • Update transaction details (set category, tags, etc)
  • Apply “group by” and see aggregate sums
• Insights
  • See big aggregates (net gain/loss by date range)
  • See charts of values over time, including:
  • Balance, Spending, Income
  • Grouped by: category, etc
  • See aggregate values by category, tag, etc.
  • See budgeting performance (under/overspent budgets, etc)
• Budgeting
  • Envelopes (by week, month)
  • Savings goal to a fixed amount
  • May be by a certain date, which can describe how much is needed
  • Or without a date
  • Savings set aside
  • By percentage
  • By dollar amount
  • Debt target amount (may be associated with a loan or credit card)
  • Pay off by date
  • Pay off fixed amount by cycle

Data modal/API requirements

In order to enable the above features, we might need the following. This isn't comprehensive. As we dig into each one, they will likely get broken down into a lot more sub-items.

Balances - to enable balances, we’ll need a concept of an “account”, even if it’s just 1-to-1 with a user, it should be a separate object. There are three ways we could calculate and show a balance:

• Every time the balance is requested, we sum all the transactions. This is very simple, but impractical over the long term.
• The Account model has a balance and every time a transaction is added, the value is increased or decreased accordingly. This is much more scalable, but likely prone to out-of-sync values that are hard to resolve.
• We maintain a separate “ledger” that tracks all changes to the balance, as well as stores the new balance after each change. Requesting the balance essentially means looking at the most recent item in the ledger. This makes it much easier figure out where things went wrong if the balance appears to be inaccurate, but is more complicated to set up overall.

Transactions - We already have a data model object for this, as well as an import process. In addition, we might include:

• Data processing (description cleanup, auto-categorizing, etc)
• Tagging
• API:
  • Allow querying transactions by: date range, text match (on description), category, tag(s), etc
  • Allow editing certain fields (e.g. description, category, tags)
  • Allow sorting and grouping

Budgets - Each budget would behave like its own account, with its own ledger.

• At a minimum, a budget object would probably need:
  • id (uuid)
  • type ('envelope', 'savings', etc)
  • target_amount (numeric)
  • title (text)
  • is_paused (boolean)
  • (additional fields to support each budget type (e.g. due_date)
• Budgets also need logic to react to transactions, changes to other budgets, new days, new paychecks. (This stuff is really hard, so we may need to do it somewhat manually at first)
• There’s a whole truckload of other logic needed to support budgets, so we’ll need to figure out how to triage to provide the most actually usable functionality to ourselves, as quickly as possible

More about budget types

Envelopes

Envelopes budgets are small buckets of money that are “filled up” at the start of a weekly or monthly cycle. Examples:

• Money set aside for dining out.
• Cell phone bill
• Rent

Wrinkles:

• What happens when an envelope is overspent? Where does the additional money come from? Another budget? Remaining balance? We can get into a scenario for which the entire unallocated balance is $0.00, and an envelope is overspent, so some concept is needed to understand where the overspent budget should draw its additional money from.
• When an envelope is underspent at the end of a cycle, where does the additional money go? Does it roll over, making it easier to fill for the next cycle? Does it get dumped back into the primary balance, and reallocation starts over from scratch?

Savings budgets

A savings budget is something that begins with a target, and gets filled up over time. Examples:

• Holiday gifts budgets (“I’m setting aside $1,500 to spend on gifts, which I’d like to have available by Nov. 15”)
• Personal savings goal (“I’d like to have saved $2,000 this year to apply to long-term savings”)
• Big purchase goal (“I want to buy a fancy camera, so I’ll set aside a little money each cycle until I get there”)

Wrinkles

• If someone spends against a savings goal before it is complete, does it adjust and effectively expand its ultimate ending value, or does the final amount include anything spent against it? For example, if you have a “Gifts” budget for $1,500, that should be complete by Nov. 15, and you spend $100 against it in September, do you still want $1,500 by Nov. 15, meaning the total allocated in the end will have been $1,600, or will the value of the budget by Nov. 15 be $1,400 remaining to spend?
• Should these be cyclical? Let’s say on Jan 1, I set up a travel budget of $2,000 for the year. By the end of the year, I have $300 remaining. When I set up the next year, do I dump the $300 back into the main balance and start over with whatever values I choose for the next year, and the previous year’s travel budget is effectively archived? Or, does the previous year’s budget carry over, and I start saving towards $2,000 again, but with a $300 head start?

Debt payoff

Debt payoff assumes that either there is a large amount (i.e. car loan or consolidated debt), and it simply needs to be paid down, or it’s constantly changing debt, probably in the form of a credit card. Examples:

• A car loan - The total amount and required payoff date are known, and so regular amounts can be calculated and set aside

[brukeg]

Good stuff Reed, I found this and a few other Python libraries that might remove some complexity https://pypi.org/project/django-ledger/

[brukeg]

Another promising library: https://pypi.org/project/finac/