Preamble

We live in an age where technology has become an extension of ourselves. The smartphone, in particular, serves as both a great tool and a great distraction. This manifesto establishes a framework for those who choose to be hyper-creators rather than hyper-consumers — those who use technology as an instrument of creation rather than a vehicle for passive consumption.

The hyper-creator recognizes that technology is neither inherently good nor evil, but that its impact is determined by the intentions and habits of its user. We assert that with deliberate practice and conscious choice, we can harness these tools to enhance our creative potential while defending against their capacity to diminish our autonomy, attention, and well-being.

Core Principles

CREATION BEFORE CONSUMPTION

✅ Acceptable: Using technology to aid writing, sketching, composing, coding, designing, or producing original work.

❌ Unacceptable: Beginning your day by consuming content before creating anything of your own.

The hyper-creator uses technology first and foremost as a tool for expression and production. Morning hours are sacred for creation, not consumption. Your ideas deserve to be born before being influenced by the noise of others.

INTENTIONAL ATTENTION

✅ Acceptable: Focused engagement with applications that serve a specific, predetermined purpose.

❌ Unacceptable: Mindless scrolling, app-hopping, or allowing notifications to fragment your attention.

The hyper-creator’s relationship with technology is characterized by intention, not reaction. Each interaction with your device should be purposeful and time-bound. Your attention is your most valuable resource — deploy it with strategic precision.

TOOL, NOT MASTER

✅ Acceptable: Using technology as an instrument that extends your creative capabilities.

❌ Unacceptable: Allowing technology to dictate your behavior through psychological hooks and addictive design.

The hyper-creator maintains sovereignty over technology. We recognize the sophisticated psychological tactics employed to capture our attention and consciously resist them. Our technology remains in its proper place: as servant, not master.

DEEP WORK OVER SHALLOW ENGAGEMENT

✅ Acceptable: Using technology to facilitate extended periods of concentrated creative effort.

❌ Unacceptable: Allowing technology to enable constant context-switching and superficial thinking.

The hyper-creator values depth over breadth. Quality emerges from sustained focus. Configure your digital environment to protect deep work sessions from interruption, and resist the allure of immediacy and novelty that technology constantly offers.

CURATION OVER ALGORITHM

✅ Acceptable: Deliberately selecting specific sources of information and inspiration.

❌ Unacceptable: Surrendering your information diet to algorithmic recommendation systems optimized for engagement.

The hyper-creator takes active responsibility for what enters their mind. We choose our influences with intention rather than allowing invisible algorithms to shape our worldview based on what will keep us scrolling longest.

CONNECTION, NOT VALIDATION

✅ Acceptable: Using technology to forge meaningful connections around shared creative endeavors.

❌ Unacceptable: Using technology primarily as a source of external validation through likes, comments, and followers.

The hyper-creator values authentic connection over approval metrics. We share our work not to accumulate social currency but to contribute value and engage in genuine dialogue. Our worth is not measured in engagement statistics.

INFORMATION ASYMMETRY AWARENESS

✅ Acceptable: Maintaining awareness of how apps are designed to manipulate your behavior.

❌ Unacceptable: Naively interacting with technology as though it is neutral and without agenda.

The hyper-creator understands that most applications are designed to extract maximum attention and data. We approach each digital interaction with healthy skepticism, recognizing the information asymmetry between users and platforms.

PHYSICAL WORLD PRIMACY

✅ Acceptable: Using technology to enhance your experience of the physical world.

❌ Unacceptable: Allowing technology to replace direct, embodied experience.

The hyper-creator recognizes that creativity flourishes when nourished by tangible experiences. We use technology to augment rather than replace our relationship with the physical world, understanding that our bodies and environments are essential sources of creative insight.

DELIBERATE DIGITAL BOUNDARIES

✅ Acceptable: Establishing clear temporal and spatial boundaries for technology use.

❌ Unacceptable: Allowing technology to permeate every moment and context of your life.

The hyper-creator designates technology-free times and spaces. We create sanctuaries from digital influence — mental, temporal, and physical — allowing our minds the freedom to wander, connect, and generate ideas beyond the digital realm.

ETHICAL CREATION

✅ Acceptable: Using technology to create work that contributes positive value to others.

❌ Unacceptable: Creating content that exploits attention or amplifies division for engagement.

The hyper-creator recognizes their responsibility in what they put into the world. We reject the creation of work that leverages psychological vulnerabilities or contributes to social harm, even if such approaches would gain more attention.

Practical Implementation

To embody these principles, the hyper-creator can:

1. Configure devices to minimize distraction (reduced notifications, grayscale mode, minimalist home screen)
2. Establish clear time boundaries for when and how long technology is used
3. Establish clear purpose boundaries for why certain devices and software applications are used
4. Use tracking tools to maintain awareness of usage patterns
5. Regularly perform digital detoxes to reset habitual patterns
6. Cultivate offline hobbies and relationships that provide perspective
7. Join communities of like-minded creators who reinforce these values
8. Regularly audit installed apps based on whether they facilitate creation or consumption
9. Schedule specific times for consumption rather than allowing it to occur by default
10. Keep technology out of sacred spaces (bedroom, dinner table, creative workspace, human interactions)
11. Practice mindfulness to develop awareness of automatic technology behaviors
12. Refrain from device use in the company of others (especially during conversation) and hold this as a personal standard for good manners

Conclusion

The hyper-creator’s relationship with technology is one of conscious choice rather than passive acceptance. We recognize the revolutionary potential of these tools while remaining vigilant about their capacity to undermine our agency.

This manifesto is not a rejection of technology but a reclamation of its highest purpose: to extend human capabilities and creative potential. By adhering to these principles, we defend not only our own well-being and creative output but also contribute to a culture where technology serves humanity’s deepest needs rather than exploiting our vulnerabilities.

We choose to be creators, not consumers; agents, not products; masters of technology, not mastered by it.

This manifesto may be freely shared, adapted, and implemented by all who aspire to become hyper-creators in an age of engineered distraction.

💬 Contact me to share your thoughts and ideas

First published on Medium on May 16, 2025.

Project: 4th Brain is an Integrated Intelligence Ecosystem developed by a community of artists, digital creators and knowledge workers who collaborate to create and share standards and tools for Personal Knowledge Management (PKM). In this article, we share our current recipe for managing events in Obsidian (Current and Future Events, Recurring Events, Birthdays, Past Events, and Cancelled Events).

Last Modified: May 9, 2025

The End Result: An Events Framework in Obsidian

With this recipe, you can track and report on key events in your life. This framework is not intended to replace the day-to-day utility of a calendar, but rather, it is meant to help you integrate key life events and related event information into your Personal Knowledge Management (PKM) system. This can help you find signals amongst the noise of your day-to-day work and it can help you record and integrate information about the moments that truly matter.

With this framework, you will be able to create new Events from a template, store them in a logical set of recommended folders, and report on them using Dataview queries.

⭐️️️️️️ This recipe is implemented in the 4th Brain Reference Vault for Obsidian, available on GitHub; fork and pull the repository or download the latest release here.

Folders

Our root folder structure follows the PARA Method pattern for PKM, which is optional in this recipe.

• 📁 1 Projects
• 📁 2 Areas
• 📁 3 Resources
• 📁 4 Archive

Within the 3 Resources folder, we have the following folders for event documents (documents created using Template − Event).

• 📁 Events
  - 📁 Cancelled Events
  - 📁 Current and Future Events
  - 📁 Past Events
  - 📁 Recurring Events

Within the Recurring Events folder, we have the following sub-folders.

• 📁 Monthly
• 📁 Weekly
• 📁 Yearly

These sub-folders are not strictly necessary because the Dataview queries we use to select documents are based on document properties and not the folders; still, we think they help keep event documents better organized and easier to manage.

Here’s what all the folders look like together in our reference vault:

Templates

We store all templates in 3 Resources/Templates. You’ll need a template for Event, of course. If you want to support reporting on birthdays, you’ll also want a template for a Person. Following are the properties you’ll want in each.

Template − Event

Create a template named “Template − Event.md” with the following properties.

template: "[[Template - Event]]"
startDate: 
endDate: 
startTime: 
endTime: 
weeklyRecurDay: 
monthlyRecurDay: 
yearlyRecurMonth: 
yearlyRecurDay:

Template − Person

Create a template named “Template − Person” with the following recommended properties (birthday is the only required property in this case).

template: "[[Template - Person]]"
givenName: 
familyName: 
jobTitle: 
email: 
email2: 
telephone: 
streetAddress: 
city: 
stateOrProvince: 
postalCode: 
country: 
birthday:

Required Obsidian Plugins

You’ll need the following Obsidian community plugins installed.

Obsidian Dataview by Michael Brenan
“Treat your Obsidian Vault as a database which you can query from. Provides a JavaScript API and pipeline-based query language for filtering, sorting, and extracting data from Markdown pages.”

This is what we use to query and report on the various kinds of events－sorting them for display.

Obsidian Folder Notes by Lost Paul
“Folder notes is a plugin for the note taking app Obsidian that lets you attach notes to folders so that you can click on the name of a folder to open the note like in the app Notion. This plugin has some unique features that separate it from similar ‘Folder note’ plugins like opening folder notes through the path, creating folder notes for every existing folder, templater/template support and more.”

This allows you to click on event folders to open the folder notes, which are Map of Content (MoC) pages that have the Dataview reports on them.

Templater by SilentVoid
“Templater is a template plugin for Obsidian.md. It defines a templating language that lets you insert variables and functions results into your notes. It will also let you execute JavaScript code manipulating those variables and functions.”

This plugin allows us to right-click on Event folders and select Create new note from template－allowing us to conveniently choose Template − Event when creating new events.

Folder Note Dataview Queries

Finally, configure Dataview queries on the appropriate folder notes.

Current and Future Events

```dataviewjs
const today = DateTime.now();
dv.table(["Name","Start Date", "End Date"],
 dv.pages()
     .sort(doc => [ doc.endDate ], 'asc')
  .where(doc => 
   doc.file.name != "Template - Event" &&
   doc.template?.path?.includes("Template - Event")
  )
  .where(doc => doc.endDate && doc.endDate >= dv.date(today))
  .map(doc => 
   [
    doc.file.link,
    doc.startDate,
    doc.endDate,
   ])  
    )
```

Past Events

```dataviewjs
const today = DateTime.now();
dv.table(["Name","Start Date", "End Date"],
 dv.pages()
     .sort(doc => [ doc.endDate ], 'asc')
  .where(doc => 
   doc.file.name != "Template - Event" &&
   doc.template?.path?.includes("Template - Event")
  )
  .where(doc => doc.endDate && doc.endDate < dv.date(today))
  .map(doc => 
   [
    doc.file.link,
    doc.startDate,
    doc.endDate,
   ])  
    )
```

Recurring Events

