The Strategy of Note Taking: Redundancy, Reliability, Efficient Discovery, and Beyond

This article is over 12,000 words and systematically explores redundancy design in note-taking systems, its benefits, and implementation considerations. I recommend bookmarking it and reading it by section as needed.

In the digital note-taking era, we have many ways to organize and manage our knowledge. However, even with the most advanced tools, we still face challenges in finding important information or remembering key notes. This article will explore how to build a redundant system to improve the reliability and flexibility of our second brain, making information truly useful.

1. The Nature of Redundancy: Not the Goal, But the Means

First, I want to emphasize that redundancy is never the goal; the reliability and flexibility that redundancy brings to the system is the fundamental purpose.

Think about SpaceX's starship design: they're equipped with multiple engines to ensure that even if one fails, the spacecraft can still safely ignite and launch. This isn't a waste of resources but a safety mechanism. Similarly, in our daily lives and work, we often prepare backup plans, which essentially embody redundancy.

Whether it's a spacecraft or a personal note system, the core value of redundancy is: when one element fails, other parts can play a complementary role to ensure the smooth operation of the entire system. This is the core of what we're discussing today: how to implement redundancy in note systems to improve the reliability of the entire system.

2. Methods for Building a Redundant Note System

In this section, I'll introduce how to build a redundant note system from perspectives including folders, tags, links, note naming, timestamps, and more. For folders, tags, and links, I've covered them in detail in a previous article, so I won't elaborate too much here. Interested readers can learn more in that article.

2.1 Folders: Basic Organizational Structure

Folders are the most basic and intuitive way of organizing. When designing a folder structure, consider the following:

• Different types of folders: Create different types of folders based on work and life focus, projects, status, etc.

• General categorization: Folders can serve the purpose of general categorization, not overly detailed

• Moderate nesting: Avoid using too many nested levels, as this significantly increases system complexity

The role of folders is to provide a basic structural framework that allows us to quickly locate the general position of notes visually.

In fact, the key to folder structure design isn't about the number of folders or the depth of the hierarchical structure. The more essential question is: regardless of what folder structure design you adopt, you can find the corresponding notes through folders when needed; and this is perhaps more important than the formal number of folders or hierarchical structure. Therefore, when designing a folder structure, we should keep the purpose in mind and not put the cart before the horse.

Specifically, we can adopt a rough folder classification structure and use necessary subfolders to subdivide topics. In practice, I also use strategies similar to naming notes when naming folders. For example, if a folder contains notes belonging to a certain project, the folder name can include the "Project" prefix and keywords representing the project name. This way, when sorting folders alphabetically, it's very convenient to see which folders are about projects and what these projects contain.

However, relying solely on folders is not enough; we need more redundancy mechanisms.

2.2 Tags: Flexible Classification System

Tags provide a more flexible classification method than folders, crossing folder boundaries to categorize notes from multiple dimensions:

• Different types of tags: Create tags representing topics, status, priority, projects, etc.

• Create as needed: Create tags carefully based on actual needs, avoiding too many tags that lead to system chaos

• Tag organization: Use the same prefix, nested tags, and other methods to reduce confusion

In my system, tag creation is more casual compared to links. Although I don't encourage the abuse of tags, I'm more lenient with tags than with links. In practice, I mainly use tags to divide topics or identify tasks; and I carefully create tags based on actual situations because adding too many tags may make it difficult to reuse tags and discover notes in the future, and the management of tags themselves may become quite chaotic.

2.3 Links: Establishing Clear Associations

Links are a way to establish clear relationships between notes and should be used with caution:

• Clear relationships: Only use links when you need to establish one-to-one, clear associations

• Different types of links: Can link to project pages, entry notes, related notes, etc.

• Avoid excessive linking: Don't create links for every keyword, as this will make the system too complex

I'm stricter with links than with tags. When do I need to use links? For example, linking one note to another; or linking a note to a certain task; or linking a certain task to a note. Only in such cases where one-to-one, strict connections must be established do I create links. This strict standard ensures that my link system doesn't become overly complex.

2.4 Note Naming: Improving Discoverability

Note naming is an often overlooked but very important aspect of redundancy. A well-designed note name can greatly improve its discoverability:

• Keywords: Use keywords that reflect the core content of the note

• Prefix: For specific types of notes (such as meeting notes), use a unified prefix (such as "Meeting")

• Names: If the note is related to specific people, for example, if you discussed something with someone, include that person's name in the title

• Suffix: For specific types of notes (such as literature notes), add a suffix (such as "Note")

• Date: Add relevant dates when appropriate, especially for meeting notes or event records

Taking meeting notes as an example, my naming usually includes: "Meeting" prefix + meeting topic keywords + meeting date + creation timestamp. The reason for doing this is that in the future, if I want to quickly locate meeting notes, I just need to find the meeting date in the calendar, and then search for the corresponding date to easily find the relevant notes.

If it's a discussion with someone, I'll add that person's name to the note name, so that in the future, searching for the person's name will quickly locate it.

For literature notes, I'll add a "Note" suffix, making it immediately recognizable as a literature note. Of course, I'll also add a tag indicating "Literature Note" inside the note, providing another layer of redundancy.

If the note name contains specific keywords, we can enter keywords in the note editing window to find the corresponding note, making it convenient to insert the note link into the current note. We can also directly call commands to enter keywords, find the corresponding note, and then insert the link. Additionally, we can customize code to query notes, whether using Obsidian Query or third-party plugins like Dataview, we can query notes containing specific keywords in their names, making batch processing convenient.

Through these naming strategies, I can very conveniently locate corresponding notes directly by searching for keywords, dates, names, and prefixes; often without needing to enter the corresponding folder or check links to find it. In fact, searching for keywords in note names to locate corresponding notes is a very common method in my system, while tags, links, and folders can serve as backup plans in this case.

2.5 Timestamps: Adding a Time Dimension

Timestamps are another important aspect of redundancy, providing reference points in time:

• Timestamps in note names: Indicate when the note was created, adding a dimension for searching

• Meeting dates: For meeting notes, include the meeting date for future reference

Why include timestamps in note names in the digital note-taking era? This stems from my personal experience:

When I first started using Obsidian, I tried using cloud storage to sync notes, only to find that the creation or modification dates of notes were accidentally changed after syncing to another device. This was very frustrating because if I wanted to sort notes by creation date or use tools like Dataview for time-dimension analysis, the data would be completely messed up. I couldn't trace the actual creation time of notes, which made the information in the notes lose an important dimension.

In traditional Zettelkasten note-taking, timestamps as note names might have been used because there were no digital note-taking tools at the time, only paper notes. To distinguish note creation times and facilitate future searching and linking, people used timestamps as card names. In the digital age, although some believe we can completely rely on creation times recorded by the file system, my experience shows that this information is not reliable, especially when syncing across devices.

Although we can understand the evolution of ideas through links, without knowing when notes were created, we cannot understand how these ideas evolved over time. Therefore, by adding timestamps to note names, even if the dates in file metadata are accidentally modified, we can still obtain time information from the names.

