What Is a Supertag? Turning Notes Into Databases — Integrity

Most note-taking tools make you choose early. Either you write freely — bullet points, half-thoughts, a running log — or you commit to structure: a table, a project tracker, a database with named columns. Freeform is fast but goes stale. Structured is durable but expensive to set up, and it punishes you for not knowing the shape of your data before you have any.

A supertag dissolves that choice. It lets you write freely first and impose structure later, on the exact same material, without moving anything.

The one idea behind it

In Integrity, everything is a node in one tree. A line of text is a node. A heading is a node. A task, a canvas card, a whole document, a recorded meeting — all nodes. They nest, drag, and fold inside a single outline. That uniformity is what makes supertags possible.

A supertag is a tag you attach to a node — but attaching it does something a normal tag never does. The node becomes a row in a database defined by that tag. The tag carries a set of fields. Every node wearing that tag gains those fields and lines up alongside the others as a record.

Nothing leaves your outline. The node is still sitting where you wrote it, still part of the thread of whatever you were thinking about. The supertag is a second way of seeing the same node — as one row among many, next to everything else that shares the tag.

That’s the whole trick: a database that is not a separate place, just a different view of nodes you already have.

From a line to a row

Say you’re in a running document and you jot:

Call the vendor back about the contract terms

Right now it’s a line in your outline. Add the supertag #task and three things happen at once. The line becomes a task node. It joins the #task database — every other node you’ve tagged #task is now its peer. And it inherits that tag’s fields: maybe a status, an assignee, a due date. You fill those in, or you don’t. The line still reads the same in context.

Do this a few dozen times across different documents and meetings, and you haven’t built a task tracker on purpose — you’ve accumulated one. The database is the sum of every place you tagged as you worked, gathered under one tag.

This is the inversion that matters. In a conventional database tool you create the table, then feed it rows. With supertags you create the rows first — as ordinary notes, wherever your attention happens to be — and the table assembles itself out of them.

The same node, through different views

Once nodes share a supertag, you can look at that collection however the moment calls for. The set of #task nodes is one thing; the way you render it is a choice you make and change freely.

Crucially, these are not exports or copies. They are the same nodes, drawn differently. Move a card from “Doing” to “Done” on the board and the table updates, because there’s only one node underneath — you changed its status, and every view of it reflects that instantly. There is no sync step because there is nothing to sync. One node, many lenses.

That single-source property is the quiet payoff. In most setups, the note and the database entry are two artifacts that drift apart: you update one and forget the other. Here they can’t drift, because they are the same object.

You don’t lose the thread

Integrity’s tagline is keep the thread, and supertags are where that shows. A row in a normal database is stranded — it knows its own fields and nothing else. A supertagged node still lives in the outline where you created it, so it keeps its surroundings: the paragraph above it, the meeting it came out of, the section it belongs to.

A recorded meeting is a node. During the call, Integrity captures the transcript and folds your sparse notes into a clean write-up — and the meeting stays a node you can reference later. Tag a decision that came out of that meeting with #decision, and it becomes a row in your decisions database while still pointing back to the meeting it was made in. You can always walk from the tidy database row back to the messy, human context that produced it. The structure never severs the story.

Multiple tags, multiple databases

A node is one thing, but it can belong to several databases at once. That vendor callback might be both a #task and a #follow-up. A meeting note might be a #meeting and hold a #decision inside it. Each tag pulls the node into its own collection, its own set of views, without duplicating anything.

So your workspace isn’t one rigid schema. It’s a loose weave of overlapping databases, each one just a tag, all of them made of the same nodes you were already writing.

Let the AI build the database

You don’t have to structure everything by hand. Integrity’s AI reads your entire workspace, and it builds editable artifacts as real nodes — plans, decks, and databases among them.

Point it at a pile of loose notes and ask it to organize them, and it can build a database out of them — one with fields and views you can immediately switch to a board or table. Because the result is made of ordinary nodes, you edit it like anything else — rename a field, change a value, drag a card. The AI gives you a running start; it doesn’t lock you into its version.

Where this leaves you

The reason supertags feel different from tags-plus-a-database bolted together is that there was never a seam to begin with. In an outliner where everything is a node, a database isn’t a separate feature — it’s what you get when you tag nodes and choose how to view them.

That means you can start anywhere. Write the note now, when the thought is fresh and unstructured. Tag it when you notice a pattern. Add fields when you know what you want to track. Switch to a board when you need to see status, a timeline when you need to see time. At no point do you rebuild, re-import, or copy. The note is the row. The tag is the database. The outline holds it all.

Start with a single tag on a single line and watch the table fill itself in. To see it in your own workspace, visit integrity.sh.

Frequently asked

Is a supertag just a folder or a label?

No. A label groups things; a supertag makes them queryable. When you tag a node, it becomes a row in a database defined by that tag, with fields you can fill in and views you can switch between. The node stays in your outline — the supertag is a second lens onto it, not a place you moved it to.

Do I have to decide on my fields up front?

No. You can tag a node first and add fields later, or add a field to the supertag and every tagged node gains that column at once. Because the node lives in your outline the whole time, there's no schema migration and no re-importing — you shape the database as your thinking sharpens.

Can the same node have more than one supertag?

Yes. A node is a single thing, but it can belong to several databases at once. A meeting node might carry a #meeting tag and a #decision tag, so it shows up as a row in both — the same underlying node, seen through two different tables or boards.

Can Integrity's AI build a database for me?

Yes. Integrity's AI reads your whole workspace and builds editable artifacts as real nodes — including databases. You can ask it to turn a set of loose notes into a database with fields and views, then edit the result by hand like anything else in your outline.

Keep the thread — try Integrity.