```dataviewjs
// Get today's date
const today = DateTime.now();

// Function to convert 24h time to 12h time with AM/PM
function formatTime12h(time24h) {
    if (!time24h || time24h === "N/A") return "N/A";
    
    // Parse the hour and minute
    const [hours, minutes] = time24h.split(':').map(num => parseInt(num, 10));
    
    if (isNaN(hours) || isNaN(minutes)) return time24h;
    
    // Convert to 12-hour format
    const period = hours >= 12 ? "PM" : "AM";
    const hours12 = hours % 12 || 12; // Convert 0 to 12 for 12 AM
    
    // Format as "1:30 PM" etc.
    return `${hours12}:${minutes.toString().padStart(2, '0')} ${period}`;
}

// Helper function for ordinal suffixes
function getOrdinalSuffix(day) {
    if (typeof day === 'string') day = parseInt(day);
    if (isNaN(day)) return '';
    
    if (day % 10 === 1 && day % 100 !== 11) return 'st';
    if (day % 10 === 2 && day % 100 !== 12) return 'nd';
    if (day % 10 === 3 && day % 100 !== 13) return 'rd';
    return 'th';
}

// ========== WEEKLY EVENTS ==========
dv.header(2, "Weekly Recurring Events");

// Get all files in the Weekly folder
const weeklyEvents = dv.pages()
    .where(p => p.weeklyRecurDay);

// Map of day numbers to names for sorting and display
const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
const dayMap = {};
dayNames.forEach((name, index) => {
    dayMap[name.toLowerCase()] = index;
});

// Sort events by day of week and start time
const sortedWeekly = weeklyEvents.sort(p => [
    // Sort by day number
    p.weeklyRecurDay ? (typeof p.weeklyRecurDay === 'number' ? p.weeklyRecurDay : dayMap[p.weeklyRecurDay.toLowerCase()]) : 7,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Day", "Start Time", "End Time"],
    sortedWeekly.map(p => [
        p.file.link,
        p.weeklyRecurDay,
        formatTime12h(p.startTime),
        formatTime12h(p.endTime)
    ])
);

// ========== MONTHLY EVENTS ==========
dv.header(2, "Monthly Recurring Events");

// Get all files in the Monthly folder
const monthlyEvents = dv.pages()
    .where(p => p.monthlyRecurDay);

// Sort events by day of month and start time
const sortedMonthly = monthlyEvents.sort(p => [
    // Sort by day of month
    parseInt(p.monthlyRecurDay) || 32,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Day of Month", "Start Time", "End Time"],
    sortedMonthly.map(p => [
        p.file.link,
        p.monthlyRecurDay ? (p.monthlyRecurDay + getOrdinalSuffix(p.monthlyRecurDay)) : "N/A",
        formatTime12h(p.startTime),
        formatTime12h(p.endTime)
    ])
);

// ========== YEARLY EVENTS ==========
dv.header(2, "Yearly Recurring Events");

// Get all files in the Yearly folder
const yearlyEvents = dv.pages('"3 Resources/Events/Recurring Events/Yearly"')
    .where(p => p.recurMonth && p.recurDay);

// Month names for sorting and display
const monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
const monthMap = {};
monthNames.forEach((name, index) => {
    monthMap[name.toLowerCase()] = index;
});

// Sort events by month, day and start time
const sortedYearly = yearlyEvents.sort(p => [
    // Sort by month number
    p.recurMonth ? (typeof p.recurMonth === 'number' ? p.recurMonth - 1 : monthMap[p.recurMonth.toLowerCase()]) : 12,
    // Then by day
    parseInt(p.recurDay) || 32,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Date", "Start Time", "End Time"],
    sortedYearly.map(p => {
        // Format the date as "Month Day"
        let monthDisplay = p.recurMonth;
        if (typeof p.recurMonth === 'number') {
            monthDisplay = monthNames[p.recurMonth - 1];
        }
        
        let dateDisplay = monthDisplay + " " + p.recurDay;
        if (p.recurDay) {
            dateDisplay += getOrdinalSuffix(p.recurDay);
        }
        
        return [
            p.file.link,
            dateDisplay,
            formatTime12h(p.startTime),
            formatTime12h(p.endTime)
        ];
    })
);
```

Upcoming Birthdays

Change the value of the daysAhead variable at the top of this script to change how far you want to look ahead (to change what you define as “upcoming,” that is).

```dataviewjs
// Get today's date
const today = DateTime.now();

// Function to convert 24h time to 12h time with AM/PM
function formatTime12h(time24h) {
    if (!time24h || time24h === "N/A") return "N/A";
    
    // Parse the hour and minute
    const [hours, minutes] = time24h.split(':').map(num => parseInt(num, 10));
    
    if (isNaN(hours) || isNaN(minutes)) return time24h;
    
    // Convert to 12-hour format
    const period = hours >= 12 ? "PM" : "AM";
    const hours12 = hours % 12 || 12; // Convert 0 to 12 for 12 AM
    
    // Format as "1:30 PM" etc.
    return `${hours12}:${minutes.toString().padStart(2, '0')} ${period}`;
}

// Helper function for ordinal suffixes
function getOrdinalSuffix(day) {
    if (typeof day === 'string') day = parseInt(day);
    if (isNaN(day)) return '';
    
    if (day % 10 === 1 && day % 100 !== 11) return 'st';
    if (day % 10 === 2 && day % 100 !== 12) return 'nd';
    if (day % 10 === 3 && day % 100 !== 13) return 'rd';
    return 'th';
}

// ========== WEEKLY EVENTS ==========
dv.header(2, "Weekly Recurring Events");

// Get all files in the Weekly folder
const weeklyEvents = dv.pages()
    .where(p => p.weeklyRecurDay);

// Map of day numbers to names for sorting and display
const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
const dayMap = {};
dayNames.forEach((name, index) => {
    dayMap[name.toLowerCase()] = index;
});

// Sort events by day of week and start time
const sortedWeekly = weeklyEvents.sort(p => [
    // Sort by day number
    p.weeklyRecurDay ? (typeof p.weeklyRecurDay === 'number' ? p.weeklyRecurDay : dayMap[p.weeklyRecurDay.toLowerCase()]) : 7,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Day", "Start Time", "End Time"],
    sortedWeekly.map(p => [
        p.file.link,
        p.weeklyRecurDay,
        formatTime12h(p.startTime),
        formatTime12h(p.endTime)
    ])
);

// ========== MONTHLY EVENTS ==========
dv.header(2, "Monthly Recurring Events");

// Get all files in the Monthly folder
const monthlyEvents = dv.pages()
    .where(p => p.monthlyRecurDay);

// Sort events by day of month and start time
const sortedMonthly = monthlyEvents.sort(p => [
    // Sort by day of month
    parseInt(p.monthlyRecurDay) || 32,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Day of Month", "Start Time", "End Time"],
    sortedMonthly.map(p => [
        p.file.link,
        p.monthlyRecurDay ? (p.monthlyRecurDay + getOrdinalSuffix(p.monthlyRecurDay)) : "N/A",
        formatTime12h(p.startTime),
        formatTime12h(p.endTime)
    ])
);

// ========== YEARLY EVENTS ==========
dv.header(2, "Yearly Recurring Events");

// Get all files in the Yearly folder
const yearlyEvents = dv.pages('"3 Resources/Events/Recurring Events/Yearly"')
    .where(p => p.recurMonth && p.recurDay);

// Month names for sorting and display
const monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
const monthMap = {};
monthNames.forEach((name, index) => {
    monthMap[name.toLowerCase()] = index;
});

// Sort events by month, day and start time
const sortedYearly = yearlyEvents.sort(p => [
    // Sort by month number
    p.recurMonth ? (typeof p.recurMonth === 'number' ? p.recurMonth - 1 : monthMap[p.recurMonth.toLowerCase()]) : 12,
    // Then by day
    parseInt(p.recurDay) || 32,
    // Then by start time
    p.startTime || "23:59"
]);

// Render the table
dv.table(["Event", "Date", "Start Time", "End Time"],
    sortedYearly.map(p => {
        // Format the date as "Month Day"
        let monthDisplay = p.recurMonth;
        if (typeof p.recurMonth === 'number') {
            monthDisplay = monthNames[p.recurMonth - 1];
        }
        
        let dateDisplay = monthDisplay + " " + p.recurDay;
        if (p.recurDay) {
            dateDisplay += getOrdinalSuffix(p.recurDay);
        }
        
        return [
            p.file.link,
            dateDisplay,
            formatTime12h(p.startTime),
            formatTime12h(p.endTime)
        ];
    })
);
```

Conclusion

In this article, I shared the current 4th Brain recipe for managing Events in Obsidian.

If memorable moments are important to your life, shouldn’t they also be important to your Personal Knowledge Management (PKM) system? Obsidian Event instances (markdown documents of the type Template − Event) not only give us important reminders at-a-glance, they also allow us to relate and integrate important event information throughout all of our notes. This turns each Event into a memory keepsake that can have its own notes and that can be linked to other notes.

I hope this recipe gives you some ideas or a solid start in creating the system that works for you!

If you’re interested in following Project: 4th Brain or more content like this:

💬 Contact me to share your thoughts and ideas
⭐️ Star the 4th Brain Reference Vault on GitHub

First published on Medium on May 10, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

PROGRESSIVE SUMMARIZATION

Version 1, last modified: March 8, 2025

Knowledge workers collect vast oceans of information — articles, books, research, ideas — only to find themselves drowning in this sea of content later. They capture everything with the best intentions, but when they return to these notes weeks or months later, they face a painful dilemma: either spend hours re-reading everything or miss crucial context by skimming too quickly.

The challenge runs deeper than simple information management. Our minds seek both detail and summary, context and essence. We need the full richness of information when diving deep, but require concentrated extraction when reviewing broadly. Traditional approaches force an impossible choice: highlight too much and lose focus, summarize too aggressively and lose context.

We have observed that:

1. Different moments demand different levels of information density
2. The most valuable insights often emerge from context, not isolation
3. Single-pass processing rarely captures the true hierarchy of importance
4. Time available for review varies dramatically by situation
5. Our understanding of material evolves through multiple exposures
6. Initial processing time must balance with future retrieval value
7. The same content serves different purposes at different times
8. Valuable ideas build upon supporting evidence and context
9. Perfect highlighting on first read is nearly impossible

Therefore:

Create a layered system of progressive information density that preserves full context while enabling rapid review at multiple levels of detail. Process important content through successive layers of distillation:

• Layer 0: Capture the complete original content
• Layer 1: Bold the most important 10–20% of the material
• Layer 2: Highlight the most critical 10–20% of the bolded content
• Layer 3: Create margin notes capturing key insights and connections
• Layer 4: Write a brief executive summary at the top

Each layer builds upon previous layers, progressively increasing information density while maintaining access to full context. Most importantly, these layers need not be created all at once — they can be added progressively as content proves its value through use and reflection.

The system works because it mirrors how our minds naturally process information through repeated exposure. Rather than forcing an artificial choice between detail and summary, it creates a gradient of density that supports different review needs. The progressive approach aligns with how our understanding evolves, allowing our processing to deepen alongside our comprehension.

This pattern transforms knowledge work in various contexts:

• A researcher reviewing literature can quickly scan Layer 4 summaries to find relevant sources, then dive into highlighted sections for precise references
• A student studying for exams can review margin notes for quick recall, then explore bolded passages to strengthen understanding
• A writer collecting research can easily scan highlighted sections for quotes while maintaining full context
• A professional reviewing meeting notes can quickly grasp key decisions from summaries while maintaining access to discussion details

When successfully implemented, Progressive Summarization creates a dynamic, evolving relationship with your notes. Rather than static documents that require complete re-reading, they become landscapes with well-marked paths of varying detail. You invest processing time progressively, focusing effort on content that proves most valuable through use.

This pattern is strengthened when combined with:

• PARA METHOD for organizing content by actionability
• ATOMIC NOTES for breaking complex topics into discrete concepts
• EVERGREEN NOTES for developing key insights over time
• MAP OF CONTENT for navigating between related notes
• BIDIRECTIONAL LINKING for discovering unexpected connections
• KNOWLEDGE LIFECYCLE for managing notes through different stages

References:

• Building a Second Brain by Tiago Forte
• Progressive Summarization: A Practical Technique for Designing Discoverable Notes by Tiago Forte, fortelabs.com
• Is Progressive Summarization a Waste of Time? by James Stuber, jamesstuber.com

Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on March 10, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

BIDIRECTIONAL LINKING

Version 1, last modified: March 2, 2025

In our quest to manage knowledge effectively, we’ve discovered something profound: the relationships between ideas are often as important as the ideas themselves. Traditional knowledge systems create one-way connections — like a webpage linking to another webpage without any trace of that connection on the receiving end. This approach reflects only half the reality of how knowledge actually works. In our minds, ideas don’t just point to other ideas; they form an intricate web of mutual references and associations.