In addition to adding timestamps to note names, I also automatically insert creation times in the note's Frontmatter, providing double protection for time information. If the note name is accidentally modified, the timestamp in the Frontmatter still exists. This multi-level recording of time information greatly improves the reliability of the system.

To simplify the process of adding timestamps, I developed the Copy Metadata plugin. It allows one-click addition of creation time information to note names. Here's how it works: when we first create a note, the note's metadata includes creation time information. We use this plugin to attach a creation timestamp to the note in its early stages. This way, when syncing the note to other locations or processing it with other tools in the future, the creation time information won't be lost due to accidents.

2.6 Combined Application: Practical Considerations

We've mentioned various ways to help us build a redundant note system. For handling a specific note, we might take the following approaches:

• Link to related notes (such as recent related notes, project pages, entry notes, Kanban boards, tasks, reminders, calendars, etc.)

• Add two tags (such as topic tags and task tags)

• Move to an appropriate folder

• Rename the note to reflect its topic

• Add dates, creation times, and other timestamps to the note name

Of course, depending on the note's content, topic, length, importance, urgency, complexity, etc., the degree of processing, processing methods, and time spent will differ. For less important notes, you might choose one or two methods that come to mind; sometimes you might even realize that the note might not need to be recorded at all. With this kind of thinking, you might actually reduce the number of notes you record, reducing your time and energy consumption on unimportant content; thus fundamentally allowing you to have the energy to focus on more important content, rather than dispersing too much time and energy on unimportant content. On the other hand, isn't it reasonable to spend more time and energy processing an important, urgent note?

Of course, whether it's important or unimportant notes, sometimes due to subjective and objective constraints, you might not be able to use multiple methods to process them, which is completely normal. For example, if you only have a phone while on the go, capturing ideas is relatively easy, but linking, adding tags, naming, and other processing methods are not very convenient. In this case, what you can do is to adopt one or two methods that most encourage you to discover the note again, such as adding a reminder.

When recording some ideas or organizing some notes on a computer, if you have more important things to deal with at the moment, you might not have enough time to process the current note. You might choose to link it to a reminder, Kanban board, or corresponding task. The core principle of this processing method is: you're not organizing notes for the sake of organizing notes, but because the notes you organize serve your tasks, projects, and goals. Therefore, once you link a note to the corresponding task or reminder, it means that the note has been processed sufficiently to some extent; because when you execute those tasks, you will see this note again, and at that time, it's perfectly fine to process this note at a deeper level.

3. Challenges and Solutions for Redundant Note Systems

3.1 Folder Classification Dilemma

When using folders to categorize notes, a common problem is: we don't know which folder some notes should be placed in, especially when the note content involves multiple topics.

Some might say that if you don't know which folder to put a note in, it might be because the note is too large and the topic too scattered, suggesting breaking it down into atomic notes. But this brings another problem: if I break down my existing 10,000 notes into atomic notes, the total number of notes might reach 100,000-1,000,000. Such a huge number of notes would be almost unmanageable for me. Not to mention that my current note library has been accumulated over the past 5 years. What will this note system look like in 10, 15, or 20 years? Its quantity and complexity are even more difficult to imagine.

Another common suggestion is to redesign the folder structure, but this ignores a fact: our note system is not a library, and we are not librarians who can plan and foresee all possible topics and development directions in advance. On the other hand, wouldn't it be boring if our ideas and notes could only develop according to a preset framework? Isn't it precisely because our ideas and note topics have a certain uncertainty and unpredictability that makes managing them add a certain fun?

Solution

Facing the above problems, my suggestion is:

• Follow your first instinct: After seeing the note's name, topic, and content, place it in a folder according to your first instinct

• Adjust anytime: As ideas and projects change, move notes to folders that feel more appropriate at the time

• Continuous practice: With more practice and time, you'll find suitable categorization locations faster

In addition, to improve folder navigation and positioning efficiency, I developed the Folder Navigator plugin. The main reason is that traditional folder navigation methods require manually expanding and collapsing the folder tree in the file explorer view, which is very time-consuming in systems with hundreds of folders. I developed the Folder Navigator plugin precisely to solve this problem—it allows you to search for folders with keywords, just like searching for notes; then you can jump directly to the target folder without having to manually browse the entire folder structure.

3.2 Tag Chaos

As the number of notes increases, the tag system may become chaotic. Now I have 10,000 notes in my main note library, assuming each note has 1-5 tags, then there might be 10,000-50,000 tags in the entire system. Even after deduplication, the number of tags might still be around 10,000, which obviously brings management challenges.

Solution

Facing this problem, you can adopt the following strategies:

• Use tag prefixes: Use unified prefixes for similar types of tags

• Nested tags: Use nested tag structures to organize related tags

• Utilize auto-completion: Use the note editor's completion function to select existing tags when creating tags

• Rename at appropriate times: Use the Tag Wrangler plugin to batch rename related tags (but note that this operation cannot be undone)

Despite these measures, a certain degree of tag chaos still seems unavoidable, simply because there are too many tags in the note library. Looking at the tag panel, not knowing when I can slide to the end of the tags makes me feel overwhelmed. Although we can sort tags by usage count, name, etc., it's still sometimes difficult to find important tags, simply because there are many tags and they're quite complex.

We might also synchronize some reading highlights and notes to our note library through external tools like Readwise, Hypothesis, etc., which sometimes bring some chaotically named tags. I once tried to unify and standardize the tag naming rules for Readwise, but later gave up because it was too complex. And this is just one highlight synchronization tool; other external tools also synchronize tags over. Different tools have different tag naming rules, so you simply cannot unify them. Although trying to solve the tag naming problem from the source seems like a more fundamental solution, for practical reasons, we cannot solve it from the source here. So, we can only try to solve this problem from other angles.

When we look at the tag management problem from a different angle, we'll find that: the key to the problem is not managing all tags, but being able to find important tags when needed. This is a good application example of the so-called Pareto principle, and it's also a point emphasized by the PTKM method: highlight key content, grasp the main contradiction.

To highlight important tags, I create project page notes for important projects. On the project page, I'll put very important tags there, and then add a link under the tag, which can locate where I first noticed the tag. This way, in the future when we want to find the corresponding tag, we just need to check the project page. This method is very effective for managing a small number of projects, but as the number of projects increases to hundreds, managing important tags also becomes quite complex or even difficult. This requires a more systematic solution, which is why the Tag Index plugin was born.

Through the Tag Index plugin, you can conveniently gather important tags that you care about, so in the future, you can quickly know which tags in the system are important. In addition to placing important tags, you can also view it as a place to temporarily place tags, just like when managing notes, placing specific notes in a folder inbox or task list inbox. When you discover a potentially important tag, you can first add it to the Tag Index, and then decide whether to incorporate it into the long-term managed tag system later.

3.3 Link Abuse

Some methods advocate creating links for every keyword, or even completely abandoning folders and tags, relying solely on links. But this approach can lead to serious problems in practice.

