Skip to content
Velloreth
Education 12 min read

Building a Personal Knowledge Base

How to turn scattered notes into a system you actually retrieve from — atomic notes, links versus folders, a workable workflow, tools, and common anti-patterns.

By

Most people do not have a note-taking problem. They have a note-retrieving problem. The inbox fills, the documents accumulate, and eighteen months later nothing comes back out — not because the notes were wrong, but because nothing forced a path from the note back to you at the moment you needed it.

A personal knowledge base is a system designed around that return trip. Storage is the easy half; the design question is how a note written today becomes findable, connectable, and useful in a context you cannot currently predict.

The retrieval problem comes first

Before choosing tools, decide how you expect to find things again. There are basically four bets:

MechanismHow it retrievesWeakness
FoldersYou remember which category it belongs toMost ideas belong to several categories; hierarchies force one choice
TagsMultiple labels per noteTag sets sprawl; inconsistent naming silently splits results
LinksYou arrive via a related noteRequires related notes to exist; useless in a small collection
SearchYou remember a distinctive wordDepends on your phrasing and on the note containing it

Every system uses all four to some degree, but one is primary. The classic Zettelkasten bets on links; PARA bets on folders organized around action; most note apps end up with search as the real mechanism, which works until you cannot remember the term.

Pick one honestly: if you will never maintain links, do not design a system that requires them. A folder tree you actually keep beats an interconnected graph you abandoned in week two.

Capture less

The instinct at the moment of reading is to save everything, because saving is cheap and feels productive. It also creates the failure mode: an inbox so large that opening it is aversive, which means nothing gets processed, which means the system never delivers a single retrieved note.

The filter to apply at capture: would I want to use this in something I will write, decide, or explain? If the answer is “maybe someday,” it is not a note — it is a bookmark, and a browser folder serves that purpose without polluting the system.

Practical consequences:

  • Save ideas, not containers. A note about the argument an article makes is worth more than the article.
  • A citation is not a note. Keep the reference — title, author, page — so you can return to the source, without copying its structure into your system.
  • Process on a schedule. A weekly session that clears the inbox beats a daily session you skip and a monthly session you dread.

Atomic notes: one idea, your words

Two properties do most of the work in a good knowledge base.

One idea per note. A note titled “Kubernetes networking” containing eleven topics can only be retrieved as a whole and linked as a whole, so it will be linked to nothing. Split it: one note on how a Service resolves to pods, one on why hairpin traffic behaves oddly, one on NetworkPolicy defaults. Small notes are reusable units — you can cite one from three different contexts without dragging the others along.

Written in your words. This is not stylistic preference; it is the encoding step. Rephrasing forces you to decide what the idea actually claims, which is the same cognitive work as retrieval practice. A clipped paragraph is the author’s sentence in your file — it retrieves as their text, not as your understanding.

A workable test: could this note stand alone if the source disappeared? If reading it later requires reopening the article, you stored a pointer, not knowledge. If it reads as a self-contained claim with enough context to disambiguate, it is a note.

Structure: what Luhmann actually did

The Zettelkasten method is worth examining because it is the strongest historical counterexample to “organize by topic.”

Niklas Luhmann, a German sociologist, built a slip box of roughly 90,000 handwritten cards over about four decades and credited it with enabling an unusually large body of work — on the order of 50 books and 550 articles. The system’s design, documented in archival studies of the collection, has four parts:

  1. Fixed positions, not topic order. Each card received a number that never changed — 1/1, then 1/2, and later insertions as 1/1a, 1/1a1 — so a new card could be placed next to any related card without reorganizing anything. The alternative, a topic hierarchy, would have required deciding in 1965 where every future idea belonged.
  2. Branching. Numbers could grow inward indefinitely, so a thought could be extended, qualified, or split without breaking the sequence.
  3. References. Cards pointed at other cards elsewhere in the box — an estimated tens of thousands of internal links across the two collections. The links, not the numbering, are what made it generative: a card could be reached from several directions.
  4. A keyword index as the entry point. The second collection’s index held about 3,200 entries, and deliberately listed only a few locations per keyword — the rest were expected to be found by following references from those starting points.