Knowledge workers struggle to create and maintain meaningful connections between their notes in a way that reveals both explicit and implicit relationships, supports unexpected discoveries, and helps them understand the broader context of their knowledge.

This challenge emerges from the fundamental nature of knowledge work. Ideas reference other ideas. Concepts build upon concepts. Yet maintaining these relationships manually becomes increasingly burdensome as our knowledge grows. We need to see not just what a note links to, but what links to it — a perspective that traditional systems rarely provide.

We have observed that:

1. Ideas naturally reference other ideas in multiple directions
2. Connections are often relevant in both directions, not just one way
3. Manually tracking references becomes exponentially difficult as note collections grow
4. Our understanding of relationships between notes evolves over time
5. Both outgoing and incoming connections provide crucial context
6. The context of how notes refer to each other matters as much as the connection itself
7. Network effects increase dramatically with each additional bidirectional link
8. Traditional one-way links capture only half of the relationship between ideas

Therefore:

Create a system of bidirectional linking where every connection from one note to another automatically establishes a reverse connection that remains continuously updated, making both outgoing and incoming relationships visible and navigable.

The essence of this pattern involves:

1. Automatic reverse linking — the system creates and maintains backlinks without user intervention
2. Visible relationship context — both notes display their incoming and outgoing links
3. Effortless creation — links are easily created using simple, consistent notation (e.g., [[Note Title]])
4. Context preservation — backlinks show the surrounding text to preserve how notes refer to each other
5. Navigational ease — users can move effortlessly in both directions between connected notes
6. Relationship types — when needed, links can be annotated to specify the nature of the relationship

For example, in a note about “Habit Formation,” you might write:

The concept of habit stacking builds on [[Implementation Intentions]] by creating a clear trigger for new behaviors.

Then, in your “Implementation Intentions” note, a backlinks section automatically shows:

Referenced in: Habit Formation — “The concept of habit stacking builds on Implementation Intentions by creating a clear trigger for new behaviors.”

This bidirectionality transforms both notes. The original note gains depth through its connection to an established concept. The referenced note gains new application context it didn’t contain before — without any additional effort from you.

The system works because it mirrors how our minds naturally create associations between ideas. When we think about a concept, we naturally consider both “what does this relate to?” and “what relates to this?” Bidirectional linking captures this dual nature of relationships, allowing our knowledge systems to more accurately reflect our thinking processes.

This pattern transforms knowledge work across different contexts:

• A researcher writing about climate policy discovers through backlinks that their notes on carbon tax unexpectedly connect to behavioral economics, revealing a new research direction.
• A student using bidirectional linking can see all different contexts where a specific concept appears when studying for exams, strengthening their understanding of its applications.
• A project manager linking from meeting notes to action items allows team members to see all meetings where their tasks were discussed through backlinks, providing fuller context.
• A writer crafting an article discovers additional supporting material they had forgotten about by reviewing backlinks to their evidence notes.
• A product designer documenting user feedback can see, through backlinks, all the different user problems a potential feature might address.

The success of this pattern has been proven across various knowledge management tools and systems. Following are just a few:

• Roam Research: Is said to have pioneered the modern implementation of “networked thought” through bidirectional linking
• Obsidian: Built its “second brain” approach around the core of automatic backlinks
• LogSeq: Combined bidirectional linking with outlining for knowledge organization

This pattern is strengthened when combined with:

• Atomic Notes: Small, focused notes create clearer, more specific relationships than large documents
• Knowledge Graph: Visualizes the network of relationships created by bidirectional links
• Map of Content: Provides curated entry points into networks of bidirectionally linked notes
• Trail Marker: Documents paths through networks of linked notes
• Concept Clustering: Groups emerge naturally through bidirectional link patterns
• Emergence Board: Provides space to explore patterns discovered through backlinks

When successfully implemented, bidirectional linking transforms how knowledge workers think about and interact with their notes. Knowledge becomes a network rather than a collection. Unexpected connections emerge naturally through backlinks. Each note gains depth from the various ways other notes refer to it. Navigation becomes more intuitive, following curiosity rather than searching a database. Maintenance becomes lighter as the system handles relationship tracking. Understanding deepens as concepts interconnect in multiple directions.

The transformative power of bidirectional linking lies in how it aligns our knowledge systems with how our minds naturally work — not as collections of isolated documents, but as rich networks of interconnected thoughts, constantly informing and enriching each other from multiple directions.

References:

• A Short History of Bi-Directional Links by Maggie Appleton, maggieappleton.com
• Notion Backlinks: Why I Love Them (And How I Use Them) by Sam Thomas Davies, samuelthomasdavies.com
• Be honest! How useful are bi-directional links? by lucidself (et al.), reddit
• HyperText Design Issues: Topology by Tim Berners-Lee, w3c.org (interesting early contemplations on web hyperlinks)

Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on March 2, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

ZETTELKASTEN METHOD

Version 1, last modified: Feb 22, 2025

Knowledge workers struggle to develop and connect ideas effectively over time. They capture thoughts and information, but these often remain scattered and disconnected, failing to evolve into deeper understanding. Traditional note-taking approaches tend to create either rigid, hierarchical structures that limit organic growth, or loose collections that lack the systematic development needed for genuine knowledge building.

The deepest problem is that human understanding develops through the gradual accumulation and connection of atomic ideas, but our typical ways of capturing and organizing information don’t support this natural process. We tend to impose hierarchical structures that force ideas into predetermined categories, or let thoughts float freely without systematic development. Neither approach matches how knowledge actually grows in our minds — through organic connections that form a network rather than a tree. Without a method that mirrors the networked, interconnected nature of thought while providing a clear workflow for development, our notes become either constraining or chaotic.

We have observed that:

1. Ideas develop gradually through non-hierarchical connection and refinement
2. Hierarchical organization often constrains natural thought development
3. Knowledge emerges bottom-up rather than top-down
4. Understanding emerges from linking atomic concepts
5. Knowledge work happens in distinct phases (capture, process, connect, create)
6. Different types of notes serve different purposes
7. Permanent knowledge needs systematic development
8. Connections between ideas are as valuable as the ideas themselves
9. Good systems support both structured and spontaneous thinking
10. References and sources need reliable addressing
11. Physical constraints can enhance clarity and focus
12. Digital tools enable new forms of connection and discovery

Therefore:

Create a systematic method for developing knowledge through three distinct types of notes, each with its own purpose and characteristics:

• Fleeting Notes
  - Quick captures of spontaneous thoughts
  - Temporary by design
  - Minimal structure requirements
  - Focus on capturing essence
  - Regular processing into other note types
• Literature Notes
  - One idea per note
  - Written in your own words
  - Clear source references
  - Focused on understanding
  - Connection to original context
• Permanent Notes
  - Atomic ideas (one concept per note)
  - Unique identifiers for reliable linking
  - Written for future understanding
  - Explicit connections to other notes
  - Platform-independent format
  - Clear, standalone expression
  - Built from fleeting and literature notes

Workflow and Implementation:

The Zettelkasten method follows a specific workflow that moves from capture to creation:

• Capture Phase
  - Record fleeting notes immediately as thoughts occur
  - Take literature notes while consuming content
  - Keep capture friction low and worry about organization later
• Process Phase
  - Review fleeting notes daily
  - Convert relevant fleeting notes into permanent notes
  - Transform literature notes into your own words
  - Make notes atomic during processing
  - Add relevant metadata and tags
• Connect Phase
  - Create explicit links between related notes
  - Look for unexpected connections
  - Build indexes and entry points
  - Let structure emerge from connections
  - Avoid forcing hierarchical organization
• Create Phase
  - Use connected notes to develop new ideas
  - Follow chains of thought through note networks
  - Create new content from linked insights
  - Document new thoughts as they emerge
• Review Phase
  - Regularly review and refine connections
  - Update indexes and entry points
  - Look for emerging patterns
  - Maintain system without imposing structure

Implementation Steps:

1. Create a simple capture system for fleeting notes
2. Process source materials into atomic literature notes
3. Review and develop permanent notes daily
4. Use unique identifiers for permanent notes
5. Make explicit connections between notes
6. Create entry points through index notes
7. Regular review and refinement
8. Focus on developing ideas over time

The system works because it mirrors how knowledge naturally develops in our minds while providing systematic support for that development. Like a scaffold for growing ideas, it gives structure without constraint, allowing thoughts to develop organically while ensuring they remain accessible and connected.

Digital Implementation Note:

While originally developed as a physical system using index cards (which naturally enforced atomic ideas through space constraints), the Zettelkasten method has found new power in digital tools. Modern implementations can maintain the benefits of physical constraints (through interface design and practice) while adding capabilities like:

• Full-text search
• Automated backlinks
• Dynamic visualization
• Multimedia integration
• Collaborative development
• Version history
• Multiple access points
• Automated ID generation

However, successful digital implementation requires careful attention to maintain the method’s core principles, particularly:

• Atomic note creation
• Clear unique identifiers
• Platform independence
• Connection-based organization
• Progressive development

The success of this pattern has been proven across both physical and digital implementations. Systems that implement Zettelkasten principles report:

• Improved idea development
• Enhanced creative output
• Better retention and understanding
• More natural knowledge organization
• Supported serendipitous discovery
• Clearer thinking processes
• Increased productive output
• Sustainable long-term growth

This pattern has been particularly successful in:

• Academic research
• Writing workflows
• Creative projects
• Learning systems
• Knowledge development
• Content creation
• Personal research

The pattern is strengthened when combined with:

• ATOMIC NOTES
• BIDIRECTIONAL LINKING
• LITERATURE NOTES TO PERMANENT NOTES
• KNOWLEDGE GRAPH
• PROGRESSIVE SUMMARIZATION
• MAP OF CONTENT

References

• How to Take Smart Notes: One Simple Technique to Boost Writing, Learning and Thinking by Sönke Ahrens
• Introduction to the Zettelkasten Method by Sascha, zettelkasten.de
• Zettelkasten, Wikipedia
• Zettelkasten Method Explained: A Beginner’s Guide by Vicky Zhao, YouTube

Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on February 22, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

EVERGREEN NOTES

Version 1, last modified: February 14, 2025

Knowledge workers accumulate vast collections of notes, but most of these remain frozen in time — static snapshots of understanding that gradually become outdated and lose their value. Their digital gardens fill with annual plants that flower briefly and die, rather than hardy perennials that return season after season with deeper roots and broader branches. Without a way to nurture and grow their most important ideas, users find themselves constantly starting over, rewriting the same concepts with only slightly better understanding each time.

The deepest problem is that our understanding of important ideas naturally evolves over time, but our note-taking habits treat each note as a finished product rather than a living document. We capture insights but fail to cultivate them. When we return to these static notes months or years later, we find them inadequate — like visiting a garden where nothing has grown since planting day. Our most valuable ideas deserve to be more than mere snapshots; they need to be evergreen, growing and maturing alongside our understanding.

We observe that:

• Understanding develops gradually through repeated encounters and refinement
• Each time we revisit an important concept, we see it from a slightly different angle
• New connections become apparent as we work with ideas over time
• Gaps in our knowledge reveal themselves through repeated engagement
• Examples that once seemed perfect come to feel incomplete with experience
• Our own words from months ago start to sound foreign or inadequate
• Most note-taking systems have no systematic way to capture developmental insights
• Static notes fail to reflect the natural evolution of our understanding
• The most valuable ideas tend to be those we return to repeatedly
• Knowledge grows through iteration rather than simple accumulation

Therefore:

Create and maintain evergreen notes that grow stronger and more valuable over time through active cultivation. Unlike regular notes that capture a moment in time, evergreen notes should:

• Focus on fundamental, unchanging concepts rather than ephemeral details
• Be written for your future self, explaining context and connections that may not be obvious in the moment
• Be cultivated through regular cycles of review and refinement, preserving their core while allowing their expression to mature
• Maintain rich connections to other notes, creating a web of reinforcing understanding
• Track their development over time, not to preserve history but to reveal patterns of growth

The system works because it mirrors how human understanding actually develops — not in sudden leaps, but through gradual accumulation and refinement. Like a tree adding rings year after year, evergreen notes grow stronger and more valuable through cycles of development. Each review cycle enriches rather than replaces what came before.

Most importantly, this pattern helps establish STABLE CONCEPTUAL FOUNDATIONS while supporting CONTINUOUS GROWTH AND REFINEMENT. It works together with ATOMIC NOTES (for clarity of concept) and BIDIRECTIONAL LINKING (for rich context) while enabling both PROGRESSIVE SUMMARIZATION (for layered understanding) and GARDEN MAINTENANCE (for sustainable development).

The success of this pattern has been proven across many knowledge management approaches. Systems that implement evergreen notes report:

• Better retention of core concepts
• Deeper understanding over time
• More valuable knowledge assets
• Clearer thinking and writing
• Enhanced pattern recognition
• Stronger conceptual foundations
• More efficient learning
• Reduced duplicate work

This pattern is particularly powerful when applied to:

• Fundamental concepts and principles
• Personal philosophy and worldview
• Hard-won insights and realizations
• Method and process documentation
• Framework definitions and explanations
• Research foundations and premises
• Teaching and learning resources

The pattern becomes stronger when combined with:

• ATOMIC NOTES
• BIDIRECTIONAL LINKING
• PROGRESSIVE SUMMARIZATION
• CONCEPT CLUSTERING
• GARDEN MAINTENANCE
• KNOWLEDGE GRAPH
• VERSION HISTORY

Through evergreen notes, we transform our knowledge management from a collection of snapshots into a living garden — one where our most valuable ideas can put down deep roots and grow alongside our understanding, becoming more valuable with each passing season.

References

• Get started with easy, evergreen notes for personal knowledge management (PKM) by Austin Govella, Medium
• Andy Matuschak’s evergreen notes about evergreen notes by Andy Matuschak
• Growing the Evergreens: Illustrated notes on the concept of ‘Evergreen notes’ and how to write them by Maggie Appleton, maggieappleton.com
• Reflection on two years of writing evergreen notes: not optimal for skill acquisition and learning by Roman Leventov, Medium
• Cultivate Your Creative Potential with Evergreen Notes by Angie Bowen, Medium

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on February 15, 2025.

Project: 4th Brain is a work-in-progress platform and plugin for Obsidian. Currently being developed with Supabase as its backend, this open-source project focuses on multi-channel publishing, standardized PKM patterns, and AI-augmented knowledge management.

In my previous log entry, I shared the GitHub repository for Project 4th Brain (an open-source Obsidian plugin being developed with a Supabase backend), and although the code is in its early stages with nothing yet ready for prime time, I made it public for transparency. I implemented the functionality for creating a new website (site entry) from within Obsidian and for publishing Obsidian markdown documents into it with document versioning supported. I am still focused on the networking and server storage; none of this can yet be served in a front-end website, but I’ll be getting to that part soon.

For context, and for those who don’t know, the first part of the 4th Brain platform being built is an open-source alternative to Obsidian Publish allowing you to host your own Obsidian-managed websites on your own Supabase server. This will enable you to run your sites on any cloud provider of choice or the Supabase cloud service. Initially, this will give people a foundation for building their own websites, using Obsidian as the content management client, with more website front-end customization capability than Obsidian Publish affords; a purely open-source solution that you can hack to your heart’s content.

Image Sync Support Added

Somewhere over the course of the week, I had an “Oh, shit!” moment when it suddenly occurred to me that I’d made no concession for the images embedded in your local vault’s markdown documents! Luckily, Supabase has support for File Storage, so I was able to implement that functionality today.

At first, I believed that if I wanted to extract the embedded images (attachments) from a markdown document, I’d first have to parse the document into an Abstract Syntax Tree (AST). I learned, however, that these embeds were already available in the cached metadata of the file…

const fileCache: CachedMetadata | null = this.app.metadataCache.getFileCache(file);
const embeds: EmbedCache[] = fileCache.embeds;

Uploading them to the sever bucket was not difficult, but honoring the goal to support multiple users and multiple sites on a single server was tricky. My solution in the end was to have a single file storage bucket on the server, with folders named with each site’s slug like so…

🪣 resources (bucket)
    📂 site-1
    📂 site-2
    📂 site-3

Within each site, the path for each file mirrors the Obsidian vault path to the file.

Each site in the bucket is secured so that only the site owner can insert, update, and delete in their respective site folder. This is achieved with a special policy for each operation type (insert, update, delete) that ensures the authenticated user is the site owner for the bucket folder they’re operating in.

Next Steps

Now that we can sync both the markdown document and all attached images to the backend server from within Obsidian, I’m just back where I was before I remembered that I’d need to support syncing file attachments (DOH!). At this point, I’ve got a simple headless CMS with Obsidian as the client.

I’m eager to start working on the part that renders server data in a website.

I do not yet know if I will need to add a web server container to the Docker compose file (and use something like Java / Spring or Node.js) or if I can get away with using Supabase Edge Functions.

I’m closing with similar questions to those I had last week, in case you have an opinion to contribute:

• Should the site be generated into a static site for screaming-fast performance or should pages be queried at runtime and cached on the server?
• If an app server technology is used, what’s the ideal language for the server-side stuff? Java (e.g. Spring Boot), Node.js or Supabase Edge Workers?
• How will website keyword search be supported? Full-text search supported in the Postgres database or something like Apache Solr that might be more robust and better performing at scale?

Anyhoo…if you care to look at any of the code so far, these are the main three classes of interest:

• main.ts — the main Obsidian plugin file
• supabase-service.ts — the SupabaseService class
• init-supabase.sql — the script that creates the database tables, indexes, functions, and policies

If you’re interested in following along or contributing to the vision for this platform, you can:

💬 Contact me to share your thoughts and ideas

First published on Medium on February 9, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

MAP OF CONTENT

Version 1, last modified: Feb 6, 2025

Knowledge workers struggle to navigate their ever-growing collections of notes and ideas. As their digital archives expand, they find themselves lost in a maze of disconnected information, unable to see the broader patterns or find specific content when needed. Traditional organizational systems either become too rigid (like hierarchical folders) or too chaotic (like pure tag-based systems), making it increasingly difficult to maintain a clear mental model of their knowledge landscape.

The deepest problem is that humans need both structure and flexibility in how they organize and access their knowledge. Pure hierarchies become brittle and limiting over time, while completely flat organizations provide no guidance or context. Without clear maps to guide them, users become overwhelmed by the complexity of their knowledge systems, leading to decreased engagement and lost insights.

We have observed that:

1. Notes naturally form clusters around topics and themes
2. Users need multiple ways to access and discover their notes
3. Understanding requires both overview and detail
4. Pure tag systems become unwieldy at scale
5. Hierarchical structures can be too rigid for evolving knowledge
6. Direct note-to-note links alone can create a confusing maze
7. Knowledge structure should emerge from use rather than being predetermined
8. Navigation needs change based on context and purpose
9. Users need both planned and spontaneous access to their knowledge

Therefore:

Create dedicated notes that serve as curated indexes and navigation hubs for specific topics or areas of interest. These “Maps of Content” (MOCs) should contain:

1. A clear scope statement defining the territory the map covers
2. Carefully selected links to relevant notes, organized meaningfully
3. Brief contextual descriptions for linked notes
4. Optional structural elements like sections, categories, or sequences
5. Links to related MOCs at the same or different levels of abstraction

Implementation:

1. Begin creating an MOC when you notice a cluster of related notes forming
2. Write a clear scope statement at the top
3. Add links to relevant notes with brief contextual descriptions
4. Organize links in a way that serves your thinking and navigation needs
5. Add structural elements (sections, sequences) as patterns emerge
6. Link to related MOCs to create layers of organization
7. Regularly revise as your understanding and note collection evolves
8. Use MOCs as both navigational tools and thinking spaces

Examples:

• A “Writing Techniques MOC” linking to notes on style, structure, and process
• A “Project X MOC” gathering all notes related to a specific project
• A “Biology Concepts MOC” organizing notes on biological principles
• A high-level “Knowledge Atlas MOC” linking to other major MOCs
• A “Research Questions MOC” organizing current investigations
• A “Learning Path MOC” sequencing educational content

The system works because it mirrors how our minds naturally organize and access information. MOCs provide flexible structure without imposing rigid hierarchies, allowing organization to emerge organically while maintaining clear navigation paths. They serve as both maps for exploring and workbenches for developing ideas.

Most importantly, this pattern helps establish CLEAR NAVIGATION PATHS while maintaining FLEXIBLE ORGANIZATION. It works together with CONCEPT CLUSTERING (another pattern) and supports both KNOWLEDGE GRAPH (another pattern) and TRAIL MARKER (another pattern).

The success of this pattern has been proven across various knowledge management approaches. Systems that implement MOCs report:

• Reduced time spent searching for information
• Clearer understanding of knowledge structure
• Enhanced discovery of connections
• More flexible organization
• Better support for both planned and spontaneous access
• Improved ability to see patterns and relationships
• Greater engagement with existing notes
• Easier maintenance of growing systems

This pattern has been particularly successful in:

• Personal knowledge management systems
• Research organizations
• Writing workflows
• Learning environments
• Project documentation
• Digital gardens
• Team knowledge bases

The pattern is strengthened when combined with:

• BIDIRECTIONAL LINKING
• CONCEPT CLUSTERING
• KNOWLEDGE GRAPH
• TRAIL MARKER
• ATOMIC NOTES
• PARA METHOD

References:

• Maps of Content (MoCs) for better Knowledge Graphs by Sébastien Dubois, Medium
• MOCs & Idea Emergence: A discussion w/ Nick Milo and his LYT framework for Obsidian, YouTube
• Maps of Content: Effortless organization for notes, Obsidian Rocks
• Quickly Organize Notes in Obsidian, Obsidian Rocks

Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on February 6, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

IDEA INCUBATOR

Version 1, last modified: Feb 4, 2025

Knowledge emerges gradually through a process of contemplation, connection, and refinement. Ideas start as fragile seeds that need nurturing before they’re ready to be integrated into our broader understanding. Yet our knowledge management systems often force us to either immediately organize these emerging thoughts or risk losing them entirely.

The deepest problem is that our natural process of developing ideas doesn’t match how we typically organize information. We try to force embryonic thoughts into fully formed structures too early, or we let promising insights fade because they don’t yet fit our organizational schemes. Ideas need time and space to develop, but without proper care, they either get prematurely crystallized or lost entirely.

We have observed that:

1. Ideas often begin as vague intuitions or partial insights
2. Forcing early organization can stifle idea development
3. Valuable thoughts can be lost if not captured
4. Different ideas mature at different rates
5. Most ideas need iteration to reach their potential
6. Early feedback helps shape development
7. Ideas can unexpectedly combine or split
8. Development paths aren’t always linear
9. Context and connections emerge over time

Therefore:

Create dedicated spaces and processes for nurturing emerging ideas through distinct developmental stages:

Initial Capture

• Quick entry mechanisms for catching fleeting thoughts
• Minimal structure requirements
• Basic context preservation
• Timestamp for temporal reference
• Rough connection notes

Development Space

• Regular review cycles
• Progress tracking
• Connection exploration
• Development prompts
• Resource linking
• Working notes
• Feedback loops

Maturation Tracking

• Clear status indicators
• Development milestones
• Integration readiness markers
• Next step prompts
• Connection mapping

The system works because it mirrors the natural lifecycle of idea development. Like a greenhouse for growing plants, it provides protected space where fragile thoughts can develop at their own pace while ensuring they receive regular attention and care. The staged approach prevents both premature organization and idea loss while supporting organic growth.

