Job search
Build a Local Job Search Tracker with Obsidian Bases and One Note per Application
An original four-note local fixture and a controlled same-note update demonstrate source-preserving application records and multiple views without claiming an Obsidian runtime test.
An Obsidian job-search tracker can use one Markdown note for each application and several Bases views over those same notes. Keep the application facts and next action in note properties; use the base to display and filter them. The same application note can appear in several views without becoming several independent records.
This guide uses current public documentation checked October 21, 2026, plus an independently authored four-note local example. LandOffer publishes this guide and offers job-search tools. No private vault was opened and no Obsidian interface was tested. For new opportunities to review before creating an application record, browse recently posted jobs on LandOffer.

Start with the note, not the dashboard
Obsidian’s Bases introduction describes a core plugin for viewing, editing, sorting, and filtering files and their properties. A table row represents a file; columns show its properties. View definitions live in a .base file or an embedded code block, while application data remains in the underlying local Markdown notes.
This lets you keep the context behind each application alongside the facts you need to scan. Open a row to return to the role description you reviewed, your fit assessment, interview preparation, and the dated evidence behind the current status. Properties hold the small facts needed across applications. The table is a way to work with those notes, rather than a separate list that you must reconcile manually.
Bases is no longer only an early-access idea. The public October 5, 2026 desktop 1.14.4 release includes Bases improvements and a kanban layout. This tutorial deliberately uses table views and documented syntax. Check your installed version and core-plugin availability if the controls differ; no update, installation, or plugin change was performed for this guide.
Use one stable application identifier and include the employer’s requisition where available. Two applications at one employer need two notes if they concern different roles. Conversely, a phone screen and a later technical interview for the same application belong in the existing note’s history, not in duplicate application notes.
Define a small, consistent property contract
The official properties documentation places structured values in YAML at the top of a note. Property types include text, lists, numbers, checkboxes, dates, and dates with time. A type assigned to a property name applies across the vault, so reuse names consistently instead of making review_date a date in one note and a free-form paragraph in another.
For this example, the contract is intentionally modest:
| Property | Meaning in this tracker |
|---|---|
record_type |
job_application, distinguishing these notes from employer research and other files |
application_id |
Your stable identifier, such as APP-001 |
company, role, requisition |
Role identity; company name alone is insufficient |
status |
One of Research, Applied, Interview, or Closed, with your evidence defining the transition |
next_action |
One concrete action, or an explicitly empty string when missing |
review_date |
A personal review date, not automatically an employer deadline or interview appointment |
source_reference |
Enough information to locate the relevant original posting or correspondence |
These statuses are editorial choices, not built-in Obsidian hiring stages. “Applied” should mean you have submission evidence; saving a job link does not establish that an application was sent. “Interview” should reflect the actual invitation or scheduling evidence recorded in the note.
Keep long explanations below the properties. YAML is a poor place for an interview debrief, and Obsidian’s property editor intentionally does not render Markdown formatting inside property values. A short next action such as “Prepare concurrency example” belongs in a property; the example itself belongs in the note body.
Worked example: four notes, three views
The following completed fixture uses invented employers and roles. It is a local editorial example, with no real applications or messages. Before a later update, Applications/APP-001.md begins:
---
record_type: job_application
application_id: APP-001
company: Northbank Robotics
role: Platform Engineer
requisition: NR-27
status: Applied
next_action: Check submission receipt
review_date: '2026-10-22'
source_reference: Fictional editorial source APP-001
---
The note body contains an “Evidence and decisions” section. In a real record, this is where you would explain what was submitted, identify the receipt, and distinguish your interpretation from the employer’s wording. The example’s source reference is deliberately fictional rather than a fabricated application confirmation.
Three other completed notes make the views meaningful. APP-002 is Juniper Parcel’s Site Reliability Engineer role JP-84, at Interview with an empty next action. APP-003 is Atlas Grove Labs’ Data Engineer role AG-15, marked Closed. APP-004 is Northbank Robotics’ separate Developer Tools Engineer role NR-31, at Research with “Review requirement fit” as its next action.
A single Applications.base defines the views. Its shared filter restricts the dataset to Markdown files in the Applications folder with the expected record type. This matters because a base otherwise includes every file in the vault, according to the syntax documentation.
The essential configuration is:
filters:
and:
- 'file.inFolder("Applications")'
- 'file.ext == "md"'
- 'note.record_type == "job_application"'
formulas:
role_label: 'company + " / " + role'
views:
- type: table
name: Active
filters:
and:
- 'status != "Closed"'
- type: table
name: Missing next action
filters:
and:
- 'status != "Closed"'
- 'next_action == ""'
- type: table
name: Closed
filters:
and:
- 'status == "Closed"'
The saved full example also specifies displayed columns. The completed membership check is:
| View | Expected application notes | Review result |
|---|---|---|
| Active | APP-001, APP-002, APP-004 | Three ongoing records, including one not yet applied |
| Missing next action | APP-002 | Interview-stage record needs an action before the tracker is useful |
| Closed | APP-003 | Retained history, excluded from the active work list |
An existing local Python environment parsed the four notes’ YAML and the three-view base, checked unique application identifiers, and independently calculated these memberships. The saved run verifies YAML parsing, four unique application identifiers, text-valued status and action fields, and the independently calculated membership lists. It does not establish that Obsidian rendered the base, evaluated its expressions, or saved property types exactly as intended.
Understand what the formula does—and does not do
The simple role_label formula combines company and role for display. It does not create a new application, rewrite the employer’s job title, or become the authoritative identity field. The requisition and stable identifier remain necessary even when two displayed labels look similar.
The formula guide distinguishes note properties, built-in file properties, and calculated formula properties. company is shorthand for a note property; file.name describes the file; formula.role_label references the calculated field. Formula definitions are stored as strings in YAML, and their output type depends on the expression.
Avoid using file.mtime as “last recruiter contact.” It is the file’s modification time, which can change when you edit your own preparation notes. If last contact matters, record an explicit property supported by the original conversation. A formula can calculate from a date you entered; it cannot prove the employer contacted you on that date.
This example uses next_action == "" under a deliberate contract: all four notes contain a text value, and missing actions are represented by an empty string. It does not claim to catch absent keys, nulls, spaces, or every malformed import. If you bring in older notes, inspect and normalize those cases before treating the missing-action view as complete.
Also distinguish the global and per-view filters. Obsidian combines them with AND. A view cannot recover a note excluded by the shared folder or record-type filter. If a record appears to vanish, inspect its path and properties before creating another copy.