The lesson is not “buy a wooden card box.” It is that position and links are enough to retrieve, if you are consistent, and that a topic-based classification was explicitly rejected as too constraining over decades of use. If you take one thing: number or identity each note permanently, and make linking the habit that replaces filing.

For many people, folders remain the more honest primary mechanism — which is the basis of PARA: organize by Projects (things with a deadline), Areas (ongoing responsibilities), Resources (topics of interest), and Archive (everything inactive). It is action-oriented rather than topic-oriented, and it works because the top-level question — “what is this for?” — has a stable answer.

Note types

Keep four kinds, and only four:

  • Inbox — unprocessed captures. Should be short-lived.
  • Literature notes — what a source said, compact, with the citation. One per source, not per idea.
  • Permanent notes — the atomic, in-your-words ideas. This is the actual collection.
  • Map of content (MOC) — an index note that links to a cluster, replacing a folder for that topic. “Distributed systems MOC” is a note containing links; you can have one per area you actively work in.

The MOC deserves emphasis: it gives you folder-like entry without folder-like exclusivity, since a note can belong to several MOCs at once — which is precisely what the folder bet cannot do.

The workflow

  1. Capture into the inbox while reading or working — fragments are fine here, because they are temporary.
  2. Process weekly. For each item: keep or delete. Deleting is the most valuable decision available and the one people avoid.
  3. Rewrite kept items as permanent notes — one idea each, own words, standalone.
  4. Link to two or three existing notes. Two is enough; the constraint forces you to actually look at where the idea fits. Include backlinks if your tool does not.
  5. Add to an MOC or create one if the topic is new.
  6. Let some notes fail to connect. A note with no links is not a failure; it may find its partner later. A note that is impossible to keep because you could not decide its place is the real failure — place it anywhere and link from it.

The step most often skipped is 4, and it is the one that makes the system work. Links are built at capture time while you still know which notes are relevant; you will not reconstruct those associations later from memory.

Worked example: notes from one article

You read an article arguing that most distributed systems outages are caused by retries amplifying load rather than by the original fault. In your inbox you drop a fragment: “retries amplify — cascading failure from the client side, not the server.”

During weekly processing, that fragment becomes two permanent notes:

Note 1: “Retry storms as a failure amplifier”

A transient fault at one service can become a sustained outage when every client retries at once. The retried requests add load to an already degraded service, pushing recovery further away. The mechanism is positive feedback: more failures cause more retries, which cause more failures. Mitigations include exponential backoff with jitter, a retry budget (a cap on retried requests as a fraction of successful ones), and circuit breakers that stop retrying a service that is clearly down.

Related: [[circuit-breaker-pattern]], [[backpressure-vs-throttling]]

Note 2: “Jitter prevents synchronized retries”

If every client retries after the same fixed delay, they retry in lockstep, producing a thundering herd exactly when the service is trying to recover. Randomized (jittered) delays spread the retries over time so no single moment carries the full burst. This is the same principle behind randomized timeouts in distributed consensus and randomized polling in leader election.

Related: [[retry-storms-as-a-failure-amplifier]], [[distributed-locking]]

Two notes, each one idea, each standalone, each linked. The article itself stays in your sources folder with a citation; you do not need it again unless the notes turn out to be wrong. Six months from now, when you are designing a client library and someone asks whether to add retries, you search “retry” and find both notes in under a minute — or, more likely, you arrive at the circuit-breaker note from an unrelated MOC and the retry note is one link away.

Notice what did not happen: you did not save the article as a clipped page, you did not write a summary of the whole piece, and you did not create a folder called “Distributed Systems” and file the summary there.

Review cadence

Beyond the weekly inbox session, a monthly pass over the MOCs you care about is enough for most people. Open each active MOC, follow one or two links at random, and update anything that has gone stale. This is not archiving; it is keeping the entry points honest. An MOC that lists a note you have not thought about in a year can stay — the cost of keeping it is low — but an MOC missing the three notes you added last month costs you a retrieval path.

Luhmann reviewed his slips often, not because the system required it, but because the review produced new connections. Your version does not need that discipline; it needs the MOCs to not lie about what exists.

