Budget with Bases

Intro

This article is a continuation of Budgeting in O3PM.

In it, we take an in-depth look at how to use Obsidian’s new Bases feature to make budgeting seamless, structured, and entirely embedded in your project workflow.

Budgeting with Bases in O3PM

Bases in a Nutshell

Bases were introduced in Obsidian 1.9.0 and released to the public in 1.9.10.
Now, everyone can explore this new feature and it’s game changing impact on workflows with structured data in Obsidian.

In O3PM, budgeting is approached in three low-friction steps:

Gathering – Add budget data directly into your notes
Querying – Use Bases to visualize and analyze your budget
Interfacing – Export or present your insights to others

Let’s break that down.

Step 1: Gathering – Storing Budget Information

Budgeting begins already at the very first project step (planning) and is a continious companion all the way to the last (review). The source of budget information can therefore be an estimate, an offer or an invoice.

The gathering step is as simple as taking the budget information from these sources and noting them down. In O3PM, you don’t open an Excel file or spreadsheet-program of your choice you just write it down — right where the work happens.

Where to Store It

There are two ways to store budget information in your vault with their own pros and cons:

Method	Pros	Cons
Inside the object note	+ Everything in one place + Easy context	– Too many properties can clutter the file
In a separate “cost” note	+ Cleaner structure via “divide-and-conquer” & “purity of purpose” + Easy versioning + Room for annotations & history	– Bases (currently) don’t support relational queries, so queries must run on the cost notes only – greater potential file clutter

Either way, the immediacy of work and notes reduces friction and improves quality.

How to Structure the Data

Use frontmatter properties in either the object note or the external cost note. If you’re using the object directly, a cost_ prefix can help distinguish budget properties from operational ones.

Recommended Properties

Here’s a set of properties I’ve found useful across multiple projects:

net — Cost amount
responsible — Person in charge of the entry
source — Origin of cost: estimate, offer, invoice
status — Status of the cost (e.g. planned, booked, paid)
account — Financial account for booking
category — Cost category (e.g. external services, material)
section — Optional sub-cluster (e.g. building, team, phase)
transfer_date — When the cost is expected to hit the budget

You can rename these to your preference, just keep your query logic consistent.

Example: Cost Properties in Object Note

net: -10000
responsible: "[[@ Person 1]]"
source: "[[Estimate - Installation - Component 1]]"
status: "[[DONE]]"
account: "[[Account - Sample Project]]"
category: "[[External Costs]]"
section: "[[Deliverable Car X1]]"
transfer-date: 2025

Step 2: Querying – Using Bases to Build a Budget Table

Bases allow you to define views (like tables or lists) that aggregate information across notes.

Base Example

Here’s a working base that collects cost entries related to a project:

views:
  - type: table
    name: Budget Overview
    filters:
      and:
        - context.contains(link("PRJT - Sample Project"))
        - type.contains(link("Class Cost"))
    order:
      - file.name
      - net
      - source
      - status
      - section
      - category

What This Does

Filters for files with the type [[Class Cost]] and the context [[PRJT - Sample Project]]
Shows a table view sorted by file name and amount
Helps you see at a glance where your budget is going

How it loos

Step 3: Interfacing – Exporting and Sharing

The Basics of Interfaces

The importance of interfaces is often unterestimated in organizations even though a team’s performance hinges on them. Every instance a worker refines a table, reworks a presentation or fine tunes a report it is a symptom of insuffient interface definition.
This article doesn’t cover interfaces, but in the case of Bases I want to present some basics Obsidian offers for efficient interfacing.

Interfacing with Bases

While Obsidian isn’t a collaborative tool yet, it offers lightweight ways to interface with the outside world.
One of the most useful features of bases is the function to copy bases to the clipboard. The workflow is as follows:

Open base
Open command pallete
Type in “Bases: Copy table to clipboard”
Open spreadsheet
Insert data

Keep Your Source of Truth

Any changes made during meetings or workshops can be written back into your cost notes, so your Obsidian vault stays the single source of truth.
That way you stay in control of versioning and content and don’t have to chase down or keep track of conflicting spreadsheets.

Sample Vault

You can find an example vault that covers the budget use case here: https://github.com/JanB987/O3PM-sample-vault

Outro

With O3PM and Bases, budgeting becomes a habit, not a headache.
You’re no longer working around your tools, you’re working within your system.