Note Taking and Knowledge Management are big things in today’s world. I did not yet find the perfect solution, but I found quite a set of solutions that in the end did not work out for me. I would like to write them down, and why they did not work out for me.

The beginning: Apple Notes

When I got into the age where taking notes became interesting, my phone was an iPhone. So I naturally started with Apple Notes. I mainly used it to write down some minor stuff or store links that I didn’t want to loose. Nothing fancy, and back then I definitely did not have in mind to store knowledge for a longer time.

DailyNotes

Then I started self hosting. One of the first relevant things I hosted back then was Nextcloud, and this is actually one of the few things that really survived in my Homelab world. Today, the same Nextcloud instance is still up and running, serving me and my family as the main cloud for files, calendars, tasks and contacts.

I then also found and setup DailyNotes and used that as my daily notes driver. While I now wouldn’t choose this app any more for various reasons I will discuss later, it helped me setting two important things for myself:

  • Markdown: Since DailyNotes, I love taking notes in Markdown. Any app that uses some different input style will have a hard time convincing me (up until today, none managed to convince me).
  • Thinking in daily journals. This is a really interesting concept for a mixture of notes that probably won’t be important any more after today, and notes that can endure over time. DailyNotes supported the typical Journaling approach, as well as sites that were not journals.

Hedgedoc

I later discovered Hedgedoc and liked the many things they have built-in to their Markdown flavor. Also, it was simpler to share specific notes with other people.

Keeping the journaling concept was a bit hard though, so I started messing with the database structure of Hedgedoc and created a Cron Job that would read my daily note at night, push it to DailyNotes and then clear the Hedgedoc note as preparation for tomorrow. History was then preserved in DailyNotes.

Bookstack

Bookstack never really was my daily note taking app, but it replaced DailyNotes when I decided that it was time for something new. I am currently using Bookstack as a combination of old notes that I still did not migrate to Logseq (Spoiler!), and for home-network-internal documentation that should be visible to other people (which my notes are not).

Zettlr

At some point, two things became a problem for me:

  • I learned that messing with the Hedgedoc database is not cool. More general, messing with the database of an application is often a bad idea, unless you are this application.
  • Storing notes in a database is not nice, I would prefer a file approach.

I was then introduced to the Zettelkasten concept. A really nice concept for taking and storing knowledge, and after reading a book about the subject, I was sure that I wanted to use that. Looking at their website, I was introduced to Zettlr as the recommended FOSS tool that supports the Zettelkasten method out of the box.

I did not stick to Zettlr really long, for two reasons:

  • There is no mobile app for it, and I want my notes on mobile as well as on the desktop!
  • While nice, I didn’t really feel good using this app.

I also don’t use the Zettelkasten approach any more. Turns out, it’s very well suited for academic work, if you expect that your work will at some point lead to a paper. But for me, this was not the case and hence Zettelkasten was not too important for me. I still learned a lot on the way, mainly about note taking, tagging and the concept of linking notes.

Joplin

Enter Joplin. Essentially in every step of the way, I knew that Joplin was an option. Still, I always was hesitant and never really sure that it would be a good fit for me.

This time, I tried it. And I sticked to it a long time. Taking daily notes is a charm, and having a second notebook for a Zettelkasten-like chaos of notes is still easy. Also, notes could be tagged, which at the time was enough for me.

I used Joplin quite some time. It was nearly pure Joplin, I never used a lot of plugins. Synchronization to multiple devices was really simple, and I liked working with it.

But then I wanted to access the data from other applications. Turns out, Joplin’s file structure is a set of flat files; that is correct. But these flat files are in a Joplin-specific format, and you should not interact with these files outside of the Joplin application. Same thing as before: Messing with a database(-like) structure is not a good idea if you didn’t create it.

The current tool: Logseq

Looking at alternatives for Joplin, you get quite a set of apps. For example:

  • Obsidian - Highly interesting for me, but the lack of an open source license made it unusable for me.
  • Notion also wasn’t open source, altough highly interesting.
  • Standard notes was again a monstrum for itself, with a database in the background.
  • Simple Notes was also in the race, but again, I didn’t want to go back to a database.

As the final competitor, Logseq was my tool of choice. I started using it, and I started liking it.

Logseq is my my current tool for note-taking. I am too lazy to migrate the last missing notes from Joplin or Bookstack to my Logseq graph, so these are still there with note fragments. Still, I think that this tool will stay for quite some time, as it already lasted longer than any previous system.

Bad things

Logseq is definitely not perfect. I have got some drawbacks that I don’t like at all:

  • The Android app is really shitty. I can use it to very basically read stuff and write something, but I shouldn’t do anything more sophisticated, as this will most probably fail. I had an iPhone before, and the iOS app was very much better than the one for Android.
  • On Desktop, the app is quite good, but sometimes it’s quite laggy…

Good things

There are loads of cool things. I would like to point out which features I find the most important ones for me.

  • Journal pages: I just get an own journal page for every day of the week.
  • Flat file storage! I have one folder for my journal pages, and another folder for my non-journal pages. This other folder is also a flat folder, which I really like. Nesting is done via file names (in my case: Page foo/bar is stored as foo__bar.md on disk).
  • Properties: You can give your block properties. With that, I managed to get my whole project management systems into Logseq. Priorizing things, giving them deadlines, and similar stuff is possible with properties.
  • Templates: This goes hand in hand with the property thing. For different projects I have, I have setup templates where the typical properties are pre-filled.
  • Queries: This completes the trio with properties and templates. I have got a property called task-group, and tasks corresponding to a specific project all have got the same value in the task-group property. Now with a query, I can really easy query all open tasks for a specific project. And not only that, I can order them by deadline or by priority (both are new properties I defined for the tasks).

Also, as it turns out, linking notes (well, actually blocks) to other blocks is really a cool and helpful thing. I am also using this quite often.

Plugins

I am not a big fan of plugins; currently, the functionality of the app itself is nearly enough for me. I have only a few of them installed:

  • Git Sync - This is actually critical for syncing between devices. Also, it’s better than the built-in Git-Commit method, as I here can decide myself when a commit happens.
  • AwesomeProps - This is just a small cosmetical thing for properties.
  • Tabs - This is helpful in some contexts, but I mostly don’t use it.

Conclusion

You probably will have to go your own way considering note taking. This was my way, and I am now at a place where I am currently content and can state that this works for me. Maybe you can get some inspirations from that.