Introduction

Personal knowledge bases (PKB) help us capture, connect, and retrieve information over time. By combining lightweight formats like Markdown with simple linking conventions and occasional review, you can build a system that supports learning, writing, and decision-making.

This guide walks through choosing a model (Zettelkasten, PARA, evergreen notes), selecting storage and tooling, creating effective note templates, linking strategies, and review routines. It is aimed at knowledge workers, students, and creators.

1. Models and philosophies

Zettelkasten

• Focus: atomic notes linked into a web of thought.
• Each note captures a single idea and links to related notes.

PARA (Projects, Areas, Resources, Archives)

• Focus: organizing files and notes by activity and lifecycle.
• Useful for keeping project work separate from evergreen knowledge.

Evergreen notes

• Focus: durable, reusable notes that grow over time and serve as seeds for writing.

2. Storage and tooling options

• Flat Markdown files in a Git repo (portable, versioned).
• Obsidian (local, backlinking, plugins).
• Notion (cloud, block-based, collaboration).
• Local static site + search (e.g., Eleventy, Hugo) for publishing and searching.

3. File and note conventions

Use consistent frontmatter for metadata (title, tags, created, updated). Example:

---

title: “Atomic note title” created: 2026-05-24 tags: [concept, neuroscience]

Small, focused notes are easier to connect and reuse.

4. Linking strategies and backlinks

• Use explicit links to related notes: [[note-id]] or relative links.
• Maintain an index or MOC (map of content) for major topics.

5. Templates and templates for capture

Capture template (quick notes):

• Title
• Source (URL/book/page)
• One-sentence summary
• Key quote or excerpt
• Tags

Evergreen note template:

• Title
• Summary
• Links to supporting notes
• How I might use this idea (writing, teaching, project)

6. Daily and weekly workflows

• Daily: capture quick notes, triage inbox, link new notes to existing ones.
• Weekly: review recent notes, flesh out evergreen notes, and add tags.

7. Search, retrieval, and writing pipelines

Use tags, backlinks, and a good search index. When writing, start from a set of linked evergreen notes and expand into a draft.

8. Long-term maintenance and pruning

• Merge duplicate notes.
• Archive obsolete project notes.

9. Integrations and automation

• Use small scripts to export highlights from Readwise or clip from the web to Markdown.
• Automate backups with Git and cloud sync.

10. Case study: turning notes into a blog post

11. Identify the seed note (evergreen idea).

12. Gather linked supporting notes and sources.

13. Draft a structure using the MOC and expand sections into paragraphs.

14. Privacy and version control

• Store sensitive notes encrypted if necessary.
• Use Git for versioning; tag releases when publishing.

12. Advanced tips

• Use incremental writing: write a paragraph a day.
• Keep a “literature note” for every source you read.

13. Checklist

• Choose storage and establish a template.
• Start with a small set of linked evergreen notes.
• Review weekly and publish monthly.

Conclusion

Building a PKB is a long-term practice. Start small, be consistent, and prefer links over categories — the web of connected notes is where the value accumulates.

14. Detailed examples and templates

Example note: Literature note (book)

---

title: “On Writing Well — Key Ideas” created: 2026-05-24 tags: [writing, craft, book] source: “Bill Zinsser — On Writing Well”

• One-sentence summary: Clear writing is an act of clarity and simplicity.
• Key ideas:
  • Remove clutter; prefer strong verbs.
  • Rewrite sentences to highlight the subject.
• Links: [[writing-basics]], [[editing-techniques]]

Example note: Evergreen note (idea)

---

title: “Atomic notes improve recombination” created: 2026-05-24 tags: [zettelkasten, workflow]

• Summary: Notes that capture single, testable ideas are easier to recombine into novel arguments.
• How I might use this idea: seed for an essay on learning techniques.

15. Practical scripts and automation

Readwise and clipping

• Use Readwise to centralize highlights from Kindle and web clippings; periodically export to Markdown for your vault.

Simple export script idea (pseudo steps):

1. Use Readwise API to fetch highlights.
2. Convert JSON to Markdown files with frontmatter.
3. Save in inbox/ folder for triage.

Git-backed vault and publishing

1. Store your vault in ~/notes/ as a Git repo.
2. Use a GitHub Actions workflow to render and publish a static site from selected notes.

Example GitHub Actions snippet (publish to GitHub Pages):

name: Publish Notes
on:
  push:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build site
        run: |
          npm ci
          npm run build
      - name: Deploy
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./dist

16. Migration and interoperability

• Export from Evernote/OneNote using ENEX or export tools and convert to Markdown.
• Use pandoc for format conversions when needed.

17. Review and spaced repetition

Incorporate a lightweight spaced repetition system for key facts using Anki or a text-based SR workflow. Link flashcards to evergreen notes for context.

18. Collaborative notes and sharing

If collaborating, use shared Git repos or cloud tools with clear contribution guidelines. Keep personal notes private and separate from collaborative documents.

19. Case study: From notes to a book chapter

Process:

1. Identify the seed evergreen note that captures the chapter’s thesis.

2. Gather supporting literature notes and experiments.

3. Create an outline in a draft note and fill sections by concatenating and rewriting linked evergreen notes.

4. Iterate and publish.

5. Final checklist and next steps

• Pick one primary tool (Markdown + Git or Obsidian).
• Create an inbox folder and a weekly review routine.
• Write one evergreen note per week and link it to at least two existing notes.

Further reading

• Sönke Ahrens — How to Take Smart Notes
• Tiago Forte — Building a Second Brain

Closing encouragement

Start with capturing one idea today and link it to something you already know — the network grows from there.