The zettel system

A flat note-taking system for clear thinking

I have spent years experimenting with different ways of taking notes — from analog paper to almost every major digital note‑taking system. I also tried to implement well‑known organizational methods like PARA by Tiago Forte or Zettelkasten. However, after an initial phase of excitement, I always ended up struggling, without fully understanding why. Some systems worked for a while, but most eventually collapsed under their own weight. The most painful part was migrating from one setup to the next. My last journey took me from Apple Notes to Notion, and finally to Obsidian. While I was excited by Obsidian’s simplicity, I struggled with how to structure the vault. The more structure I added, the more friction I felt whenever I wanted to capture a simple idea. Eventually, I reached a point where I no longer wanted a "perfect system" — I wanted something that faded into the background and simply let me think.

This is how I arrived at my current note‑taking system, which I call zettel. It is extremely simple: one folder, a flat structure, no sub-directories. Notes are organized not by where they live, but by what they are. It complements my analog notebook rather than replacing it. Its single purpose is to collect knowledge, process it, and turn it into something I can use — whether that’s a newsletter, a talk, a book idea, or a future project.

My Requirements

I tried to keep my list of requirements straightforward — aiming for a simple, frictionless note‑taking system:

• Text-based notes written in Markdown

• A flat directory structure

• No need to think about filenames or where to put them

• General compatibility with Obsidian

• Optimized for my main editor, Neovim

• Mobile-friendly (should work on my iPhone as well)

• Easy backup options

Those requirements might sound almost too basic, but they became my guiding principles. The more I experimented with complex systems, the more I realized that complexity was the problem, not the solution. I didn’t want a tool that demanded constant maintenance; I wanted one that disappeared into the background so I could focus on my work — thinking, writing, creating.

Over time, this led me to a flat structure with just one folder: no sub‑folders, no nested hierarchies, no elaborate naming conventions. Every note is equal. Organization happens inside the file, not outside of it. Instead of relying on where something is stored, I focus on what it is.

Structure and IDs

Each note is stored as a plain markdown file. The filename itself is deliberately meaningless — just an ID composed of the creation date and a random three‑digit number:

2025-07-24-042.md

The filename is purely technical; I never try to encode meaning into it. The only indicator is the date for a rough time indication. The actual title and metadata live in the note itself, inside a simple YAML frontmatter. This also means I can rename titles freely without breaking links.

Frontmatter and Tags

Every note begins with three essential fields:

---
id: 2025-07-24-042
title: Idea for a new workshop
tags: [note]
---

The id matches the filename, title is whatever makes sense for me, and tags define the function of the note. This is the core of the system: tags describe what the note is, not where it belongs.

Instead of folders, I rely on a small set of functional tags that describe the role of each note:

• note – thoughts, observations, reflections, ideas (default)

• capture – material from outside sources (books, articles, videos, podcasts)

• meeting – notes from conversations or events

• journal – daily reflections or logs

• content – polished pieces intended for publication (newsletter drafts, blog posts)

• meta – hub notes that link other notes together (e.g., for people or themes)

• view – dynamic queries to create filtered lists (more on this later)

Beyond these functional tags, I sometimes add thematic ones like life, work, learn, or create to mark broader areas of focus.

Status and Workflow

A simple status field lets me track the progress of a note — idea, draft, done, or published. This way I can query for all notes in “inbox” or “draft” status without needing extra folders.

What I like about this approach is that it scales naturally. I don’t have to reorganize anything when I start a new project. Notes evolve, tags shift, and connections emerge organically.

Some note types have their own additional fields — for example, author and source for captures, or participants for meeting notes. The system doesn’t force these fields; I only add them when they add value.

Working Without Folders

Because there are no folders, search and filtering become essential. In Obsidian, I use the Dataview plugin to build simple queries, like “show me all notes tagged content and still marked as draft.” In Neovim, I built my own plugin, zettel.nvim, that generates similar views directly in the terminal. The plugin is lightweight and designed for this flat structure — I’ll explain it in detail in the next post.

This approach might sound chaotic at first — everything dumped into one place — but in practice, it’s surprisingly calm. The system doesn’t fight me. I don’t need to maintain a tree of folders, and I don’t lose anything, because tags and queries give me the organization I need exactly when I need it.

Assets and Templates

Notes can also include additional resources, such as images or documents. These are stored in an _assets folder, separate from the actual notes. Templates can be helpful when working in Obsidian, but they are even more useful with my zettel.nvim plugin, which I will describe in more detail in a later post.

Analog + Digital

I still keep a paper notebook for daily sketches, thoughts, and drafts. It’s faster, freer, and helps me think without a keyboard. But when something is worth keeping — an insight, an idea, a quote — it moves into the digital system. The analog side fuels the digital side; the digital side archives and connects everything long‑term.

Why It Works for Me

This system is minimal, and frictionless. It gives me enough structure to stay consistent without locking me into rigid workflows. It plays well with the tools I love — Obsidian for visual browsing (e.g. graph view), Neovim for focused writing — but it’s also portable. At its core, it’s just plain text files in a folder. No lock‑in, no proprietary formats, no fear of outgrowing the system.

Most importantly, it keeps me moving. Capturing an idea takes only seconds, and turning it into content feels natural. Because everything is flat and tagged, old notes often resurface in new contexts — a small quote from a year ago might suddenly connect to a project I’m working on today. I’ve also added a simple way to capture thoughts as voice messages on my iPhone, which are then automatically transcribed into inbox notes. I’ll share more about this workflow in a future post.

Next: The Tooling Behind It

This post is about the system — the philosophy and structure. In the next one, I’ll dive into the tool I built to support it: zettel.nvim. It’s a small Neovim plugin that makes this flat approach practical: automatic ID generation, tag-based views, simple queries, and minimal friction for daily use.

If you’re interested in first‑principle tools and low‑noise workflows, you might enjoy what’s coming next.

Build. Write. Share.
That’s the idea behind craftpurist — and this is where it begins.