Tana

Promptfree, for everyone, and the only version there is

Copy the prompt for Claude CodeCopy the prompt for CodexCopy the prompt for Cursor

Copy

Build me the typed outliner that replaces Tana.

The idea is genuinely novel and worth understanding before you build: **you write freely, then apply a type to a line, and it becomes a record with fields — without moving it out of the outline.** Structure emerges from writing rather than being designed in advance.

STACK
- Node 20+ with Fastify, server-rendered HTML with a good deal of vanilla JS
- SQLite through better-sqlite3, WAL mode, FTS5 across nodes
- Caddy in front

THE DATA MODEL, WHICH IS THE WHOLE THING
- nodes: id, parent_id, position, body_md, created_at, updated_at — **everything is a node, including what other systems call a document, a tag or a field value**
- types: id, name, fields_json — the field definitions for a type
- node_types: node_id, type_id, applied_at — a node can have several
- fields: node_id, type_id, field_key, value_node_id, value_text — **a field value is usually another node, which is what makes the graph work**
- queries: id, name, definition_json — a saved query is itself a node

APPLYING A TYPE
- Type a symbol, pick a type, and the node gains that type's fields inline underneath it
- **Existing nodes can be typed retroactively without moving them.** That is the feature; a system that requires choosing a template first is a database with extra steps
- Adding a field to a type shows it on every node of that type immediately, empty, without a migration

QUERIES
- A query is a node that renders as a list: all nodes of this type where this field matches, sorted
- Rendered inline wherever it sits, live
- **A query result must be editable in place.** Editing a task in a list and having it update where it actually lives is what makes this feel like one system rather than two
- Cap results and paginate; an outline with a hundred thousand nodes will find every unbounded query

THE OUTLINER ITSELF
- Keyboard: indent, outdent, move up and down, collapse, zoom into a node. These must be instant and they must never lose the cursor
- Zoom is important: any node can be the root of the view, which is how a large outline stays navigable
- Undo across structural operations, which is harder than it sounds and unforgivable to get wrong

PERFORMANCE, WHICH IS WHERE THIS BREAKS
- **Render only the visible window.** An outline of tens of thousands of nodes cannot be in the DOM
- Position as a sparse ordering so a move is one write, not a renumber
- Index parent_id and position; every read is a tree walk

SAFETY
- Export the whole outline as nested markdown and as JSON, and mean it. **A structure this specific is a lock-in risk, and the export is what makes it not one**
- Every change into an append-only log, so an accidental collapse-and-delete is recoverable

WHAT MATTERS MOST
Types applied retroactively, editable query results, and windowed rendering. The first two are the idea; the third is whether it is usable after a year.