Imagine if your note library has 100,000-1,000,000 atomic notes, and you create note links every time you mention certain keywords, the complexity of the graph view will reach an unimaginable level. This not only affects system performance but also doesn't help with actual use.

I once tried to view the graph in my note library (Graph View), only to find that even with my M-chip MacBook Pro with ample memory, opening this complex graph would still lag. More importantly, such a graph, apart from looking complex, has limited practical use. I might only look at it a few times a year, then exclaim "Wow, how complex my note library graph is!", satisfying my vanity, nothing more.

Therefore, I insist on creating links with caution, only using them when there's a genuine need to establish clear associations.

3.4 Complex Note Naming

As mentioned earlier, a complete note name might include prefixes, keywords, dates, timestamps, and other elements, which indeed looks quite complex. But this complexity brings convenience for future retrieval.

Solution

To simplify the note naming process, I usually adopt a progressive method:

1. Use a simple name when creating a note (such as when quickly recording inspiration on a phone)

2. Refine the naming after syncing to a computer

3. Use text expansion tools (such as Espanso) to quickly insert dates, timestamps, etc.

For example, some time ago I needed to prepare for a project meeting, thinking about what to discuss and what to present. So, on my way home, I realized I had a meeting tomorrow and needed to discuss several key points, so I created a simple note on my phone listing the outline. Later on the computer, I added the Meeting prefix, meeting topic keywords, date, and timestamp to the note name.

Based on the main content of this note, we can very conveniently choose different methods and tools to prepare meeting slides according to the content of the meeting, the type and complexity of the presentation materials to be prepared, etc. For example, PowerPoint, Markdown, Obsidian Advanced Slides, Marp, LaTeX Beamer, Reveal.js, Jupyter Notebook RISE, etc., can all be used to create meeting slides.

File Title Updater plugin: To efficiently unify and update titles in different locations of notes, I developed this plugin. In actual use, I often encounter situations where I modified the file name but forgot to update the title in the note, or the title in the Frontmatter is inconsistent with the actual title. This inconsistency not only affects aesthetics but, more importantly, may lead to search and reference confusion.

File Title Updater can update the file name, Frontmatter, and first-level title in the note with one click, ensuring they remain consistent; this in itself reflects a certain redundancy in the note system. When we modify the note name, we also need to modify the title in the Frontmatter and the first-level title in the note. This redundancy ensures that even if one of them is accidentally modified, the other two can still provide correct information.

4. Reflections on Using AI for Note Management

Considering the development and application of AI technologies, I'd like to briefly discuss the issue of using AI to help us find the notes we need.

Currently, there are many AI note Q&A plugins in Obsidian, as well as external tools like NotebookLM, Reor, etc. AI IDE tools such as WindSurf and Cursor can also be used for note Q&A purposes. These tools use RAG or other related technologies to find relevant text fragments in our note system based on our questions, which are then synthesized by LLM to provide answers. This application scenario seems promising, but from my personal experience, it has some problems and shortcomings.

4.1 Privacy Considerations

First, there are privacy concerns: If the note content is relatively private or sensitive, I am cautious and skeptical about sending this type of content to entities that might use personal data to train their models. Although some companies offer options to opt out of using our data for training and improving their large language models, once we use their services, we still have to provide them with our data. As users, once we hand over our data, it's difficult to know how they will use it. Additionally, the privacy policies listed by many companies are really difficult for ordinary users to understand how they will use our data; and they usually reserve the right to update their privacy policies at any time. This puts ordinary users in a more vulnerable and passive position regarding privacy protection; once problems arise, the cost of defending users' rights is often too high, even if users are aware they can defend their rights. So, from a more fundamental perspective to solve privacy issues, it might be better to not easily hand over sensitive data.

Of course, you might say that we can use offline large language models for note Q&A. For example, Ollama and LM Studio provide unified API interfaces to support multiple offline LLMs, including the Llama series, DeepSeek series, etc. However, how their model capabilities compare to OpenAI's GPT series and Anthropic's Claude series varies from person to person and is subjective. Of course, it's undeniable that the capabilities of open-source offline LLMs are gradually improving, but OpenAI and Anthropic's closed-source, online models are likely improving as well.

4.2 Q&A Technologies

Second, there's the issue of Q&A technologies: Whether using online or offline models, current RAG and similar technologies retrieve relevant notes based on our questions, then synthesize the found text fragments using LLM to provide responses; but this approach also has some problems. Are the text fragments it bases its answers on really the content you would want to use when manually searching for notes? In other words, are the notes it finds truly closely related to answering your question?

Of course, you might say that RAG is just the current technology, and it might develop further in the future. But on the other hand, even if AI technology develops to a certain degree and can help us answer our questions based on closely related notes, there might still be other issues. There is indeed a certain correlation between our thoughts and notes, but this correlation doesn't necessarily develop linearly over time. For example, you generated idea note A on date A, idea note B on date B, and idea note C on date C; but the connections between notes A, B, and C and their evolution over time may not be linear. Based on my personal experience, the evolution of ideas over time and the connections between them are often non-linear; simply because the human brain is not linear, and the surrounding environment and information you encounter are also non-linear. So, how can AI understand this non-linear relationship and the workings of the brain?

4.3 Understanding and Thinking

Finally, there's the issue of understanding and thinking: Even if AI's capabilities develop to overcome some of the obstacles I mentioned earlier, this only represents progress in AI's capabilities, unrelated to humans. AI can provide closely related and expected answers based on your notes, but what does this mean? It's still just a response given by AI, and doesn't represent your true understanding; moreover, it might weaken your thinking process, which could be detrimental to understanding your past notes and ideas. When we want to communicate ideas with others, we surely can't let AI speak for us, can we? In this case, what role would humans play?

Of course, I'm not saying we shouldn't use AI tools. In fact, we might find it difficult to avoid this, and we can't ignore technological developments. In fact, I use AI for speech transcription, text processing, programming, and more. We just need to approach and use AI with a critical attitude. Ultimately, we need to actively learn and think to truly master knowledge. Those notes are for our own use, not for AI's use.

AI can assist us in completing work, but it cannot replace us in completing work. Imagine if all our work today could be replaced by AI, and AI becomes even more powerful in the future, would we still have jobs? Therefore, when using AI, we need to actively think and maintain a critical attitude; this way, we might avoid having our future work replaced by AI, avoid being replaced by AI.

5. Benefits of a Redundant Note System

Earlier, we introduced various ways to build a redundant system, such as folders, tags, links, note naming, timestamps, etc., and also mentioned the problems and solutions that might be faced when building a redundant system. So specifically, what are the benefits of building a redundant note system? Next, we will explore this question from several aspects.

5.1 Improving System Reliability

One obvious advantage of a redundant system is that it can improve the reliability of the system.

5.1.1 Everyday Explanation

Let's first try to describe what reliability is, or what reliability means, in more everyday language. As mentioned earlier, SpaceX's spacecraft are configured with multiple engines, so that even if one engine fails to ignite, there are still backup engines to ensure the spacecraft launches successfully.

