Second brain5 min read

Why your Notion database isn't the right place for a journal

Notion is excellent at structure and a journal resists structure. Why the daily-entries database tends to die by month three, and what to do instead.

Almost everyone who uses Notion seriously has built a journal in it at some point. A database, a date property, a mood select, maybe a relation to a Projects table. It is a satisfying hour of work and it produces something genuinely elegant.

Most of these die around month three. That is worth examining, because the reason is not laziness and it is not Notion being bad.

What Notion is actually for

Notion is a structured-data tool with a document interface. Its real power is in databases: typed properties, relations, filtered views, rollups. Give it things that share a shape — tasks, clients, recipes, reading — and it is superb. The database model is the product.

That power has a precondition. Structure pays off when the items are similar enough to compare, and when you know in advance which dimensions matter.

A journal violates both.

Why journals resist the database model

The schema is a guess, and it is wrong. You decide the fields in week one, when you know least. Mood, energy, maybe tags. Six months later the thing you want to track is something you had no word for in January — and your historical entries have no value on that dimension, because the column did not exist.

Properties become a tax. Every field is a small decision at the moment of writing. Choose a mood. Pick tags. Set the relation. Individually trivial; collectively, this is the thing that kills the habit. Journalling has to be nearly frictionless on the bad evenings or it does not survive them, and it is precisely the bad evenings whose entries matter most.

Structured fields crowd out the writing. The visible scaffolding is the mood select and the tag list, so those get filled in. The paragraph gets shorter. Eventually you have twelve months of mood ratings and almost no prose — a dataset with nothing in it, since the prose was the asset.

Tags cannot be assigned in advance. You can only tag what you have already named. The recurring thing you have not yet noticed — which is the whole point of keeping a journal long enough — is by definition untagged. The taxonomy can only ever encode what you already knew when you built it.

A filtered view is not reading. You can filter to every entry tagged work. That returns the entries you remembered to tag, in a list. It is not the same as being shown that one subject ran continuously for eleven months under three different labels.

The deeper mismatch

Notion asks you to declare the structure up front and then fills it in.

A journal works the other way round. You write without structure, and the structure is discovered later, in hindsight, by reading back. The shape of 2023 was not knowable in January 2023. It becomes visible in 2025, by looking.

Any tool that requires the taxonomy first is asking you to do the impossible part first. That is why the elegant database decays into a date and a paragraph within a few months — people are quietly routing around the mismatch, correctly.

Where Notion genuinely wins

Be fair about this, because it is a good tool and the answer is not "never use it".

  • A work log or decision log. These genuinely do have a schema: date, project, decision, reasoning. Notion is excellent here and better than a journal app.
  • Anything collaborative. Journals are single-player; Notion is not.
  • A journal as part of a larger system. If everything else is already in Notion and the main benefit is one place, that may well outweigh the rest of this article.
  • Highly structured tracking. If you really do want numeric daily ratings over two years, a database is the right shape and a journal app is the wrong one.

The failure case is specific: using a database for open-ended reflective writing you intend to read back years later.

What the alternative looks like

What a long-lived journal actually needs:

  • Near-zero friction to write. Open, type, done. No required fields.
  • Reliable dates. The one piece of structure that is always knowable and always useful.
  • Full text preserved, not summarised into properties.
  • Structure discovered afterwards, from what you wrote, rather than declared beforehand.
  • An exit. Plain text out, whenever you want it.

That last one matters more in Notion's case than people allow. Notion exports to Markdown and CSV, which is better than most, but a database of entries with properties exports as something considerably less portable than a folder of dated text files.

The fourth point is the one that changes the experience most. Letting the themes assemble from the writing — rather than from tags chosen in advance — is the difference between finding out what you have been circling and confirming what you already labelled. That is the thing Ember is built around: no schema to design, and the recurring subjects surface from the entries themselves.

If you want to move

Notion exports reasonably well, which makes this straightforward.

  1. Export the database as Markdown & CSV. You get a CSV of properties and a Markdown file per entry.
  2. Check the dates survived. This is the part that matters; everything else is recoverable and dates are not.
  3. Bring the Markdown or the CSV into whatever you are moving to — Ember reads both, along with PDF, HTML and plain text.
  4. Keep the Notion database. There is no reason to delete it, and the properties you did fill in are a record of what you thought was worth tracking.

Expect to lose the relations and most of the properties. Those were scaffolding; the writing is the building.

The honest test

If your Notion journal is working — you write in it most weeks, you have read it back at least once, and it told you something — then it is working, and nothing here applies. Tools are not won on theory.

But if you have a beautifully designed database containing nine entries from February, the design is not the problem and neither are you. You built a structured tool for an unstructured activity, which is a reasonable mistake to make given how well Notion does everything else.

The writing is the part worth keeping. Getting it somewhere that will read it back is a better use of an afternoon than redesigning the schema again.

A journal that reads itself back

Ember reads across everything you write and surfaces what keeps returning. Bring an old archive with you, or start tonight.

Keep reading

  • Second brain

    Journaling with Claude: a workflow

    Using a model you already talk to as a thinking partner for your own writing, without handing it the job of deciding what your life means.

    5 min read