1. LandOffer
  2. Blog
  3. All articles
  4. Build a Local Job Search Tracker with Obsidian Bases and One Note per Application

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.

10 min readLandOffer team

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.

A job seeker organizes individual application notes into several views of the same records

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.

A note revision remains connected to its original record while view definitions stay separate

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.

Sources and Further Reading