We make backup plans in our work and life, which is also a manifestation of improving reliability. When we want to reach a destination, we need to formulate a transportation plan. At this time, map tools will give us multiple travel options, such as subway, bus, taxi, driving ourselves, etc. We can choose one plan as our travel method, and if something unexpected happens along the way, we can switch to another plan, ultimately ensuring that we reach our destination smoothly.

When we want to travel by plane for a long journey, for example, for domestic flights, airlines might suggest arriving at the airport two hours in advance; while for international flights, they usually suggest arriving three hours in advance. This essentially reflects redundancy in time, and can improve the reliability of successful travel. However, redundancy in time does not mean a waste of time. Because after we arrive at the airport, we can handle check-in procedures, complete security checks, etc.; afterwards, we can still take out our laptops to work, or use our phones to record ideas, or engage in entertainment and relaxation. We can always find some way to use this redundant time.

These examples from daily work and life show that redundancy can improve reliability and give us a sense of security. This is obviously one of the advantages brought by redundancy.

5.1.2 Theoretical Explanation

Earlier, we discussed what redundancy is and the reliability it can bring using everyday examples. Now, let's try to understand redundancy and reliability from the perspective of probability accumulation effects.

Let's make a random assumption: each measure we take to process notes increases the probability of us finding them in the future by 5%. Then, if we take 5 measures, the total probability increase is 28%. If each measure increases the probability of notes being rediscovered by 10%, then after 5 measures are stacked, the total probability of notes being rediscovered reaches 61%. This effect is similar to compound interest in investments, which is advocated by people like Buffett. We're just transferring the compound interest of time to the way notes are processed, but the essence and effect are the same.

We put in a little extra effort when processing notes, and the probability of rediscovering them in the future will greatly increase, which is a high-return investment. It's worth noting that taking multiple measures to process notes doesn't necessarily mean spending a lot of time and energy. If handled properly, it can be completed in a minute or two. If it takes too much time, it indicates that some processes or methods can be optimized. For example, when adding timestamps, tools like Copy Metadata, Task Marker, Espanso, etc. can be used to assist in adding them; when wanting to move notes to specific folders, automated tools like Hazel, note moving plugins, etc. can also be used to achieve this.

5.1.3 Processing Measures

Even though there are multiple benefits to processing notes from a redundant perspective using multiple methods, we still don't need to take all measures to process every note. Instead, we can choose the appropriate processing depth and time and energy expenditure based on the importance, urgency, complexity, etc. of the notes.

An obvious truth is that since they are important notes, relatively speaking, we will definitely want to rediscover them in the future. Therefore, it is only natural to spend more time and energy and take multiple approaches to process them. For notes that are not particularly important, we can take relatively fewer measures to process them, after all, they are not very important. Over time, we may even realize that some notes don't need to be processed at all, or even recorded, if they are not important at all. This, in turn, can free up extra time for us to process important notes. Over time, a positive feedback loop is formed. As for what feedback and positive feedback are, we can discuss them in the future.

Finally, whether important or unimportant notes, sometimes we can't take multiple measures to process them, or even use one method to fully process them. For example, linking them to related notes, adding related tags, etc. Then, we can add a reminder at the beginning of the note, reminding our future selves to link the note to other notes or add some tags; when we see this reminder in the future, if we feel that this note is still important and this reminder still makes sense, we can create links, add tags, etc. according to the reminder. In fact, adding link and tag processing reminders in notes itself is a redundant design, which is equivalent to leaving clues for your future self on the time scale.

5.2 Easily Finding Needed Notes

A core value of a redundant system is that it can help us discover and find previously recorded ideas.

Let me first recall what my work and life state was like before exploring the note system. About nine years ago, my research ideas might be scattered in different places. For example, they might exist in Word files, OneNote, plain text files, paper notebooks, sticky notes, literature management tools. In other words, my ideas, meeting notes, etc. were scattered across multiple tools and different forms of media.

At first glance, you might say, your ideas are scattered across different tools, isn't this itself a manifestation of redundancy? But this is completely different from the concept of redundancy introduced earlier. The difference is that these ideas scattered in different locations are isolated from each other, with no connection. When I want to find an idea, it's very laborious, and I might need to search each location one by one. As for how to find the corresponding idea in each location, this becomes additionally complex. For example, where should I look for a certain idea in a paper notebook? If I later generate additional ideas, how should I follow up and develop them? These are all problems, and they made me feel overwhelmed and anxious all day long at that time.

As for how I built a system (PTKM) to manage all notes, tasks, and projects, allowing me to escape from that anxious state at that time; this question is much more complex, and we can elaborate on it in the future. Here, I still want to discuss how to find needed notes from the perspective of redundancy.

5.2.1 Finding Notes Through Keywords

It might be somewhat unexpected, but keywords are one of the most common ways I find the notes I expect. However, the keywords here refer to keywords in the note name, not keywords in the note content.

If we search for keywords in the note content, when you search for a certain keyword in a note tool, such as OneNote, it might give many related notes. For example, in my note system, there are over 10,000 notes, so it shouldn't be abnormal to get a hundred related notes when searching for a certain keyword. Of course, this doesn't mean that searching for keywords in note content is useless; in fact, it can serve as a backup plan and can be combined with other methods to efficiently find notes. This point will be introduced later.

In contrast, since we have already included keywords, prefixes, people's names, dates, and other information when naming notes, directly searching for these elements can quickly locate relevant notes. For example, searching for "meeting" can find all meeting notes; searching for someone's name can find discussion records related to that person.

Specifically, in Obsidian we can search for keywords to find needed notes in the following ways:

• Note Editing Window: When we are editing a note and want to reference another note, we can directly input keywords in the editing window (usually surrounded by double square brackets [[keyword]]), and the note tool will automatically display a list of notes containing that keyword, allowing us to quickly select and insert links. This method is particularly suitable for quickly establishing connections between notes during the note organization process.

• Command Palette Search: In Obsidian, we can use the command palette (usually called up via Cmd/Ctrl+O) to input keywords, quickly find and open relevant notes, and then insert links to them in the current note.

• Batch Processing Queries: Using plugins like Dataview, we can write query code to find all notes with specific keywords in their names, which is very useful for batch processing specific types of notes. For example, I can query notes with the keyword "project" in their names, which can list all project page notes.

• Full-Text Search of Note Content: In addition to note names, we can of course also search for keywords in note content. Although this method is not always efficient, it can serve as a backup plan when other methods fail to find the needed notes.

In short, using keyword search to locate notes is one of my most commonly used methods. Due to my naming rules that include rich keyword information, I can usually find the needed notes through simple searches, often without having to rely on link tracking or folder navigation. This method is very efficient, especially when I remember the general topic, date, or related personnel of the note.

5.2.2 Finding Notes Through Link Networks

Bidirectional links can establish one-to-one connections between two notes, forming clear and reliable connections. It is precisely this reliable connection that provides a clear and reliable method for finding notes. Specifically, in Obsidian, there are multiple ways to locate expected notes through note links.