This pattern becomes stronger when combined with:

• ATOMIC NOTES for capturing developed insights
• BIDIRECTIONAL LINKING for connection exploration
• EVERGREEN NOTES for mature integration
• KNOWLEDGE GRAPH for seeing relationships
• PROGRESSIVE SUMMARIZATION for development
• QUESTION CASCADE for deepening understanding

Known uses:

• Research development environments
• Writing workflows
• Project ideation spaces
• Learning journals
• Innovation systems
• Creative development tools

References

• Ideation: Incubation places space between an idea and a decision. by Kristi Riggs, Medium
• Incubating Ideas — How to Supercharge Your Creative Process by Jim Eagar, Original Mac Guy
• My Obsidian Setup (Part 13) — Inbox Folder / Quick Note Capture Workflow by Nuno Campos, Medium

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on February 4, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

ATOMIC NOTES

Version 2, last modified: February 22, 2025

Knowledge workers struggle to capture and organize complex ideas in ways that remain useful over time. They write long, interconnected notes that become increasingly difficult to understand, maintain, and reuse. Without a clear way to break down complex thoughts into manageable pieces, their knowledge becomes trapped in dense, monolithic documents that resist both understanding and reorganization.

The deepest problem is that human understanding naturally works with discrete, interconnected concepts, but our writing habits tend toward creating large, tangled documents that mix multiple ideas together. When we try to reference or build upon these mixed notes later, we find ourselves unable to extract the specific pieces we need without losing important context or breaking connections.

We have observed that:

1. People naturally think in discrete, interconnected concepts
2. Understanding complex ideas requires breaking them down into simpler parts
3. Knowledge becomes more valuable when it can be recombined in new ways
4. Context is crucial but too much detail becomes noise
5. The same idea often applies in multiple different contexts
6. Connections between ideas are as important as the ideas themselves
7. Writing that can’t be reused tends to be written again
8. The mind can only hold one clear thought at a time

Therefore:

Write each note to contain exactly one unit of knowledge — a single concept, argument, observation, or idea. Make each note:

• Small enough to be understood at a glance (typically 1–3 paragraphs)
• Self-contained enough to make sense on its own
• Clearly titled with the core concept it contains
• Connected to related notes through explicit links
• Written in your own words to demonstrate understanding
• Focused on explaining one thing well

For example:

• A single concept: “Photosynthesis converts light energy to chemical energy”
• A single argument: “Distributed practice leads to better learning than massed practice”
• A single observation: “Desire paths reveal natural user behaviors”
• A single technique: “The Feynman Technique for learning”
• A single principle: “Gall’s Law about system complexity”

The system works because it matches how our minds naturally process and connect ideas. When each note contains exactly one clear thought, we can easily find, understand, and recombine our knowledge in new ways. The atomic structure creates natural boundaries that make both writing and retrieval easier.

Most importantly, this pattern helps establish CLEAR THOUGHT BOUNDARIES while maintaining RICH CONNECTIONS between ideas. It works together with BIDIRECTIONAL LINKING (another pattern) and supports both PROGRESSIVE SUMMARIZATION (another pattern) and EVERGREEN NOTES (another pattern).

The success of this pattern has been proven across various knowledge work contexts. Systems that implement atomic notes report:

• Improved understanding of complex topics
• Easier retrieval of specific information
• Better connection-making between ideas
• Reduced duplication of content
• More flexible knowledge organization
• Enhanced ability to synthesize new insights
• Clearer thinking and writing
• Sustainable long-term growth of knowledge

This pattern has been particularly successful in:

• Personal knowledge management
• Research and academic writing
• Technical writing
• Learning and teaching
• Project documentation
• Collaborative knowledge bases

The pattern is strengthened when combined with:

• BIDIRECTIONAL LINKING
• MAP OF CONTENT
• PROGRESSIVE SUMMARIZATION
• EVERGREEN NOTES
• ZETTELKASTEN METHOD
• CONCEPT CLUSTERING
• EMERGENCE BOARD

References

• Anatomy of an Atomic Note (Zettel) by Bryan Lee, Medium
• Atomic Note Taking by Dane Walker, Medium
• Concept and Principles of Atomic Note-Taking by Gokay BURUC
• Beyond Simple Backlinks: “Relationship” Notes as First-Class Atomic-Note Citizens by Alex Skarulis

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on February 2, 2025.

🤨 What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

GARDEN MAINTENANCE

Version 1, last modified: January 30, 2025

Digital knowledge gardens grow wild and untamed. Without regular attention, they become overgrown with outdated information, broken connections, and cluttered spaces that make it increasingly difficult to find and use valuable content. Notes that were once clear become obscured by accumulated digital brush, while important pathways between ideas become blocked by the debris of abandoned thoughts and projects.

The deepest problem is that knowledge bases are living systems that require ongoing care to remain useful. Like physical gardens, they can’t simply be planted and left alone. Users often focus on adding new content while neglecting maintenance, leading to a steady decline in the system’s overall utility. Without regular tending, even the most well-designed knowledge system will gradually decay into an unusable state.

We have observed that:

1. Knowledge bases naturally accumulate digital debris over time
2. Connections between notes break as content evolves
3. Information becomes outdated but isn’t automatically marked as such
4. Users resist deletion, leading to the accumulation of obsolete content
5. Navigation paths become obscured by unused content
6. Search results get cluttered with outdated versions
7. Important information gets buried under layers of newer additions
8. System performance degrades as content grows unchecked

Therefore:

Create a systematic maintenance routine that tends to your knowledge garden through regular cycles of review, pruning, and care:

1. Daily Quick Checks
   - Review recent additions
   - Fix obvious broken links
   - Clean up temporary notes
   - Update outdated information spotted during use
2. Weekly Garden Walk
   - Review active project areas
   - Strengthen important connections
   - Clear accumulated clutter
   - Update changed information
   - Merge duplicate notes
   - Archive completed projects
3. Monthly Deep Clean
   - Systematic area review
   - Major reorganization as needed
   - Update metadata and tags
   - Strengthen weak connections
   - Identify growth patterns
   - Plan future development
4. Quarterly Maintenance
   - Full system review
   - Major pruning decisions
   - Archive inactive areas
   - Update organizational structure
   - Review and adjust maintenance practices

The system works because it matches the natural lifecycle of knowledge work. Like a well-tended garden, regular maintenance prevents problems from growing out of control while ensuring valuable content remains accessible and useful. The different review cycles ensure that maintenance stays manageable while keeping the system healthy.

Most importantly, this pattern helps establish SUSTAINABLE GROWTH while maintaining SYSTEM VITALITY. It works together with VERSION HISTORY (another pattern) and supports both KNOWLEDGE LIFECYCLE (another pattern) and ATOMIC NOTES (another pattern).

Note: While this pattern uses gardening as an extended metaphor, its principles apply to any personal knowledge management system, whether public or private. The term “digital gardening” here refers to the ongoing process of maintaining and nurturing any collection of digital knowledge — much like tending a garden requires planting, pruning, weeding, and careful attention. This pattern is relevant regardless of whether you think of your system as a “digital garden,” a “knowledge base,” a “note archive,” or any other metaphor. The key insight is that any living knowledge system requires regular, systematic maintenance to remain useful and healthy over time.

The success of this pattern has been proven across various knowledge management approaches. Systems that implement regular maintenance report:

• Improved information findability
• Clearer navigation paths
• Better connection reliability
• Reduced digital clutter
• More sustainable growth
• Enhanced system performance
• Greater long-term utility
• Increased user confidence

This pattern has been particularly successful in:

• Personal knowledge bases
• Research databases
• Digital gardens
• Team knowledge bases
• Documentation systems
• Learning repositories

The pattern is strengthened when combined with:

• KNOWLEDGE LIFECYCLE
• VERSION HISTORY
• SPACED REPETITION
• MAP OF CONTENT
• ATOMIC NOTES
• EVERGREEN NOTES

References

• On (digital) gardening, by Aaron Tushabe, Medium

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on January 31, 2025.

What’s this pattern language thing all about? Catch up on the intro and the evolving index of patterns here.

PARA METHOD

Version 1, last modified: Jan 29, 2025

Knowledge workers struggle with an ever-increasing volume of digital information spread across multiple tools, projects, and contexts. Their content becomes scattered and difficult to find when needed, leading to duplicated work and lost insights. Without a clear organizational framework matching how they work and think, digital content becomes increasingly chaotic and harder to manage over time.

The deepest problem is that traditional organizational systems either become too rigid (like strict hierarchical folders) or too loose (like pure tag-based systems). People need a system that balances structure with flexibility while matching their natural workflow from active projects to long-term archival.

We have observed that:

1. Information naturally exists in different states of actionability
2. People work primarily in projects but maintain ongoing areas of responsibility
3. Knowledge value changes over time, requiring different organizational approaches
4. Users need both quick access to active content and reliable archival of completed work
5. Too many organizational categories create decision fatigue
6. Too few categories lead to unclear boundaries and mixing of concerns
7. Organization should support both action and reference
8. Information’s relevance and actionability changes over time

Therefore:

Organize all digital information into four main categories that reflect descending levels of actionability:

1. Projects (Time-bound efforts with specific goals)
   - Active initiatives with clear completion criteria
   - Current focus areas requiring regular attention
   - Clearly defined outcomes and deadlines
2. Areas (Long-term responsibilities with standards to maintain)
   - Ongoing commitments without end dates
   - Key life/work domains requiring maintenance
   - Continuous activities with success standards
3. Resources (Topics of interest for reference)
   - Relevant topics and interests
   - Reference materials and research
   - Potentially useful future content
4. Archives (Inactive items from other categories)
   - Completed projects
   - Outdated areas
   - No-longer-relevant resources
   - Historical reference materials

The system works because it mirrors how we naturally think about and prioritize our work and knowledge. Projects capture our active focus, Areas maintain our ongoing responsibilities, Resources support our interests and learning, and Archives preserve our history without cluttering our active spaces.

Most importantly, this pattern helps establish CLEAR BOUNDARIES between different types of information while maintaining FLEXIBLE ORGANIZATION within each category. It works together with REVIEW CYCLES (another pattern) and supports both QUICK CAPTURE (another pattern) and PROGRESSIVE SUMMARIZATION (another pattern).

The success of this pattern has been proven across various knowledge management tools and contexts. Individuals and organizations that implement it report:

• Reduced time searching for information
• Clearer priority management
• Better project completion rates
• Maintained long-term responsibilities
• Easier archival decisions
• Improved information retrieval
• Reduced cognitive overhead
• More sustainable organization

This pattern has been particularly successful in:

• Personal knowledge management systems
• Team collaboration spaces
• Project management tools
• Research organizations
• Educational contexts

The pattern is strengthened when combined with:

• ATOMIC NOTES
• MAP OF CONTENT
• PROGRESSIVE SUMMARIZATION
• KNOWLEDGE GRAPH
• BIDIRECTIONAL LINKING
• VERSION HISTORY
• GARDEN MAINTENANCE
• KNOWLEDGE LIFECYCLE

References:

• The P.A.R.A. Method: A Universal System for Organizing Digital Information by Tiago Forte, Medium
• Building a Second Brain: A Proven Method to Organize Your Digital Life and Unlock Your Creative Potential by Tiago Forte, Amazon
• How to Organize Your Digital Life in Seconds (PARA Method) | Part 1 by Tiago Forte, YouTube
• Building a Second Brain: The Illustrated Notes by Maggie Appleton, maggieappleton.com

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on January 30, 2025.

Remember that article where we talked about building a pattern language for Personal Knowledge Management (PKM)? Well, it’s time to dive into our first pattern! Today we’re looking at the Johnny Decimal System — a clever approach to bringing order to digital chaos. (If you’re just joining us and wondering what this pattern language thing is all about, catch up on the intro here.)

