How to Build a Database From Your Notes Using Supertags — Integrity

You already have the database. It is just scattered across a few hundred notes.

The books someone recommended, the people you keep meaning to follow up with, the bugs you jotted down mid-meeting, the features you sketched on a call — they are all already written down. What they are missing is structure. The usual advice is to stop, open a separate database tool, design a schema, and then re-type everything you wrote into rows. Most people never do it, and the notes stay as notes.

Integrity takes the opposite route. In an outliner, every line is a node in one tree, and a supertag turns a node you already wrote into a database row without moving it anywhere. The note stays exactly where it is. The database is simply another way to look at the same nodes.

This guide walks through how that works and how to build a real database out of notes you have lying around.

The one idea that makes this click

The mental model is the whole game: the same node, seen through different views.

In most tools a note and a database entry are two separate things living in two separate places. In Integrity there is one node. When you give it a supertag, that node becomes a row. Look at it in your outline and it is a line of text you can nest, fold, and drag. Look at it in a board and it is a card. Look at it in a table and it is a row with columns. Nothing was duplicated. You are just pointing a different lens at the same underlying node.

That is why building a database here does not mean leaving your notes. It means labeling the notes you already have so a structured view can gather them up.

Step 1: Have some notes

Start messy. Say you have been dropping lines into an outline as you read:

• Designing Data-Intensive Applications — Ravi keeps citing it
• The Making of a Manager — for the new leads
• Thinking in Systems — half done, want to finish

These are ordinary lines in your tree. No structure, no fields, no table. That is fine. This is the raw material.

Step 2: Turn a line into a supertag row

Pick one line and tag it. Type # and add a supertag — call it #book. The moment you do, that node stops being just a line and becomes a row in a book database. Behind the scenes the supertag defines the shape of the row; on the line itself, nothing dramatic happens — it is still your note, sitting in your outline, now wearing a tag badge.

Tag the other two lines with #book as well. You now have a three-row database, and you never opened a database tool. The rows are still nested in your reading notes where you wrote them.

Step 3: Give the supertag fields

A row with no columns is just a label. So give #book some fields — the attributes every book should carry:

• Status — a select: want to read / reading / finished
• Recommended by — text, a name
• Rating — a number

A supertag’s fields apply to every node that wears it. Tag a new line with #book and it arrives with the same empty fields ready to fill. This is how a loose habit (“I write down books”) quietly becomes a schema, without you ever designing one up front. You add the field the first time you wish you had it, and every past and future book gets the column.

Fill in what you know. Leave the rest blank — a half-filled row is still a real row, and you can complete it later.

Step 4: Switch views

Here is where the payoff shows up. The same set of #book nodes can be viewed several ways, and you switch between them without touching the data:

• Table — every book as a row, every field as a column. Best for scanning the whole list and editing fields quickly.
• Board — group by the Status field and each value becomes a column: a “want to read,” “reading,” and “finished” lane you can drag cards between. Dragging a card to another column just changes its Status field.
• Timeline — lay the rows out along a date field. Point it at a “finished on” date and you get a reading history; point it at a due date and you get a schedule.

It is one database. The board, the table, and the timeline are the same nodes wearing different clothes. Change a rating in the table and the board card shows it too, because there is only ever one node.

Step 5: Let the pattern spread

Once the idea lands, you start seeing databases everywhere in notes you already keep.

• A #person supertag over the names in your notes gives you a lightweight CRM — fields for company, last contact, and what you owe them.
• A #bug supertag over the issues you scribble during work gives you a tracker with a status board.
• A #decision supertag over the calls you make gives you a searchable log of what was decided and why.

None of this required a new document or a new tool. You tagged nodes that were already there. And because a node can carry more than one supertag, a single meeting note can be both a #meeting row and a #decision row at the same time — one node, showing up in two databases.

Let the AI build it for you

If setting up fields by hand is more ceremony than you want, hand it to the AI. Describe what you want to track, and Integrity’s assistant builds a real database as nodes — columns with proper types and the first rows, so you can see it working right away.

The crucial part: what it builds is not a static export or a snapshot. It is live nodes — the same kind of nodes you would have made yourself. You can edit them, add a field the AI missed, delete a row, or retag one, exactly as if you had built it by hand. The AI does the tedious first pass; you keep full control of the result.

Why this beats a bolted-on database

The reason to build your database this way is not that Integrity has more features. It is that the database and the notes are never separated in the first place.

When your CRM is a separate app, the context — the actual conversation, the messy thought behind the entry — lives somewhere else, and the link between them rots. Here, a #person row is the note where you first wrote that person down. You can fold the row open in your outline and read the surrounding context. You can drop that same node onto a canvas and connect it to a project. You can reference it from a meeting node months later. It keeps the thread — the structured view and the original thinking stay attached, because they are literally the same node.

That is the quiet advantage of building a database out of an outliner. You are not maintaining two parallel systems and praying they stay in sync. There is one tree, and a supertag is just the moment you decide a note is worth looking at as data.

Start with three tagged lines. Add a field the first time you miss one. Flip to a board when you want to see the shape of it. The database was always there — you are just turning on the view.

Frequently asked

Do I have to move my notes into a separate database to use supertags?

No. That is the whole point. A supertag turns a line you already wrote into a database row in place. The node stays where it is in your outline; the database is just another way to look at the same nodes. You are never copying notes into a separate table.

Can one node belong to more than one database?

Yes. A node can carry more than one supertag, so the same meeting note can be a row in your Meetings database and a row in your Decisions database at once. There is only one node; it simply shows up in every view whose supertag it wears.

What views can I see a supertag database in?

Board, table, and timeline. It is the same set of nodes each time. A table is good for scanning and editing fields, a board groups rows by a status field into columns, and a timeline lays rows out by a date field. You switch views without changing the underlying data.

Can Integrity's AI build a database for me instead of me setting one up by hand?

Yes. The AI can build an editable database as real nodes: it sets up the fields with proper types and fills in the first rows so you can see it working. It is not a static export. Everything it produces is live nodes you can edit, add fields to, retag, and view like anything else.

Keep the thread — try Integrity.