Linked mentions at the bottom of the note window: When viewing a note, the bottom of the window usually shows which notes link to the current note (Linked mentions). This allows us to understand how other notes reference and use the current note, thereby discovering potential associations. These backlinks often reveal connections that I wasn't previously aware of.

Entry notes: I create entry notes for notes with similar topics. What are entry notes? When creating them, I follow the note naming principles mentioned earlier: their prefix usually includes the keyword "Entry", followed by keywords related to the entry note's topic, and finally a timestamp. When we want to view notes on a certain topic, we can locate them in the corresponding entry note.

One point that needs to be emphasized is that the topics of entry notes and their creation are unpredictable; we can only create entry notes as the note system develops and as needed. We might find that an entry note initially contains only 2-3 notes, but as the related topic develops, it might gradually accumulate to 10, 20, 50, or even more notes. When we realize the need, we can split the entry note into smaller entry notes. By smaller, I mean more focused topics and fewer related topic notes. The creation, development, and evolution of entry notes themselves can be elaborated on in the future.

Project pages: I create dedicated project pages for each important project, which contain important note links, tags, project action notes, and other important information related to the project. Project pages can essentially be viewed as special entry notes, except that they link not only to notes but also to tasks, tags, and other important information. Project page naming also follows the naming rules mentioned earlier; their names include the prefix "Project", keywords reflecting the purpose of the project, and the timestamp of when the project page was created.

For example, I need to attend a conference in the second half of the year, so I need to develop algorithms, test algorithms, analyze results, write an article, and book travel arrangements, etc. All the notes, tasks, etc. involved in this can be linked to the project page. As for how to create project pages, we can discuss this further in the future.

When we need to find notes related to a specific project, I just need to open the corresponding project page to see all the key links. These centralized link collections provide a convenient starting point for project work.

Link view in the sidebar: Obsidian's sidebar view shows which notes the current note is linked to, and which notes link to the current note. This bidirectional link view helps us understand the network of relationships between notes and quickly navigate to related content.

Essentially, the link view function in the sidebar is partially similar to the linked mentions at the bottom of the note window, except that the link view here needs to be opened in the sidebar to be seen, while the former can be directly seen at the bottom of the note editor window. The two have different usage methods, but the functions they provide are essentially similar.

Block link reference relationships: As for what block links are, simply put, they allow us to conveniently link to specific lines in a note, not just the note as a whole. As for why use block links instead of directly using note links, this involves whether we should record long notes or atomic notes. This point was mentioned in a previous article and won't be elaborated on here, but it might be discussed again in the future.

Using the Strange New Worlds plugin, we can conveniently view the reference relationship information of block links. In short, with this plugin, there is a superscript at each Block ID (a type of block link identifier) that shows in which notes the current text block is referenced. Of course, with this plugin, we can also conveniently locate the corresponding notes; this block link positioning function provides a view of text link reference relationships with a relatively small granularity, which is particularly important for systems that use long notes.

To facilitate the creation of Block IDs, I developed a plugin called Timestamp Link. In short, this plugin can use the current timestamp as the Block ID when creating a Block ID. The fundamental reason for developing this plugin is the concept of context in the PTKM method, and time information is an important part of context. The content about this plugin, as well as context, timestamps, etc., can be introduced in the future.

Graph view: Since Obsidian is a note tool with a graph view function, this way of viewing note link relationships should naturally not be omitted. But unfortunately, as I mentioned earlier, the graph view, especially the global graph view, has almost no practical significance in my PTKM system, except to satisfy my vanity. Of course, the local graph view might have some value, but considering the multiple methods I mentioned earlier, the local graph view doesn't have much practical significance for me either.

A third-party plugin related to the graph view is called ExcaliBrain. Interested readers can also research it; it allows you to conveniently view the link relationships between notes.

5.2.3 Finding Notes Through Canvas

Canvas Introduction: This is a feature later introduced by Obsidian. Simply put, it provides a visual two-dimensional view to display the link relationships between notes, tasks, pictures, and more. The necessity of the Canvas feature lies in the fact that although notes can contain internal links to other notes, when we view related note links in an entry note, it only lists some related notes presented in a linear way; and that linear presentation method is insufficient for complex note and task relationships. As for what linear and non-linear mean, we can also elaborate on this in detail in the future.

Non-linear Note and Task Management: Specifically, we can place different notes and tasks on Canvas files; these notes can internally contain links to other notes, and task sub-items can contain links to related tasks. At the same time, on Canvas files, we can connect notes and tasks with arrows, or simply arrange them vertically and horizontally; this way, we can organize the link relationships between notes and between tasks. In short, just like an artist painting on canvas, using Canvas files allows for convenient implementation of non-linear note and task management.

Actually, as soon as I saw the Canvas feature, I immediately thought of suspense films where detectives place various clues related to a case on a whiteboard, such as photos, text, etc., and then connect related elements with lines. Therefore, Canvas can also implement this functionality for note and task management. In short, it provides a visual, non-linear way of managing notes and tasks.

The two-dimensional, non-linear note and task management method provided by Canvas is very important for showing complex associations and dependencies between notes and tasks. Essentially, Canvas files can be viewed as a special type of entry note and entry task, because we can list important notes and tasks on them. Then, these notes and tasks can internally view other related notes. Therefore, it can be viewed as a special, two-dimensional, non-linear way of organizing notes and tasks.

Canvas Plugins: In fact, it was precisely because of my reliance on the Canvas feature that I developed the Canvas Format Brush and Send to Canvas plugins. The former works like the format painter in Word, allowing you to copy and paste the size and color of Canvas cards; the latter allows you to conveniently send text, note blocks, and note links to Canvas files, after which you can easily organize the relationships between them.

Finding Notes Through Canvas: Once you understand the function of Canvas, discovering needed notes through it becomes natural. You can easily locate the target Canvas file, then view the important notes and tasks listed on it. Afterwards, you can use these notes and tasks as entry points to view other related notes and tasks as needed. Of course, you can also view the link relationships between Canvas card elements from another angle through the arrows on the Canvas file.

Regarding the naming of Canvas files, the same naming strategy mentioned earlier is adopted. You can use the keyword "Canvas" as a prefix, then use keywords that reflect the topic of the Canvas file as the main name, and a timestamp as a suffix. At the same time, we can link Canvas files to appropriate locations such as project pages; we can also put them in dedicated folders. This way, we can very conveniently locate the corresponding Canvas files through name keyword searches, note links, folders, etc., and then view the notes, tasks, etc. on them.

5.2.4 Finding Notes Through Folders

Folders are an intuitive way of organizing notes, providing important navigation paths. We can find needed notes through folders in multiple ways:

• Browse by General Classification: Folders provide a general classification of notes, allowing us to browse notes by topic, project, etc. This visual organization method helps obtain an overall view of notes.

• Combine with Time Sorting: In specific folders, we can combine sorting by creation time or modification time, so that we have both topic classification and time order, making it convenient to track the evolution of ideas under specific topics.

• Dataview Folder Queries: Using plugins like Dataview, we can query all notes in specific folders and sort and filter them by various conditions (such as creation date, tags, links, etc.).