JOHNNY DECIMAL SYSTEM

Version 2, last modified: Feb 5, 2025

People struggle to find their digital files and folders, leading to wasted time, duplicated work, and lost information. Traditional folder hierarchies become unwieldy and confusing beyond three levels deep, while completely flat organizations lose the benefits of structure entirely.

Without a clear organizational system, digital spaces become chaotic. People create folders haphazardly, name them inconsistently, and struggle to remember where they put things. This leads to:

• Lost files and wasted time searching
• Multiple copies of the same information
• Inconsistent naming conventions
• Difficulty sharing locations with others
• Mental strain trying to remember locations
• Fear of losing important information

The deepest problem is that our minds need both structure and flexibility. Pure hierarchy becomes too rigid and breaks down, while pure flatness provides no guidance. We need a system that matches how our minds work.

We have observed that:

1. People can easily remember two-digit numbers
2. Ten is a natural grouping size for categories
3. Three levels of hierarchy is a cognitive sweet spot
4. Numbers provide clear order and reference
5. The mind needs both structure and flexibility

Therefore:

Create a numerical organization system that divides all information into 10 areas (10–90), with up to 10 categories in each area (11–99), and numbers individual items within categories (11.01–99.99). Always write the numbers first, followed by descriptive names.

For example:

10-19 Administration
  11 HR Documents
    11.01 Employee Handbook
    11.02 Org Chart
20-29 Finance
  21 Invoicing
    21.01 Invoice Template
    21.02 Client List
30-39 Projects
  31 Project Alpha
    31.01 Project Charter
    31.02 Timeline

This creates a system that is:

• Limited to three levels deep
• Easy to reference verbally (“eleven dot oh one”)
• Quick to navigate visually
• Flexible within clear boundaries
• Consistent across all contexts

The system works because it mirrors how our minds naturally organize information. The two-digit area codes become familiar landmarks. The decimal notation creates clear boundaries. The numbers provide order while the descriptive names provide meaning.

Most importantly, this pattern helps establish a CONSISTENT LOCATION (another pattern) for every piece of information while maintaining FLEXIBLE BOUNDARIES (another pattern) between areas. It works together with FILE NAMING CONVENTIONS (another pattern) and supports both INDIVIDUAL ORGANIZATION (another pattern) and TEAM SHARING (another pattern).

The success of this pattern has been proven in both personal and professional contexts. Individuals and organizations that implement it report:

• Reduced time searching for information
• Clearer file locations and references
• Improved team coordination through shared numbering
• Better digital organization sustainability
• Reduced cognitive overhead in file management
• More consistent naming and structure
• Easier onboarding of new team members

This pattern has been particularly successful in:

• Personal file management
• Team documentation systems
• Project management tools
• Research organizations
• Digital asset management
• Knowledge bases
• Shared drives and workspaces

The pattern is strengthened when combined with:

• PARA METHOD
• MAP OF CONTENT
• KNOWLEDGE GRAPH
• TRAIL MARKER
• VERSION HISTORY
• GARDEN MAINTENANCE
• KNOWLEDGE LIFECYCLE

References

• johnnydecimal.com
• Johnny.Decimal — A system to organise your life, by Johnny.Decimal, YouTube
• The Johnny Decimal System: The Missing Piece In Your Quest For Obsidian Digital Zen, by Ric Raftis, Medium
• Using Johnny Decimal With Obsidian Solved My Organising Woes, by Ellane W, Medium
• The Johnny Decimal System is the best thing to ever happen to my digital ecosystem, by Victoria Kay, articles.victoriakay.co

Inspired by the Project: 4th Brain vision, Patterns for PKM is a community initiative. We don’t invent these patterns, we just help identify and collect them into a pattern language. As a valued member of our community, you’re invited to share patterns and opinions about how to improve upon those we’ve published. Want to stay in the loop?

💬 Contact me to share your thoughts and ideas

First published on Medium on January 29, 2025.

Project: 4th Brain is a work-in-progress platform and plugin for Obsidian that aims to create harmony between four types of intelligence — human cognition, digital note-taking systems, community wisdom, and AI. Currently being developed with Supabase as its backend, this open-source project focuses on multi-channel publishing, standardized PKM patterns, and AI-augmented knowledge management.

In my previous update, I provided the source code repo on GitHub. Even though the code is in a very early stage and there is nothing valuable for users yet, I made it public for transparency. I also hard-coded a little acid test to perform inserts on the documents table and I came up with some initial Sync with Server scenarios, written in the Gherkin language. My purpose today is to provide a quick status update to let interested parties know that things are progressing and to invite feedback and participation.

The Backend Database

In addition to the core documents table, two tables have been added to support the concept of sites (that is, the websites users publish Obsidian markdown documents to). The sites table is necessary to support multiple websites served atop the same Supabase instance and it will eventually allow users to own and publish to more than one website. The document_site_publications table ties the documents and sites together (many-to-many). Here’s what the schema looks like now…

There’s an init-supabase.sql script that creates everything necessary for your Supabase backend, which, at this point, now includes:

• An enum type for document states: draft, published, expired, removed
• Tables (as shown above)
• Indexes (to speed up data retrieval)
• Functions to perform operations on the data and to support transactions so that if any multi-step operation fails before it is completed, the transaction will be rolled back, and the database will not be left in an inconsistent state.
• Row Level Security policies

All items listed above will be created simply by running the init-supabase.sql script (in the Supabase SQL editor, for example).

The Obsidian Plugin

The Obsidian 4th Brain plugin’s settings page now looks like this:

These are the fields needed for a connection to the backend server and a slug for the website you publish your documents to. A slug is a short, URL-friendly string that will be part of the URL that loads your site (unless you map that part of the URL pattern to a website domain).

Current Plugin Functionality

Right-click a document and a Sync with Server option now shows in the context menu…

If the site slug you’ve written in the plugin settings identifies a site that does not yet exist in the backend, then you will first be given the option to create it, like this:

If the document you’re syncing has not yet been inserted into the database, then uuid and version properties are added to the document, and it is inserted. Each time you sync the document again, the version property is incremented, but the uuid stays the same. Previous versions remain on the server so that we can support compare and roll-back features in the future.

If you delete a document from your Obsidian vault and that document has a uuid property, its corresponding document (and all versions) are flagged as removed. I am not supporting a true delete for now, though I will implement a way to purge old versions and removed documents in the future (for database cleanup and performance).

Next Steps

Now that we can sync to the backend server from within Obsidian, I’m eager to start working on the part that renders your server data in a website. For that, I hope to add a web server container to the Docker compose file. In this way, you’ll be able to spin up the Supabase backend and the web server with a single docker compose up command.

I’m closing with some questions I’m still chewing on, in case you have an opinion to contribute on these matters:

• Should the site be generated into a static site for screaming-fast performance or should pages be queried at runtime and cached on the server?
• If an app server technology is used, what’s the ideal language for the server-side stuff? Java (e.g. Spring Boot), Node.js, Python?
• How will website keyword search be supported? Full-text search supported in the Postgres database or something like Apache Solr that might be more robust and better performing at scale?

Anyhoo…I’ll keep ya posted.

If you’re interested in following along or contributing to the vision for this platform, you can:

💬 Contact me to share your thoughts and ideas

First published on Medium on January 25, 2025.

Back in 1977, an architect named Christopher Alexander dropped a book that would blow everyone’s minds — though maybe not in the way he expected. “A Pattern Language: Towns, Buildings, Construction” wasn’t just another dry architecture text. It was Alexander looking around and basically saying, “Hey, notice how humans keep solving the same problems in similar ways? Maybe we should write that down!”

He called these recurring solutions “patterns,” and here’s the cool part: he didn’t just list them randomly. He connected them like pieces of a giant puzzle, where each piece could be part of many different pictures. This wasn’t just a collection — it was a language for talking about good design.

Now, you might be wondering what architecture has to do with managing your digital notes and knowledge. Hold that thought, because there’s a plot twist coming. See, in the late 1980s, some software engineers got their hands on Alexander’s book and had what I can only imagine was a collective “Aha!” moment. They realized that programmers were also solving the same problems over and over again. Next thing you know, the “Gang of Four” published their own pattern language for software design, and the rest is history.

Why PKM Needs Its Own Pattern Language

Let’s be honest — we’re all drowning in information. Our digital lives are a mess of notes, bookmarks, random thoughts, and that article we swear we’ll read someday. But here’s the thing: we’re all facing surprisingly similar challenges. Whether you’re a researcher, a writer, a student, or just someone trying to keep their digital life organized, certain problems keep popping up.

That’s why I started collecting PKM patterns. And let me tell you, once you start looking, you see them everywhere. Here’s what I’ve spotted so far…

Patterns for PKM: The Index

Version 5: last modified: Feb 6, 2025

Collaboration, Publishing & Access

• CONTENT SYNCHRONIZATION
• INDIVIDUAL ORGANIZATION
• TEAM SHARING

Connection & Discovery

• BIDIRECTIONAL LINKING
• CONCEPT CLUSTERING
• EMERGENCE BOARD
• KNOWLEDGE GRAPH
• TRAIL MARKER

Information Capture & Organization

• CONSISTENT LOCATION
• FILE NAMING CONVENTIONS
• FLEXIBLE ORGANIZATION
• JOHNNY DECIMAL SYSTEM
• MAP OF CONTENT
• PARA METHOD
• PROGRESSIVE SUMMARIZATION
• QUICK CAPTURE
• ZETTELKASTEN METHOD

Processing & Development

• ATOMIC NOTES
• EVERGREEN NOTES
• IDEA INCUBATOR
• LITERATURE NOTES TO PERMANENT NOTES
• QUESTION CASCADE
• SYNTHESIS MATRIX

Review & Maintenance

• GARDEN MAINTENANCE
• KNOWLEDGE LIFECYCLE
• SPACED REPETITION
• VERSION HISTORY

Structural Principles (Fundamental Organizing Principles)

• CLEAR BOUNDARIES
• DIFFERENTIATION AND INTEGRATION
• FLEXIBLE BOUNDARIES

This Is Just the Beginning

Now, I know what you’re thinking: “Great list, but what do these patterns actually look like in practice?” Well, that’s the fun part — I’ll be diving deep into each pattern in the near future. Think of this as your PKM pattern preview. It’s like when a TV show gives you those tantalizing “Coming up next season…” teasers.

Until I get those detailed pattern write-ups published (stay tuned!), you can find information about most of these patterns scattered across the internet. They’re already out there in the wild, being used and adapted by PKM enthusiasts everywhere. I’m just trying to gather them into one coherent language.

Join the Pattern Hunt!

Here’s where you come in. This list? It’s just a first pass, like a rough map of a territory we’re all exploring together. I probably missed some patterns that are obvious to you, or maybe you’ve developed your own solutions that could become patterns.

So, let’s make this interesting:

• Got a pattern I missed? Tell me about it!
• Think these patterns could be organized differently? I’m all ears.
• Found a clever way to combine some of these patterns? Share your secrets!
• Just want to tell me I’m completely wrong about something? Hey, that’s what comments are for!

Think of this as the start of a conversation about how we can all get better at managing our personal knowledge. After all, if architects can have a pattern language for buildings, and programmers can have one for software, why shouldn’t we have one for organizing our digital thoughts?

Let’s build this pattern language together — and maybe have some fun while we’re at it! Or, simply follow along and see what unfolds…

💬 Contact me to share your thoughts and ideas

First published on Medium on January 16, 2025.

Not a member? You can still access this story for free.

In my previous update, I brainstormed the Project: 4th Brain Supabase backend, one aspect of the 4th Brain platform that will provide a unique alternative to Obsidian Publish — allowing you to publish directly from Obsidian to a platform you can host yourself. Supabase is an open-source Firebase alternative that offers:

• a Postgres SQL database,
• Authentication,
• Storage,
• Edge Functions
• Realtime
• AI & Vector
• Scheduled Jobs (Cron)
• Message Queues
• and More

I’ve now started the Proof of Concept (PoC) phase, refining the technical design with hands-on coding experiments and scrupulous deliberation, one table at a time. My purpose today is to provide a quick status update to let interested parties know that things are still in progress and to invite feedback and participation.

Obsidian 4th Brain Plugin on GitHub

Though the Obsidian 4th Brain plugin has not been released, I’ve published the source code repo on GitHub for transparency.

At this early stage, the only thing worth noting in the repo is the init-supabase.sql script at the project's root. This is the script that any user can run on their own Supabase instance to set up the database. It currently creates:

• Table: documents including:
  - index
  - function and trigger for flagging the latest of all versions of a given document
  - Row Level Security (RLS) enablement
  - Policies for INSERT, SELECT, and UPDATE

You can examine that script here: init-supabase.sql

Other code in the plugin project implements a SupabaseService and utilizes the Supabase JavaScript SDK. For now, I have hard-coded a little acid test to perform inserts on the documents table.

Table: documents

The documents table is the most important since it stores the Obsidian markdown documents. Here’s a quick summary of the core concepts that have influenced the design up to this point, column by column:

• id | uuid — the id of the document, a universally unique identifier. This is generated when a markdown document is inserted into the database. When a successful insert signal is returned, the same uuid can be added to the front-matter metadata in Obsidian. In this way, the local document can thereafter be cross-referenced with a server copy.
• version | int4 — this will help us support a version history so that documents can always be restored to a previous state. This represents a revision of the original design that called for a separate document_versions table.
• path | text — the folder path
• name | text — the document name (file name, minus the extension), which can be used for the content title when a metadata title has not been provided
• content | text — the complete markdown document is stored in this field
• is_latest | bool — a convenience field helping us select the latest among all versions of a given document
• created_at | timestamptz — a timestamp, with time zone information, recording when the document was created in the database
• created_by | uuid — the id of the user who created the document

Next Steps

Here are some use cases I intend to tackle next. These use cases are written with the Gherkin syntax, which can later be converted to executable test cases using a tool like the Cypress Cucumber Preprocessor.

Feature: Sync with Supabase

GIVEN the user is working with the Obsidian client
WHEN the user right-clicks a document
THEN a ‘Sync with Supabase’ item appears in the context menu

GIVEN the Obsidian user selects ‘Sync with Supabase’
WHEN the right-clicked document has no uuid property
THEN a uuid property is added to the markdown document 
AND a version property, is added to the markdown document with value 0
AND the document is inserted into the DB
AND the is_latest field is set to true
AND the created_at field is set to reflect the moment of insert

GIVEN the Obsidian user selects ‘Sync with Supabase’
WHEN the right-clicked document has a uuid property
AND the right-clicked document has a version property 
THEN the version property value is incremented by 1 on the markdown document
AND the document is updated in the database
AND the is_latest field is set to true
AND the is_latest field of all previous versions are set to false
AND the modified_at field is changed to reflect the update timestamp

GIVEN a markdown document has been inserted into the database
WHEN the markdown document has no title property
THEN the title field contains the file name without the file extension

GIVEN a markdown document has been inserted into the database
WHEN the markdown document has a title property
THEN the title field contains the title from the markdown document’s title property

If you’re interested in following along or contributing to the vision for this platform, you can:

💬 Contact me to share your thoughts and ideas

First published on Medium on January 13, 2025.

In my previous article, I introduced Project: 4th Brain — my endeavor to create a Personal Knowledge Management platform for digital creators and knowledge workers. The system, based on the Obsidian writing app and its plugin-based extensibility, will endeavor to create harmony between four distinct types of intelligence: human cognition (your brain), digital note-taking systems (your “second brain”), community wisdom, and artificial intelligence.

Rather than viewing these as competing forces, the project aims to build an integrated ecosystem where they enhance each other.

While the vision is expansive, every journey begins with concrete steps. Today, we’ll lay the foundation by setting up our backend infrastructure using Supabase, an open-source Firebase alternative that will power our system’s data layer and API.

Supabase is built on robust open-source software; it’s stuffed with sweet features, and it’s reportedly very easy to use and highly scalable. This will be my first time using Supabase, but I’ve done enough homework to know it’s a great fit for the project.

Key Supabase Features

• PostgreSQL Database: A powerful, open-source relational database with advanced features like full-text search and vector operations
• Authentication: Built-in user management with multiple auth providers (email, social, SSO) and Row Level Security
• Auto-generated APIs: Instant RESTful and real-time APIs based on your database schema
• Real-time Subscriptions: Live data synchronization using PostgreSQL’s native pub/sub system
• Edge Functions: Serverless functions for running custom backend logic
• Storage: Large file handling with object storage and CDN capabilities
• Self-hosting Option: Can be fully self-hosted for complete data control and privacy

Supabase Development with Docker

One of the key requirements for the platform is that any user should be able to host their own backend on any cloud provider of choice, including Supabase’s own cloud, which is reasonably priced. Users should be able to get the entire backend running with as minimal configuration and customization as possible. As such, I chose to run Supabase locally for development. This should not only help me develop faster, but it will also help me prove that I can recreate the backend quickly and faithfully after tearing it down.

Note: I will provide links to reference resources and will not be repeating technical information that is already well-documented in those resources.

I set up Supabase on my Apple MacBook Pro (M3 Max) by following the guide, Self-Hosting with Docker, from the Supabase docs. Aside from a port conflict with another one of my running Docker containers, this procedure was smooth and easy. Next step: the relational database design.

Brainstorming the Database Schema Design

Key Entities

• tenant — the backend must be capable of securely isolating and managing data for multiple independent users/organizations while sharing the same infrastructure, ensuring that each tenant’s data remains completely separate and inaccessible to other tenants. A tenant is an organization or logical group of users who can collaborate and publish to the same site.
• user — an individual person identified in the system by a globally unique id.
• site — a web site uniquely identified by a domain or subdomain where resources are published and synchronized from the client authoring tool, Obsidian. A site may be synonymous with a given Obsidian vault on a user’s local machine, though it may be beneficial to allow publishing and synchronizing from one vault to multiple sites.
• role — a named set of security access that gan be applied to operations and resources; I am presently unaware of whether or not this is truly necessary as I do not yet understand how Supabase auth works (more homework is required).
• property — represents a frontmatter metadata property belonging to one or more documents and having one or more possible values. I foresee treating properties like common RDF predicates that can be reused across multiple sites and even across tenants.
• tag — a concept or term used either as a value of the tags frontmatter property or within the body of a markdown document (synonymous with Obsidian tags).
  - hierarchical tags should be supported (e.g. parent-tag/child-tag)
• document — a markdown document published from and synchronized with the Obsidian client
• document_version — represents a specific version of a document at a point in time, containing the complete state of the document, including its content and frontmatter metadata for that version
• canvas — a JSON document conforming to the JSON Canvas specification.
• folder — a unit of storage in a hierarchical storage system synonymous with the Obsidian vault’s file system, and which may translate to site areas when published on the web

Relationships Between the Entities

• Tenant Relationships
  - tenant ↔ user: One-to-Many (A tenant has multiple users)
  - tenant ↔ site: One-to-Many (A tenant can have multiple sites)
• User Relationships
  - user ↔ tenant: Many-to-One (Users belong to one tenant)
  - user ↔ site: Many-to-Many (Users can have different roles/permissions across multiple sites)
  - This requires a junction table: user_site_role
