For several years, I tracked personal finances in monthly spreadsheets. The
system worked, but the format evolved over time, recurring expenses were easy to
miss, and reviewing accounts payable and receivable required navigating many
disconnected files.
When I started consolidating the data, I did not want to create another hosted
application or move sensitive financial information into an external service.
I wanted the data to remain local, portable, and understandable without a
special runtime.
Obsidian provided a useful middle ground: Markdown files for durable storage,
links for relationships, Bases for structured views, and QuickAdd for lightweight
automation.
One transaction, one Markdown file
The central design decision is simple: every financial transaction is an
individual Markdown note with YAML properties.
person:
- "[[FINANCES/PEOPLE/Example person|Example person]]"
movement: pay
period: 2030-01
period_note: "[[FINANCES/PERIODS/2030-01|2030-01]]"
description: Fictional bill
amount: 100.00
due_date: 2030-01-10
status: pending
category:
- "[[FINANCES/CATEGORIES/Other|Other]]"
This is more verbose than a spreadsheet row, but it has useful properties:
- the data remains ordinary text
- every transaction can link to related notes
- Git can show meaningful changes
- searches and scripts do not depend on a proprietary database
- Obsidian can present the same files through multiple views
The source of truth is the transaction note. Dashboards and tables only query
those notes, which avoids having to update the same financial entry in multiple
places.
Relationships through links
People, categories, periods, and recurrence definitions are also notes. A
transaction links to them through properties instead of repeating loosely
normalized text.
This improves filtering and navigation while also making Obsidian's graph and
backlinks useful. The graph is not the primary interface for financial analysis,
but it provides a quick view of how records connect to people, periods, and
categories.
Dashboards with Bases
Obsidian Bases turns the Markdown collection into database-like views without
changing the storage format.
The template includes views for:
- the current month
- pending transactions
- accounts payable and receivable
- completed and cancelled records
- installments and recurring transactions
- expenses grouped by category
- monthly expenses
Movement and status formulas add visual markers so inflows, outflows, pending
items, and completed items are easier to distinguish at a glance.
Recurring transactions without duplicate sources of truth
Recurring expenses initially created an awkward problem. Editing both a
recurrence definition and an already generated monthly transaction meant the
same information existed in two places.
The revised model gives each file a clear responsibility:
- a recurrence note describes the rule
- a generated transaction represents one specific month
- dashboards only read transaction notes
Fixed expenses use their configured expected amount. Variable expenses can use
the latest matching transaction as the starting value for a new month. Charges
already included in a credit card bill can be documented without generating an
additional transaction.
The monthly generator is idempotent: running it again for the same period does
not create duplicate transactions. Installment plans also stop after their final
configured period.
QuickAdd as the interaction layer
Two QuickAdd actions provide the main workflow:
- create a new financial transaction
- generate the transactions for a new month
The scripts create the required period note and transaction file, while the
user still edits ordinary Markdown afterward. QuickAdd is an interaction layer,
not a separate database.
Privacy and portability
The vault is synchronized between devices using an independent file-sync setup.
The finance model itself does not require a cloud account or a finance-specific
provider.
For the public template, generated people, periods, transactions, Obsidian
workspace state, and environment files are excluded through .gitignore. The
repository contains only the reusable structure, scripts, documentation, and
fictional screenshots.
Local-first does not eliminate the need for backups or device security, but it
does keep ownership and portability explicit.
What I learned
This project reinforced a few ideas that also apply outside personal finance:
- A single source of truth matters even in small personal systems.
- Automation should remove repetitive input without hiding the underlying data.
- Plain files can support surprisingly rich workflows when metadata and links are modeled deliberately.
- A useful internal tool does not need to become a hosted product.
- Publishing a sanitized template requires treating privacy as part of the architecture, not as a final cleanup step.
The resulting project is available here:
https://github.com/lksvn/obsidian-finances-template
It includes the empty vault structure, setup documentation, Bases definitions,
QuickAdd scripts, recurrence rules, and fictional screenshots.
Top comments (0)