Tana: Supertags and Field-Based Knowledge Management

Tana reimagines how we capture and use information by merging the freeform nature of outliners with the structured power of databases. This approach, centered on supertags and fields, allows you to manage knowledge with unprecedented flexibility and precision. Whether you're tracking projects, researching topics, or managing daily notes, Tana transforms your outline into a dynamic, queryable system that grows more valuable as you use it.

From Chaotic Notes to Structured Information

Traditional note-taking tools force a trade-off. You can have flexible, unstructured documents that are easy to write but hard to analyze, or rigid databases that are powerful but cumbersome to populate. Tana eliminates this compromise. At its core, Tana is an outliner—a nested, bullet-point list where you can capture thoughts as quickly as they come. However, when you apply a supertag to any node (a bullet point), you attach a predefined template of structured fields to it.

Think of a supertag as a digital stamp that instantly gives an item a consistent set of attributes. For example, tagging a node as #meeting could automatically add fields for date, attendees, agenda, and action items. The node remains a part of your fluid outline, but it now carries structured, machine-readable data. This turns your entire workspace into a flexible database where every piece of information can be both a freeform note and a structured data point.

The Anatomy of a Supertag: Fields, Types, and Inheritance

A supertag is more than just a label; it's a blueprint for consistency. When you create a supertag like #book, you define what information is important to capture about every book you log. You might add fields for author, readDate, rating, and summary. Each field can have a type, such as text, number, date, or even a reference to another node (like linking the author field to a separate #person node).

A powerful feature is inheritance. You can create supertags that build upon others. For instance, you could have a base #project supertag with fields for owner and deadline. Then, a more specific #clientProject supertag could inherit all fields from #project and add its own, like clientName and budget. This creates a hierarchical taxonomy for your knowledge, reducing redundancy and ensuring consistency across similar items. The system allows you to model complex relationships—like which #actionItem from a #meeting is assigned to which #person—directly within your outline.

Querying Your Knowledge Graph: Live Searches and Views

The real power of adding structure with supertags is the ability to interrogate your data. Tana's search function goes beyond simple text matching. You can construct live searches that act as saved queries, continuously updating as you add new information. A query like "show all #meeting nodes where date is this week" instantly generates a filtered view. You can sort these results by any field, such as sorting #book nodes by rating.

These live searches can be saved as views and placed anywhere in your outline. This means you can have a dedicated "Weekly Review" note that contains a live table of this week's meetings, a list of pending action items, and a chart of time spent on different projects—all pulling data dynamically from nodes scattered across your workspace. The outline (your input interface) and the views (your output dashboards) exist in the same space, seamlessly connected. This bridges the critical gap between capturing information and gaining insights from it, enabling sophisticated queries and views without ever leaving the intuitive outlining environment.

Automating Workflows with Commands and Formulas

To further reduce cognitive overhead, Tana introduces commands and calculated fields. Commands are shortcuts that automate complex actions. For example, a "Log Meeting" command could create a new node, apply the #meeting supertag, prompt you for the attendees and date, and even generate a template for minutes—all from a single keystroke.

Calculated fields use formulas to auto-populate data based on other fields. In a #project node, a daysUntilDeadline field could automatically calculate the time remaining by comparing the deadline field to today's date. In a #invoice supertag, a total field could multiply hours by rate. This automation ensures data integrity and surfaces important information proactively, moving your system from a passive repository to an active assistant. It embodies field-based knowledge management, where the structure you define works continuously in the background to organize and analyze your information.

Common Pitfalls

1. Over-Structuring from the Start: A common mistake is trying to design the "perfect" set of supertags and fields before you begin. This leads to friction and abandonment. Start simple. Tag nodes with basic supertags and add fields only when you notice you're consistently typing the same kind of information (e.g., always writing a "publisher" after a book title). Let your structure evolve organically with your use.
2. Creating Redundant or Overlapping Supertags: Without a plan, you might end up with #book, #readBook, and #readingList for essentially the same thing. This fragments your data and makes queries ineffective. Regularly review your supertag catalog. Use inheritance to create specialized versions (#book -> #audiobook) rather than entirely separate tags, and merge duplicates.
3. Neglecting the Power of References: Using plain text in a field like attendees instead of referencing #person nodes is a missed opportunity. By creating links, you build a true knowledge graph. Clicking on a person's name then shows you every meeting and project they're connected to. Always use reference fields to connect nodes, transforming your notes from isolated pages into an interconnected web.
4. Confusing Nodes with Fields: It can be tempting to make everything a field. Ask yourself: "Will I ever want this item to stand alone or be the subject of a search?" If yes, it should be its own node with a supertag. For example, a Project should be a node, while its deadline is a field on that node. A Contact should be a node, while their email address is a field.

Summary

• Supertags are structured templates applied to any node, attaching consistent fields that turn freeform notes into organized data without sacrificing the ease of an outliner.
• This approach bridges the gap between outliners and databases, providing the flexibility of the former with the querying power and consistency of the latter.
• Fields and inheritance allow you to model complex information relationships, creating a hierarchical and non-redundant taxonomy for your knowledge.
• Live searches and views let you dynamically filter, sort, and display information from across your workspace, creating custom dashboards that update in real time.
• The system's true potential is unlocked by using commands for automation and reference fields to build connections, evolving your notes into a proactive, interconnected knowledge graph.