• Folder Navigator Plugin: A common challenge in folder navigation is finding specific folders in a complex note library. The traditional method is to manually expand and collapse the folder tree, which is very time-consuming in systems with hundreds of folders. I developed the Folder Navigator plugin precisely to solve this problem—it allows you to search for folders with keywords, just like searching for notes; then you can jump directly to the target folder without having to manually browse the entire folder structure.

Of course, a very natural thing is that when managing the folder structure, when we try to use folders to find needed notes, we might find that the naming method of this folder is not very suitable. For example, if 50 notes have accumulated in a folder, this will obviously make it inconvenient to find related notes through that folder in the future. Therefore, in this case, I will split the folder. For example, regarding Obsidian plugin development, I initially used one folder to manage it, but later found that ideas about plugin development were at different stages and states. Some were at a very early idea stage, some were under development, and the plugins under development included multiple plugins. For example, now I have developed 12 plugins, so it is obviously necessary to use a more fine-grained folder structure for classification.

Adjusting the folder structure as needed can greatly improve our efficiency in locating specific folders to view related notes. Not only this manual way of locating folders, we can of course also use the Folder Navigator plugin to search for our plugin names, and then very efficiently locate that folder and view related notes.

In fact, even in the design and use of folders themselves, it has never been a single method, but a redundant method. Through the design of the hierarchical structure, we can know what types of notes each folder roughly contains; by using prefixes and keywords as folder names, we can also efficiently locate different categories of folders; and by directly searching for keywords, such as plugin names, we can easily find the corresponding folders and view related notes. Therefore, the design and evolution of the folder structure itself is essentially a manifestation of redundancy and reliability.

5.2.5 Finding Notes Through Tags