Tools

OptionStrengthsCosts
Plain Markdown folder + gitPortable, versioned, works anywhere, no vendor riskNo backlinks or graph; search depends on your editor
ObsidianLocal files, backlinks, graph, large plugin ecosystemElectron footprint; plugin sprawl can become the hobby
LogseqOutline-native, daily notes, block-level linkingOutline structure suits some material poorly
NotionDatabases, collaboration, polished UISlower, cloud-dependent, awkward for plain text portability
Org-mode / EmacsExtremely capable for structured and literate notesTool commitment is high

Any of them works. The two failure modes to avoid are choosing a tool whose friction you will not pay daily (web apps you must log into, mobile-only capture with no processing path) and spending so much time configuring that the capture-to-link loop never becomes habit.

Plain Markdown with git is the safe default: you can leave any other tool at any time, and the files outlive the application.

Retrieval in practice

  • Search before you browse. Know one distinctive term and search beats navigating. This is why writing specific titles (“Service DNS resolution path” rather than “Networking notes”) matters more than folder depth.
  • Enter from any related note. The links mean you rarely start at the index; you start near the idea and walk.
  • Maintain the MOCs you actually use. An MOC that has not been opened in six months is decoration; merge it or drop it.
  • Rewrite on retrieval. When you pull a note into a document or decision, update it with what you learned since. Notes that get used get refined; notes that are only stored rot.

Anti-patterns

  • Hoarding. Capture rate far above processing rate. The symptom is an inbox you avoid; the fix is deleting aggressively at capture.
  • Perfect taxonomies. Spending a weekend designing a four-level hierarchy that no future note will fit cleanly. Structure should grow from use.
  • Tag sprawl. Dozens of overlapping tags, near-duplicates, and no index of what exists. Two or three tag dimensions at most, applied mechanically.
  • Verbatim clipping. Storage without encoding; you have built a quotation database.
  • Linking without reading your own notes. Adding links because the system wants them, to notes you never revisit — this produces a graph nobody traverses.
  • Tool churn. Migrating every year, which resets links and momentum while feeling like progress.

A minimal starter spec

If you want something to begin with rather than a framework to evaluate:

notes/
  inbox/           # unprocessed fragments, cleared weekly
  permanent/       # atomic notes, one idea each
  sources/         # one literature note per source, with citation
  moc/             # index notes per active topic
templates/
  note.md          # title, tags, 1-sentence summary, links

A note template worth keeping small:

# <specific claim or idea, not a topic>

<two to six sentences in your own words>

Source: <citation, page>        # only for notes from reading
Related: [[note-a]], [[note-b]]

Start with the folder, the weekly processing session, and the discipline of writing one idea per note in your own words. Add backlinks, graphs, and plugins only when you have enough notes that finding them becomes the actual problem — at which point the retrieval bet you chose will be obvious, and changing systems will be a decision rather than a hope.

Frequently asked questions

Do I need a special tool like Obsidian or Logseq?
No. A folder of plain Markdown files with a git remote gives you portability, search, version history, and no vendor risk, and it works in any editor. Tools that add backlinks, graph views, and daily notes are genuinely useful for linking-heavy workflows, but the system design matters more than the application — a sophisticated tool holding unprocessed clippings still retrieves nothing.
How is this different from a notebook or a document?
Scale and structure. A notebook is linear, so a note about a topic you wrote two years ago is only findable if you remember where it is. A knowledge base gives every note a stable identity and links it into a network, so you enter from any related idea and travel to the one you need.
How many notes should I take from a book or article?
Far fewer than you want to. Take the ideas you would want to reuse in your own writing, decisions, or explanations — usually a handful per source — and write them as standalone notes rather than a chapter-by-chapter summary. Everything else can stay as a citation with a page number; you can always go back to the source if the need is real.
What do I do with an inbox of unprocessed notes?
Process it on a schedule, not opportunistically: once a week, take each item, decide whether it is worth keeping, rewrite anything worth keeping in your own words, link it to two or three existing notes, and delete the rest. An inbox that has not moved in a month is a sign the capture rate is too high, not that you are busy.