Worked example: update the same application once
The second completed artifact is a controlled update to APP-001. In the fictional scenario, a new invitation changes Northbank Robotics’ Platform Engineer application from Applied to Interview. The next task becomes preparing a concurrency example, with a personal review date of October 24.
The actual local file exercise edits those three properties in the existing note and appends a dated change journal. It preserves the application identifier, employer, requisition, and original body. The journal explicitly says the invitation is fictional; it is not presented as evidence of an employer event.
| Check | Before | After the authored local update |
|---|---|---|
| Application identifier | APP-001 | APP-001, unchanged |
| Status | Applied | Interview |
| Next action | Check submission receipt | Prepare concurrency example |
| Personal review date | October 22 | October 24 |
| Number of application notes | Four | Four |
| Base definition | Existing three-view file | Same SHA-256 hash |
The note’s SHA-256 hash changes, while the base’s hash remains unchanged. That demonstrates the file-level point: the application’s data can change without copying it into another dashboard or editing the view definition. The saved before-copy, updated note, and run log let you inspect exactly which three properties changed and read the appended journal.
This is not an in-app synchronization test. No Obsidian vault was opened, no live property edit was observed, and no cross-device conflict or refresh behavior was tested. In your own isolated trial, check that editing the note and editing its table cell refer to the same property before trusting the workflow with important deadlines.
APP-001 remains active after the change. APP-002 still needs a next action. Updating one record should not hide a missing task on another; reviewing both views is what turns stored information into a manageable work list.
Keep local-first storage separate from privacy and backup
Obsidian’s data-storage guide describes a vault as a folder of local plain-text files. It also describes syncing through Obsidian Sync and other services. The location of your Markdown therefore does not by itself establish that nothing leaves your computer.
Review the folder’s sync location, installed community plugins, sharing tools, and any AI integration you choose to add. This workflow needs no AI service to store the sample properties or define the views. Adding one would require its own data-flow review; “local-first” is not a blanket privacy conclusion about every extension or configuration.
Back up the application notes together with the .base definition. Copying only the base preserves the view configuration without the application records. Copying only the notes preserves the underlying facts but leaves you to recreate the views. A CSV export may be useful as a dated handoff, but it should not silently become another editable master tracker.
Finally, keep employer deadlines separate from personal review dates and calendar events. A base is useful for seeing tasks, not evidence that a reminder will fire or an interview is booked. Before relying on a reminder integration, test its trigger, delivery, and time-zone behavior separately from whether the note appears in a view.
Review naming and transitions before expanding
Write a brief definition for each status beside your template. In this example, Research means fit review remains open; Applied requires submission evidence; Interview requires an invitation or scheduling record; Closed means you have deliberately stopped active work on that application. A recruiter conversation that has gone quiet does not automatically prove rejection, and a Closed value should not erase the reason for closing it.
Keep the employer's requisition separate from your identifier. If the posting disappears, your APP identifier still locates the note, while the requisition helps distinguish the employer's records. If you later discover that two saved postings describe the same application, compare the source references and histories before consolidating anything. Compare requisitions and source histories as well as titles before treating two records as duplicates.
For maintenance, review the missing-action view first, then the active list. Read the note behind any surprising row. Check whether a changed status has a dated explanation and whether the review date still makes sense. These are manual review decisions in this workflow; no background script watches your inbox or advances applications for you.
Use the tracker to decide the next action
Begin with a few applications and inspect the underlying notes after each change. Make sure a research-stage opportunity stays distinct from a submitted application, one employer’s two requisitions remain separate, and closed records disappear only from the active view rather than being lost.
The fixture’s result is deliberately actionable: APP-002 needs a next action; APP-001 needs preparation; APP-004 still needs a fit review. When you find another recent opportunity on LandOffer, create one identifiable note and preserve its evidence. Add views only when they help you make a decision from those same records.