Tags provide flexible classification across folder boundaries. Entering a tag (such as #Tag) in the search bar can find all notes using that tag. This method is particularly suitable for finding all related notes on a specific topic or project. We can trigger tag searches in multiple ways:

• Tag Completion in Note Window: When editing a note, entering the # symbol triggers the tag completion function, displaying a list of existing tags. This allows us to quickly add consistent tags and also see what tags already exist in the system.

• Browse Tag Panel: Obsidian's sidebar has a tag panel that displays all tags and their frequency of use. By clicking on a specific tag, we can view all notes using that tag.

• Tag Index Plugin: This plugin I developed specifically addresses the problem of too many tags being difficult to manage, providing a centralized place to manage important tags. Through this plugin, we can quickly access those tags that are most important to us, without having to search among thousands of tags.

5.2.6 Finding Notes Through the Time Dimension

Time is another important dimension for organizing and finding notes. We know that note names may contain date and timestamp information, and the internal parts of notes and frontmatter sections, note metadata, etc. may also contain time information. When we search for notes, we can combine this time information to help us locate the notes we need.

• Time Information in Note Names: As mentioned earlier, I include date and timestamp information in note names. This allows me to directly search for specific dates or use creation time as a filtering criterion to find all notes created on that day. For example, if I remember discussing an important idea at a certain meeting but forgot the specific content, I can quickly find the relevant notes by searching for the meeting date.

• Sort by Modification Time: In the file explorer, we can sort notes by their modification time, which helps find recently processed notes.

• Sort by Creation Time: Similarly, sorting by creation time can help us understand the timeline and evolution of ideas. This is very valuable for tracking the development of thoughts.

• Dates in Frontmatter: By storing date information in frontmatter, we can use plugins like Dataview to query and sort notes by creation date, modification date, or custom date fields.

Time dimension searches are particularly suitable for situations where I remember "approximately when" a topic was discussed, but don't remember the specific title or content. For example, if I remember that an important decision was discussed in last month's project meeting, I can search for that date plus the "meeting" keyword to quickly find the relevant meeting note.

The last point I want to add is that if I made some additions to the note content, such as adding a line of text at a certain position, I generally add a timestamp after the text (for example, added text 📝 2025-04-22T12:00), so that later I can easily know that the text at the current position was added later. If I want to find text that was added later, I can also use the full-text search method to search for specific dates, which can also find the corresponding text.

As for why not create a new note, the reason is the same as creating long notes instead of atomic notes: creating a new note increases the complexity of the note library and the difficulty of management. Of course, if the newly added text is very long and the content is very important, I will create a new note; the reason and starting point for doing this is very simple: compared to the complexity this might bring to the note system, creating and managing important notes is more important; after all, our system is to serve our notes, especially important ones. However, if the note is very short or the content is not particularly important, then I will use the method mentioned earlier to add it to the original note. As for why add an Emoji symbol prefix before the timestamp, it's simply because Emoji symbols are more eye-catching in notes: when scanning the entire note, you can see at a glance which position is newly added text.

5.2.7 Finding Notes Through Combined Methods

Here I want to explain how to find needed notes by combining the methods mentioned above with specific examples.

The following is my process of finding a meeting note:

• I vaguely remembered recording some ideas in a certain meeting note, so I wanted to find the corresponding meeting note to review those ideas.

• Because when holding important meetings, such as research project meetings, whether online or offline, we generally schedule meetings in the calendar. Therefore, I found that meeting by searching for keywords of the meeting name or looking at the approximate date of the meeting.

• Because my meeting note names generally include the meeting date of that day, just like the note naming rules mentioned earlier, so I directly searched for the meeting date in the note name to view the meeting notes of that day. However, I couldn't find the meeting notes for the corresponding date no matter how hard I tried.

• Later I realized that when I initially created the meeting notes, I used the date of the day I created the notes, not the date of the meeting day. Naturally, I couldn't find the meeting notes for that day, because there was no meeting on the day the notes were created.

• After that, I thought that my meeting note names also include the "meeting" prefix and keywords of the meeting topic. So, I tried searching again by combining these two methods, and this way I found several meeting notes with prefixes and keywords in their names.

• Then, I roughly sorted them by date, for example, sorting the found notes in descending order by creation date. This way, I could very conveniently view all meeting notes created within a certain date range. It was then that I realized that when creating meeting notes, the date attached to the note name was actually the week before the meeting date. However, through this method, I finally found the corresponding meeting notes.

From the above experience, it can be seen that although there was an error in the meeting date in the name of the meeting notes, I could still find the corresponding notes through the redundant design of the note system mentioned earlier. Obviously, this demonstrates the fault tolerance capability and reliability of a redundant system.

Sometimes, I want to view notes on a certain topic, tried searching for note name keywords, but couldn't find them no matter how hard I tried. Later I realized that I thought I had used a certain keyword as part of the note name at that time, but actually I used a synonym of the keyword I thought of at the moment; and this is a very normal phenomenon, because our brain, language, and concept system work this way. At that time, I tried several synonyms but couldn't find that note, so what should I do? Fortunately, when recording that note, I thought it was very important, so I linked it to multiple locations. Later, I looked for it on the Kanban and project page, and indeed found it.

It can be seen that even if we have memory bias about the keywords used at that time, the redundant system design still allows us to find the corresponding notes. After finding this note, if I feel that the name of this note or the keywords in it might not be conducive to me discovering it again in the future—after all, this time I experienced quite a few twists and turns—I might rename this note to include keywords that are more in line with my current language habits. Of course, when renaming, I can use the File Title Updater plugin I developed, which allows me to update note titles in multiple locations with one click, without spending too much manual work.

In daily work and life, there are countless examples of finding corresponding notes through the above redundant methods. Through diversified search paths, the redundant system ensures that we can find the notes we need from different angles and dimensions. Even if one search method fails (for example, forgetting the exact name of the note), we can still find it through other paths (such as links, tags, or folders). This multiple guarantee greatly improves the reliability of the system, allowing us to more confidently store ideas in the system, because we know we can find them in the future.

5.3 Discovering Unexpected Connections

Hoping to make unexpected discoveries and establish unexpected connections in the future—isn't this the essence of the Zettelkasten method? In fact, this is one of the reasons that initially attracted me to explore the Zettelkasten method, because just thinking about it feels wonderful. The redundant design of a note system is an effective tool for achieving this purpose. From my five years of practical experience building the PTKM system in Obsidian, this design has indeed been effective, I can frequently discover unexpected ideas and establish new connections.

When I want to create a link to another note in one note, I search for relevant notes using keywords. I can directly search for relevant keywords in the note editing window, then establish a link after finding the corresponding note; or I can separately use the search interface to search for keywords in note names, locate the corresponding note, and then insert the link to that note. During this process, I often discover some unexpected notes: when searching for a keyword, several or even ten to twenty notes might appear; and these unexpected discoveries and connections are ones I hadn't thought of before establishing the note link here, and are unpredictable. These unexpected discoveries and connections often have great value for current thinking.

When we view project pages, entry notes, or note links at the bottom of the note editing window, we also often find unexpected notes: even if we initially wanted to find just one note, we often inevitably see other notes, and those additional notes are ones we didn't anticipate. Afterwards, we can casually link the related notes together.

The same applies to tags: when we want to search for a tag in the note editing window, we find that Obsidian recommends related tags to us. The main reason is that Obsidian's method of recommending tags is diverse and flexible, because our keywords might appear at the beginning, middle, or end of tags. When we search for a keyword to view tags, we might not find it; at this point, we might try synonyms or other words. This way we can also discover unexpected associations.

An obvious fact is that through the redundant design of the note system, we can obtain unexpected discoveries. When searching for a specific topic, we might discover other related notes that we weren't previously aware of, and these unexpected connections might inspire new creativity and insights. This is one of the most valuable aspects of a knowledge management system: not just storing information, but creating new connections and ideas.

Even today, I can still make unexpected discoveries every day, each time bringing me surprise, and this experience is difficult to provide with a single organizational method.

Finally, one point we need to be constantly vigilant about is that although a redundant system allows us to frequently make unexpected discoveries and connections, we should prioritize the notes we currently want to find and our current tasks and projects, rather than being delayed in our task execution because of those unexpected discoveries and connections. After all, compared to those unexpected connections, actually completing those tasks might be more important. More fundamentally, our system serves our tasks, projects, and goals, not the other way around. We should avoid putting the cart before the horse.

5.4 Enhancing System Flexibility

Another advantage of a redundant system is that it enhances the flexibility of the entire system.

5.4.1 Multiple Processing Options

With multiple ways to process notes, we are not confined to a single method

• No need to feel anxious because one method is imperfect

• Can choose the most suitable processing method based on specific situations

For example, if completely relying on links without a folder structure, when the number of notes reaches tens of thousands or even hundreds of thousands, the system becomes extremely chaotic. I once tried to select just 100 files in Finder, and it would lag, let alone managing tens of thousands of files.

5.4.2 Multi-dimensional Discovery

Multiple processing methods mean multiple paths to find notes

• Increases the possibility of discovering unexpected connections

• Improves the adaptability and resilience of the entire system

Fundamentally, multiple processing methods essentially increase the probability of rediscovering specific notes, discovering unexpected connections, and also improve the reliability of system operation.

6. Balancing Redundancy and Simplicity

In the process of building a redundant system, we inevitably face a question: how can we ensure system reliability while avoiding excessive complexity? This is an issue that requires constant adjustment and balance.

6.1 Balancing Reliability and Workload

Adding redundancy does indeed improve the reliability of a note system, but it may also increase the workload of maintaining the system. Here are some balance points I've found in practice.

6.1.1 Importance Classification

Not all notes require the same degree of redundant processing. For core projects, key ideas, and important reference materials, spending more time on comprehensive redundant processing is worthwhile; while for temporary records, daily trivia, or less important inspirations, simple processing is sufficient.

For example, for notes from a monthly project meeting, spending a day or two (not necessarily consecutive) to process them is reasonable, as this content may affect work for the next month or even longer. For daily inspirations or temporary ideas, simple recording and adding one or two tags might be enough.

6.1.2 Progressive Processing

You don't need to complete all redundant processing the moment you create a note. You can record quickly first, then gradually improve when you have time. For example, give the note a basic name, place it in a temporary folder, and later add tags, establish links, optimize naming, etc.

I often quickly record ideas on my phone, giving them just a simple title. Later, when processing on the computer, I gradually improve the naming, add tags, establish links, move to appropriate folders, etc. This progressive approach ensures that I don't delay recording important ideas due to concerns about perfect processing.

6.1.3 Automation Tools

We can use plugins and tools to reduce manual operations. As mentioned earlier, plugins like Task Marker and File Title Updater can greatly reduce the workload and burden of maintaining a redundant system.

For example, using text expansion tools (like Espanso) and Copy Metadata can insert the current date and timestamp with one click, greatly simplifying the note naming process. Similarly, the File Title Updater plugin can update note titles in multiple locations with one click, without manual updates.

6.2 The Art of Simplification

Although note system redundancy can bring many benefits, this doesn't mean we should have redundancy for redundancy's sake. After all, redundancy itself is ultimately not the goal; the benefits it brings are the goal. Therefore, we should learn to appropriately simplify the system. This way, we can make the system easier to use and maintain without losing the advantages of a redundant system. Specifically, we can appropriately simplify the system from multiple aspects.

6.2.1 Reduce Unnecessary Complexity

Avoid too deep folder nesting, control the number of tags, and create links cautiously. Additionally, we can take a strategic approach to naming notes. As for adding timestamps to note names, we can also use appropriate tools to assist, rather than adding them manually.

I once tried to create a very deep folder structure, only to find that it created great resistance in note categorization and locating folders and notes, wasting too much time and energy. Therefore, now I try to keep the folder structure relatively flat, with at most two to three levels of nesting; then create necessary folders as needed. These strategies greatly improve the maintenance and usage efficiency of the note system. In fact, I developed the Folder Navigator plugin also for folder and note navigation efficiency.

6.2.2 Establish Clear Rules and Processes

Establish simple and clear note processing rules, so you don't have to rethink how to process notes every time in daily use. For example, I've established corresponding naming rules and processing flows for different types of notes: meeting notes always start with "Meeting", include topic keywords, date, and timestamp suffix; literature notes always start with topic keywords, followed by timestamp and "Note" suffix; reading highlight notes imported from Zotero to Obsidian also follow special naming rules, such as PaperLee2008HAD_How are doctoral students supervised Concepts of doctoral research supervision - Annotation.

One point that needs to be emphasized here is that my notes generally have corresponding timestamp suffixes. The reason for not adding timestamp suffixes to reading highlight notes imported from Zotero is considering the special case of highlight note imports. We may make different annotations or modifications to the same literature at different time points, but when using the Zotero Integration plugin to import literature highlights and notes, I still want to save them in the same note. This is why I don't add timestamp suffixes to this type of note. So, there will be some special cases in note naming and other aspects, which need to be determined according to your own needs.

Of course, to assist in creating different types of notes, we can create different templates for different types of notes. This can improve the efficiency of note creation and organization, while ensuring system redundancy and efficiency.

6.2.3 Focus on Core Functions

Don't be tempted by all the features of a tool. Focus on those features that truly improve efficiency and reliability, and ignore those that look cool but aren't very useful in practice.

For example, although the graph view looks very cool, I actually rarely use it because it often becomes too complex and difficult to interpret in large note libraries. Instead, I focus more on core functions like keyword search, tags, and links, as they provide more practical value in daily use.

For example, in terms of software appearance, I've tried many different themes, because there are too many themes in the third-party theme market, just like there are many plugins. But I eventually chose the Minimal theme because it's relatively concise for me, allowing me to focus on the notes themselves. Of course, to make folders look more intuitive, I use the Iconize plugin to assign different icons to different types of folders.

6.2.4 Review the System as Needed

Accept the fact that the system cannot always remain perfect, and review and organize the system as needed. For example, I usually spend some time organizing my project pages, entry notes, tag system, root directory notes, etc. when I realize the need. This is much more practical than trying to maintain perfect consistency at all times.

The reason I say to review and process when you realize the need rather than saying to process regularly is because, just like I stopped doing weekly reviews, I later realized: once something is something I must do every week, I feel a lot of resistance. Therefore, a strategy I later adopted was to do it when needed, rather than having to do it regularly. Because the "must" thing makes me feel like someone is forcing me to do something, which instead brings me a lot of resistance and pressure, making me develop a resistant mentality. Fundamentally, it might be because having to do something regularly requires a lot of willpower. As a book (I forget the specific name) says, our willpower is limited. Therefore, if the operation of the system needs to consume a lot of our willpower, it indicates that the design of the system itself may have room for optimization.

In contrast, when we realize the need to deal with these things, it's because we know that if we don't deal with them, the system cannot operate normally and cannot better serve our tasks, projects, and goals. At the same time, our system design gives us the time and energy to process, maintain, and optimize it. Therefore, we know that doing this is meaningful and won't delay other things. This in turn can mobilize our subjective initiative, because we know that completing this can make the system better serve us. This also forms the so-called positive feedback again.

Regarding simplifying and cleaning as needed, another point I want to emphasize is: when to optimize the system should be decided by yourself. This might sound abstract, but I think a principle that can be followed is: in normal use of your system, there should not be much resistance; the design and maintenance of the system should be simple enough to better serve your tasks, projects, and goals. When you realize that your system is not running smoothly in serving your tasks, projects, and goals, perhaps that is a time to review, simplify, and clean it. Of course, more importantly, maintaining your system itself should not hinder the goals it is meant to serve. This explanation might still be somewhat macro and non-specific, but I believe you will gradually realize how to handle system maintenance and what it means to process as needed.

6.3 Personal Balance

Everyone's optimal balance point is different, depending on personal life stage, work responsibilities, working style, project nature, time constraints, and so on. The key is to find the balance point that suits yourself, rather than blindly pursuing someone else's system.

For example, if you mainly handle short-term projects, you may not need too complex redundancy mechanisms; if you are engaged in long-term research, you may need more comprehensive redundancy guarantees. Similarly, if you only process a small number of notes each day, you can invest more time in each note; if you need to process a large amount of information every day, you need a more efficient processing flow.

In fact, although this article introduces the implementation methods, advantages, and various aspects of redundant systems, these measures were never achieved overnight, but were gradually reflected upon and explored in my work and life. We always go through this process: identifying problems, finding ways to solve problems, and iteratively optimizing solutions. It can be foreseen that this system will continue to evolve in the future. Fundamentally, we ourselves are changing, and our system serves us; so, it is natural for our system to change with our own changes.

6.4 Balance Between Future and Present

When building a redundant system, we often face an important trade-off: investing time and energy for future discoveries, or focusing on current tasks and projects.

Although we hope to discover unexpected connections in the future, we must admit that "unexpected" also means these discoveries may or may not occur. The future is inherently uncertain, while current important and urgent matters are certain, because they are right there. Spending too much time and energy organizing notes for future, uncertain discoveries, while neglecting current priorities, cannot be said to be a wise choice.

My suggestion is to follow the 80/20 rule: invest more time and energy in organizing and arranging a small number of truly important notes, and invest less time in more secondary content. For example, comprehensive organization is worthwhile for critical project meeting notes or project plans; for general ideas or less core content, basic organization is enough.

Remember, your future self will ultimately face the problems of the present. If you neglect the certain present for the uncertain, idealized future, when will you truly enjoy the benefits of the system? Moreover, the purpose of a redundant system is to serve your thinking and creation, not the other way around. If maintaining the system itself takes up too much time and energy, to the extent that it affects actual thinking and creation, then the system needs to be reassessed and adjusted.

One day, sitting on the steps of a park I often visit to clear my mind, with my eyes closed, basking in the sun, listening to music and the surrounding noise, I suddenly had this insight:

We should focus on the present. The future will eventually become the present at some point. If we cannot handle today well, but only chase after tomorrow, how can we truly own the future?

7. Conclusions

Establishing a redundant note system is not an end in itself, but rather a means to improve the system's reliability and flexibility, to facilitate finding notes when needed, and to discover unexpected connections. Through the reasonable use of folders, tags, links, naming conventions, and timestamps, we can build a personal knowledge management system that can both reliably store information and flexibly adapt to changes.

Importantly, we should not pursue redundancy for redundancy's sake. For less important notes, simple processing is sufficient; while for key information, adding more redundancy safeguards is a wise move. This balance ensures that important information won't be lost, while also preventing us from falling into the trap of excessive complexity in daily operations.

We should remember: the significance of a redundant system lies not in perfectly processing every piece of information, but in ensuring that we can find important information when needed. As emphasized by my PTKM method: highlighting key content is the core of knowledge management.

Ultimately, a well-designed redundant note system becomes an aid to our thinking and creation, not a burden. It allows us to focus on important current tasks while leaving possibilities for future discoveries and connections. This is exactly what I've experienced in building my project, task, and knowledge management system (PTKM) in Obsidian over the past five years, and it's the core concept I want to share with everyone at this moment.

Related Reading

• 12 Obsidian Plugins I Developed