• Site Relationships
  - site ↔ tenant: Many-to-One (Sites belong to one tenant)
  - site ↔ document: One-to-Many (A site contains multiple documents
  - site ↔ canvas: One-to-Many (A site can have multiple canvases)
• Document Relationships
  - document ↔ Many: Many-to-Many (Documents can belong to many sites)
  - document ↔ Property: Many-to-Many (Documents can have multiple properties)
  - This requires a junction table: document_property
• document ↔ tag: Many-to-Many (Documents can have multiple tags)
  - This requires a junction table: document_tag
• Document Version Relationships
  - document ↔ document_version: One-to-Many (A document has multiple versions over time)
  - document_version ↔ property: Many-to-Many (Each version has its own set of properties)
  - document_evrsion ↔ tag: Many-to-Many (Each version has its own set of tags)
  - document_version ↔ site: Many-to-Many (Each version can be published to multiple sites)
• Property Relationships
  - property ↔ document: Many-to-Many (Properties can be used across multiple documents)
• Tag Relationships
  - tag ↔ document: Many-to-Many (Tags can be used across multiple documents)
  - tag ↔ tag: One-to-Many (Self-referential for hierarchical tags — parent/child relationship)
  - tag ↔ tenant: Many-to-One (Tags are scoped to a tenant)
• Folder Relationship:
  - folder ↔ site: Many-to-One (Folders belong to one site)
  - folder ↔ folder: One-to-Many (Self-referential for hierarchical folder structure — parent/child relationship)
  - folder ↔ document: One-to-Many (A folder contains multiple documents)
  - folder ↔ canvas: One-to-Many (A folder can contain multiple canvases)

Expressed in Mermaid’s ERD notation, that looks something like this:

erDiagram
    tenant ||--o{ user : "has"
    tenant ||--o{ site : "owns"
    tenant ||--o{ tag : "defines"
    
    user }o--o{ SITE : "accesses"
    user_site_role }|--|| user : "belongs_to"
    user_site_role }|--|| site : "applies_to"
    
    site ||--o{ folder : "contains"
    folder ||--o{ folder : "parent_of"
    
    folder ||--o{ document : "contains"
    folder ||--o{ canvas : "contains"
    
    document ||--o{ document_version : "has"
    
    document_version ||--o{ version_property : "has"
    version_property }|--|| property : "references"
    
    document_version ||--o{ version_tag : "has"
    version_tag }|--|| tag : "references"
    
    site }o--o{ document_version : "publishes"
    document_version_site }|--|| document_version : "links"
    document_version_site }|--|| site : "contains"
    
    tag ||--o{ tag : "parent_of"

Next Steps

Now that I have a preliminary design for the database, I will soon start exploring the database development tools available in Supabase. There is a UI for creating tables, for example, and a visual schema designer. SQL can be inputed directly into the UI, and then, of course, you can also access the Postgres database directly through the command line. While I want to explore those and other Supabase and Postgres features, I need to be sure that I all DB creation steps can always be faithfully recreated.

I expect that, while implementing this DB design, a lot of new thoughts will come to mind, so the design will surely be evolving quickly.

If you’re interested in following along or contributing to the vision for this platform, you can:

💬 Contact me to share your thoughts and ideas

First published on Medium on January 5, 2025.

The future of knowledge work isn’t about your talent versus the competition, your personal knowledge management system versus others, your intelligence versus collective intelligence, or human intelligence versus artificial intelligence — it’s about their harmony.

Like many knowledge workers, I’ve spent countless hours trying to get my digital life in order. The organization scheme in my Obsidian knowledge vault follows one pattern, and my file system follows another. I need to collect and organize knowledge for optimal use, but I also need to produce and share it. Yesterday, I managed a blog, and today, I post on Medium. Other options like Substack have caught my eye. I’m told to build a personal brand, but my interests keep expanding and evolving. There are new tools that I’m sure can help me work faster, but I don’t have the time to learn them. FOMO is my middle name; my browser bookmarks are multiplying like rabbits. And now AI is throwing both exciting possibilities and new challenges into the mix.

But here’s the thing — I’ve realized I’ve been thinking about this all wrong. I keep looking for the winning solution: the best note-taking app, the most efficient workflow, the most intelligent AI assistant. I’ve been stuck in this mindset of competition and comparison.

Then it hit me: what if the answer isn’t about finding the perfect tool or system? What if it’s about getting different types of intelligence to work together? My brain, my digital note-taking system, the collective wisdom of other knowledge workers, and yes, even AI — all working in harmony instead of competition.

That’s what “Project: 4th Brain” is about. It’s my attempt to build something I wish existed — a system where these four different types of intelligence enhance each other instead of competing. And I’m sharing every step of the journey, from the first lines of code to the inevitable face-plants along the way.

I don’t have it all figured out, but I’m excited to explore this idea in public.

Core Requirements: What This System Must Do

Seamless Obsidian Integration

• Act as an extension to Obsidian (not a replacement).
  - Leverage all the goody-goodness of Obsidian — extending it with a plugin or system of plugins.

Multi-Channel Publishing

• Provide an alternative to Obsidian Publish that empowers users to host their own with a unique features and options not currently provided by Obsidian.
• Aid content creation and publishing to common platforms that expose publishing APIs (e.g. Medium, Substack, Atlassian Confluence, etc.)
• Aid production of formats like Hardcover/Softcover, eBook, and Audiobook for publishing on Amazon KDP, ACX / Audible, etc.

Community Integration

• Provide a community-driven system for sharing and refining patterns and mental models, especially for Personal Knowledge Management (PKM).
• Promote a kind of W3C-like standards body for PKM so that standard systems can be developed and integrated to help drive tool integration and AI Augmentation.
• Enable the community to develop, share, and collectively refine PKM “formulas” that help digital creators and knowledge workers know the “Next Best Steps” for a variety of desired outcomes.

AI Augmentation

• Integration of Large Language Models and a system of Agents
• Low code customization with visual node-based workflow editor
• Specialized agents that understand PKM standards
• AI assistants that learn your personal knowledge patterns and can be permitted to act
• Agents that help maintain consistency across your knowledge base

Initial Development Focus

• Setup the self-hosted publishing platform
• Build the foundational Obsidian plugin architecture
• Establishing community standards framework
• Design the agent system architecture

The Road Ahead

This is an ambitious project, and I’m under no illusions about the challenges ahead. But I believe the time is right for this kind of integration. We have the technical capabilities with modern APIs, the growing PKM community around tools like Obsidian, and the emergence of powerful AI models. What’s missing is the bridge between all these pieces.

I’m starting this journey because I need this tool myself and because I enjoy having a side project that keeps me practiced with technology. Every line of code will be solving a real problem I face in my daily work as a knowledge worker. And by building in public, I hope to learn from others who share these challenges.

If you’re interested in following along or contributing to this vision of an Integrated Intelligence Ecosystem, you can:

💬 Contact me to share your thoughts and ideas
➡️ Read the next article in this series

Let’s see where this journey takes us.

First published on Medium on January 4, 2025.

When I was just a boy, enthralled by the special effects of Star Wars, I found a magazine that showed how movie magic was made. It was called Cinefex: The Journal of Cinematic Illusions.

I sat on the floor in the aisle of the bookstore and flipped through every beautifully illustrated page. By the time I reached the end, I knew what I wanted to be when I grew up. I was 9 years old, and I continued to read the magazine through age 50 when the publication was finally retired, a victim of the COVID-19 pandemic…

Reading Cinefex ignited a passion that shaped my approach to setting and achieving goals. Those pages, revealing the secrets behind cinema’s greatest illusions, catalyzed my early career work in the motion picture industry. Even now, holding an issue stirs profound emotions — each page brings back that childhood wonder of discovering how incredible visual effects were created, a feeling that still moves me deeply after all these years.

With deep respect for something that has brought great joy to my life, here, for the record, is the cover of every issue, from 1 to 172.

Cinefex, you were more than a magazine — you were the spark that ignited dreams. Thank you for everything.

First published on Medium on December 30, 2024.

In this article, I share my personal recipe for managing contacts in Obsidian.

Last Modified: Aug 29, 2024

If you’re wondering why one would do such a seemingly ludicrous thing as managing contacts in Obsidian (as opposed to using a purpose-built contacts app or back-office app like Microsoft Outlook), then take a look first at my previous article, Contacts in Obsidian? Heck yeah! where I described my top 6 reasons. Here they are again, in short:

Why Manage Contacts in Obsidian?

1. Query and report on people and their properties.
2. Search by specific metadata properties.
3. Classify and organize people into membership groups.
4. Link and browse people by their relationship to things and to one another.
5. Take rich notes that promote good relationship habits such as the “Follow Up.”
6. Provide a single point of access to A.I. agents for Retrieval Augmented Generation (RAG).

OK, this is a recipe, not an essay, so let’s get straight to it.

Folders

In my system, I use the concept or class “Person” to represent instances of people (each with contact information, among other things).

Wherever it fits in your own vault’s file structure, create a parent folder called Persons with the following recommended child folders for alphabetically organized entries:

📂 Persons
….📁 A — C
….📁 D — F
….📁 G — J
….📁 K — M
….📁 N — R
….📁 S — T
….📁 U — Z
📂 Templates

In my system, I title and organize Person instances by first name first (“John Doe” not “Doe, John”). This is important because when I am creating notes, I link people’s names when I mention them in my notes and I want the text of those links to read naturally as shown below.

With that in mind, my alphabetical grouping of folders aims to balance the number of entries per folder. By analyzing common first names, we can determine that certain letters, like “A”, “M”, and “S”, are more common, so they are paired with fewer letters to maintain balance. This set is purposely limited to “Miller’s Magical Number 7,” but feel free to break the groups into more detail or to adjust them to better fit your own records.

I also recommend creating a “Templates” folder somewhere, if you don’t already have one. You’ll need it for storing the Person template document, described next.

Person Template

Create a new markdown file in the Templates folder called “Template — Person”.

📂 Templates
….📄 Template — Person

Common Contact Properties

Because we’re going to be querying across our Person documents, it is important that they share a set of common properties. At a minimum, these properties should reflect the common properties you would normally find for a contact record, plus any special properties you care to add. A standard set of common properties can be found on the Schema.org type for Person.

• givenName — Given name. In the U.S., the first name of a Person.
• familyName — Family name. In the U.S., the last name of a Person.
• jobTitle — The job title of the person (for example, Financial Manager).
• email — Email address.
• email2 — Secondary email address.
• telephone — The telephone number.
• streetAddress — The street address. For example, 1600 Amphitheatre Pkwy.
• city — Center of population, town, municipality.
• stateOrProvince — Region within a country; states are found in the U.S. and provinces are found in countries like Canada and Italy.
• postalCode — The postal code. For example, 94043.
• country — The nation as a distinct part of the world.
• birthDate — Date of birth.

Note that the template is tagged with #type/Person to identify its type. This helps when browsing and searching people by tags and by Dataview plugin queries.

Note that I do not include the common “company” property. That is because I use the “tags” property and apply an Organization membership tag for this purpose. More on that later.

Note also that, for property names, I prefer the lower camel case capitalization style (with no spaces) as it conforms to the Resource Description Framework standards established by the W3C (keeping your data more compatible with future plugins and A.I. systems that may leverage Semantic Web standards).

Templater Trick: Optionally Prompt for a Title and Automatically Move the File

If you use the Templater plugin for Obsidian, you can use the following snippet. When you create a new file using the Person template, you will be prompted for the name and that name will be used for both the name of the file and the page title (heading 1). Additionally, based on the name, the file will be automatically moved into a new folder of the same name, within the appropriate alphabetical classification.

A parent folder is created for each person instance so that attachments and future files related to the person will have a logical home. This especially works well when you use the Folder notes plugin because then, when you click on a person folder, it will automatically open the folder note, which bears the same file name.

<%*
let title = tp.file.title
if ( title.startsWith("Untitled") ) {
 title = await tp.system.prompt("Person name (first last): ") 
 await tp.file.rename(title) 
}

let firstLetter = title.charAt(0).toUpperCase()
let folder = ""

if (firstLetter >= "A" && firstLetter <= "C") {
 folder = "3 Resources/Persons/A - C"
} else if (firstLetter >= "D" && firstLetter <= "F") {
 folder = "3 Resources/Persons/D - F"
} else if (firstLetter >= "G" && firstLetter <= "J") {
 folder = "3 Resources/Persons/G - J"
} else if (firstLetter >= "K" && firstLetter <= "M") {
 folder = "3 Resources/Persons/K - M"
} else if (firstLetter >= "N" && firstLetter <= "R") {
 folder = "3 Resources/Persons/N - R"
} else if (firstLetter >= "S" && firstLetter <= "T") {
 folder = "3 Resources/Persons/S - T"
} else if (firstLetter >= "U" && firstLetter <= "Z") {
 folder = "3 Resources/Persons/U - Z"
}

// Move the file to the appropriate folder
await tp.file.move(folder + "/" + title + "/" + title)
%>

# <% title %>

Note: If you use the Filename Heading Sync plugin, you should disable it temporarily when creating using the snippet above or your file will be renamed to “<% title %>,” which, of course, you probably don’t want. Once you create the template, you can re-enable the plugin.

Add Section Headers to Taste

In addition to frontmatter properties, you can add section headers to your Person template, which will act as placeholders and reminders for the kinds of notes you might keep about a given person.

My personal favorite is the heading “Follow Up,” which reminds me of things I need to discuss with a given person when we meet again. This works for me because I’ve made a habit of opening a given person’s document every time we connect. I also like “Quotes” for recording the notable, memorable, powerful, or just funny words a person has said.

Personally, that’s it for me. I otherwise like to keep my notes for a given person freeform and ad-hoc. But, in case you want some ideas, I’ve taken a look at some of the templates other Obsidian users have published and asked ChatGPT for some ideas. I’ve compiled those together with my own in the list below:

Optional Person Section Headers

• Follow Up
• Quotes
• Key Relationships
• Quick Bio
• Personal Background
• Professional Background
• Skills
• Defining Work
• Notable Achievements
• Links
• Social Media Profiles
• Education
• Hobbies and Interests
• Strengths
• Weaknesses
• Goals
• Projects
• Publications
• Awards and Honors
• Meeting Notes
• Communication Preferences

Create Query Views

Now we can use various Dataview plugin queries to aggregate our contact data into handy views. Following is one example that gives us a list of email addresses for all contacts at a glance. Refer to the Dataview plugin documentation and the Obsidian Forum to learn how to create more advanced Dataview queries.

```dataview  
TABLE WITHOUT ID  
file.link AS Person,  
email AS Email,
phone AS Phone
FROM #type/person AND -"System/Templates"  
SORT file.name asc  
```

In the query shown above, -“System/Templates” prevents the template document from showing up in the query results (assuming the template is stored in that path; change this to suit your own path accordingly).

Grouping with Tags

To organize people into groups, you can tag them. For this, I create a tag hierarchy that begins with the tag, #memberOf. For example:

#memberOf/usmc/1–3/delta/3rd-platoon/3rd-squad

Such a tag makes the person browsable by the full hierarchy of tags. If I click the “usmc” tag in the tag browser, the person will be returned. Likewise, the person will be returned by the tag #usmc/1–3, by #usmc/1–3/delta, by #usmc/delta/3rd-platoon and so forth.

Another way to group people is to create Organization pages and then just link to person instances from an Organization instance. This technique is known as a MOC (Map of Content). While it gives forward and backlinks from both the Person and the Organization pages, I find the maintenance with this approach to be a little too cumbersome.

Conclusion

In this article, I shared my personal recipe for managing contacts (Persons) in Obsidian.

The people I know are “first-class citizens” in my knowledge vault, just as they are in my life. My Obsidian Person instances (markdown documents of #type/person) not only give me quick access to contact information, but also allow me to relate and integrate primary Person entities throughout all of my notes. This turns each Person page into a “topic hub” where I can easily see all the information I’ve related to a given person over time.

I hope this recipe gives you some ideas or a solid start in creating the system that works for you!

First published on Medium on June 29, 2024.