The Configured Content Pattern (Notion)
An intuitive principle for advanced data modeling design in Notion
Epistemic Status: Medium-high confidence in the application of content-based patterns to productivity systems, based on my experience studying AI, cloud storage, and semantic search systems
Epistemic Effort: Medium, translated design patterns from other domains of systems, implemented devised pattern in Notion, evaluated its effectiveness
Arguably the greatest learning hurdle to constructing Notion systems is database design. One wonders…
Do I have too many properties?
Should I split this table into multiple tables? Or should I combine multiple tables into one?
How do I make use of rollups?
What property icons should I use?
Sure, you may know Notion syntax. You may know what relations do and what rollups are, but this is just one player in the skillset of building productivity systems. The next level of system proficiency is systems thinking and design, which means we need to identify some design principles for building an interlinked set of tables that efficiently serves its purpose.
In this post, I’ll introduce a Notion design pattern, inspired by computer science and AI, which I’ve used to help me with designing my Notion databases. I call it the configured content pattern.
What is a Notion Design Pattern?
Let me first clarify what I mean by a Notion design pattern.
In the context of Notion, a Notion design pattern refers to a reusable solution to common design problems encountered when structuring components within the Notion ecosystem. One can think of it as a best practice or principle for creating better Notion systems.
In this blog post, I’ll unravel the configured content pattern, a Notion data modeling pattern. I'll explain how this pattern works, when to use it, and provide an implementation example (with a little Notion AI in the mix 🙂).
The Configured Content Pattern
The configured content pattern (CCP) is a data modeling design pattern that enables configurable information to be passed between databases. It involves defining properties as key, value, query, or parameter, and these properties serve specific purposes to ensure efficient information transfer.
At its core, CCP relies on a property typology that I adapted from AI systems for Notion:
Key: The name of the row (page title). The role of the key is to help you quickly find the page you are searching for. There is only one property of type “key” per table.
Value: The content that is passed to related databases (via a roll-up). Any property of type value should be automated, either through Notion AI or a formula. Notion AI enables more creative or complex values (like summarizations), while formulas are rigid but consistent.
Query: The connection to another database (via relation). This property is used to query the entities in a related table by their key.
Parameters: Configures the content in properties of type “value”. This is where the “configured” in CCP comes from. The value of each Notion page can be modified by adjusting the parameter properties.
The pattern for pulling information from database B into database A is as follows: first, establish a query to database B and search for the relevant information via the key (add relevant pages). Then, pull the value from that entry (create a rollup on the desired value property). In database A, you can configure the value of each row by modifying its parameters, which automatically updates the queried values in linked databases.
Step By Step
To use the configured content pattern, follow these steps:
Choose a set of icons to classify a property as one of {key, query, value, parameter}.
Identify two or more tables that have relations and rollups (or create them).
Classify the relevant properties of your tables as key, value, query, and parameter (by changing their icons). (Note: not all properties follow this typology. Some properties are simply descriptors and have nothing to do with passing information between related tables.)
Establish a query to the database you want to share information with (create a relation).
Pull one or more values from the queried pages (create a rollup for each value).
Configure the value of each row in the source database by modifying its parameter properties.
Inspiration
I mentioned before that I devised CCP to mimic design patterns I have learned in other domains of systems, specifically AI, search engines, and databases (not Notion, I’m talking some SQL shit).
In fact, the OpenAI earthquake that triggered tsunamis in productivity land (a reference to ChatGPT for those who have been in hibernation) is based on a mechanism called content-based attention, which also uses the ideas of keys, queries, and values to help the algorithm search for relevant context when generating text.
Hopefully, the success of content-based design patterns in major technologies like cloud databases, large language models, and search engines is reason enough to incorporate those ideas into your productivity systems. I have done so, and CCP is one such pattern, and they have been tremendously helpful. I continue to work on new content-based design patterns, especially in the PKM realm.
The Configured Content Pattern in Action
I recently released a Notion system called AutoPlanner that implements the configured content pattern. The system uses information about your tasks, the time you want to allocate to each task, events, and routines to generate a customized schedule for the day (using Notion AI).
Once the idea occurred to me, designing this system literally took me like 10-20 minutes using the CCP principle as my guide. The final outcome was a pretty cool system that satisfied the important qualities of any productivity system:
Simplicity. There are three tables, one with 6 properties and two with 4 properties.
Intuitive. The relational structure makes sense. You have tasks, parameterized by how much time you want to allocate to the task, and events, parameterized by the start and end times. The daily plan table assembles this information, nicely formatted, and Notion AI pulls it to generate a custom schedule.
Maintainable. The formulas are super simple, and the Notion AI script can be easily tweaked. Also, simple systems that are intuitive are easy to maintain.
Some Caveats
Design patterns are not there to tell you how to build every system. They are there to help you build systems in specific, but common, situations.
The configured content pattern is useful when you want to design a set of tables (e.g. define their properties and relations) that pass configurable information between each other, meaning the information is configurable by other properties (parameters) in the source database.
Let’s take AutoPlanner as an example. I want to generate a daily schedule based on constraints. What are those constraints? Well, there are specific tasks I want to do, and there are events taking place. I want to spend a certain amount of time on each task, thus that modifies the task-level information passed to the daily plan table. And each event happens at a specific time, thus that changes the event-level information passed to the daily plan table. In summary, tasks and events are configurable information, and the daily plan assembles that information for Notion AI to do its thing. That’s a perfect case for the configured content pattern.
It’s also important to emphasize the CCP property typology (key, value, parameter, query) is not exhaustive. Those are simply the relevant types for implementing this specific pattern, but there are plenty of other property types. The purpose of the value is to be accessed by other databases. If a property does not modify a value, and it is not the page title (key), then it is not a parameter.
CCP as an “Enabler” of Other Design Patterns
CCP also enables other design patterns. A good example is the observer pattern (from software design). The observer pattern allows for an efficient update process of multiple dependent objects when a related object changes its state. So when a queried row has its state changed (parameters changed), the values automatically update, and thus the queried content in the sink databases automatically reflects the changed state.
So in AutoPlanner, if I already generated a schedule but let’s say the “state” of my day has changed, the observer pattern lets me easily modify the parameters of my objects (tasks and events) and update the sink database (daily plan). All I have to do then is rerun the Notion AI script.
Conclusion
The configured content pattern is a powerful Notion design pattern for efficient data modeling. By defining properties as key, value, query, and parameter, you can enable configurable information to be passed between databases. It provides an intuitive guideline for more advanced data modeling design in Notion.
If you're struggling to organize your information in Notion tables, give the configured content pattern a try. And for more insights on how to use Notion effectively, be sure to subscribe to my newsletter for more Notion design patterns in the future!