Slots, not a blank page

Claim: sensitive assets need schemas

While a vault is unlocked, you do not want a blank page. You want a place that already knows what a credential looks like, what a bank item should hold, and where a document’s issuer and expiry belong. You want slots—typed fields with labels, masking, copy moments, and attachments that stay tied to the record they explain.

NT² Vault is built for structured digital assets. The product claim for this series is architectural, not cosmetic: sensitive life data deserves document collections with schemas, not a freeform canvas and not a single password-manager-shaped row stretched across every domain.

That claim is easy to say and easy to abandon. A notes app is always one textarea away. A spreadsheet is always one more column away. A “secure note” that can hold anything feels flexible until every domain collapses into the same undifferentiated blob—and every feature (search, share, expiry, health) has to guess which lines matter.

This essay is the hub for how NT² refuses that collapse. Later posts in the series deepen the type system, pack composition, sealed wire shape, and the four product surfaces that share one field set. Here we fix the document model in plain language.

The constraint: blank pages flatten domains

Freeform tools win on speed. Open, type, search later. For grocery lists and travel ideas, that is enough. High-sensitivity records are different.

A passport is not a login. It has issuer, number, dates, and often front and back scans. Copying “the whole note” is the wrong default when an officer asks for a number.

A bank account is not a password. Routing, IBAN, institution name, and account number have different disclosure habits. Presenting proof of address should not dump every digit you ever stored.

An API key is not a family memo. Rotation notes, environment labels, and masked secrets behave like credentials—but they are not autofill for a shopping site.

A seed phrase is not a paragraph. It needs a place that understands recovery material without training users to paste twelve words into chat.

When those records share one blank surface, structure becomes personal discipline. Remember which line is current. Remember not to paste too much. Remember where the scan lives. The tool does not help you keep the shape; it only stores the text.

Password managers solve a narrower problem extremely well: logins. Stretch that schema to insurance policies, medical cards, SSH keys, and tax documents, and you either invent custom fields without shared meaning, or you shove everything into notes again. The blank page returns through the side door.

NT²’s constraint is therefore product-shaped: if the vault is going to hold many domains, the model must admit that domains differ—without inventing a new app for each vertical.

The design: collection, schema, row, column type

NT² uses a small set of document-model words. They are not marketing metaphors; they are how the vault thinks.

flowchart TB
  Cat[Category — collection]
  Tpl[Category template — schema]
  Item[Asset item — row]
  FT[Field type — semantic column]
  Cat --> Tpl
  Tpl --> Item
  FT --> Tpl
  Item --> Values[Field values on the row]

A category answers “what kind of collection is this?” Titles and category labels are list metadata—useful for filters and search—while sensitive values live in the item payload.

A template answers “what fields does a new item in this collection start with?” Credential starts with username, password, URL. Document starts with document type, number, issuer, dates, and typed photo slots. Bank starts with institution and account-shaped fields. The template is a schema, not a frozen protocol constant: releases may refine placements, and users may enable optional packs when they need a domain.

An item is one row. Creating a bank account does not create a mini-database; it creates one structured record under the bank template.

A field type is the reusable meaning of a column. Expiry date means the same thing on a passport document and on a TLS certificate item. Password means a secret with masking and health-scan habits wherever it appears. The next essay in this series is about that registry. The hub claim is simpler: columns are semantic, not one-off form widgets invented per screen.

Two more product facts keep the model honest:

• Core builtins stay small. Credential and secure note are always available. Specialized domains ship as optional packs you enable when you need them— bank, document, crypto, IT, medical, and others—so a new vault is not a museum of every vertical on day one.
• Features follow fields. Expiry reminders, password health, and share masks should key off the active field set on a row—not off a hard-coded if (category === "bank") forever. Composition is how domains scale; slug gates are how they ossify.

The trade-off: compose instead of inventing screens

Schema discipline costs something. Authors of templates compose from a shared catalog instead of inventing arbitrary keys for every UI. Users choose a category instead of starting from an empty page. Optional packs are an explicit enable step.

What you gain is leverage across domains:

• The same expiry field can drive reminders on documents and certificates.
• The same secret field can stay masked in edit, view, and present flows.
• Search and list previews can project only fields marked safe to index.
• Share and selective presentation can reason about fields, not whole opaque notes.
• Backup and sync can carry sealed payloads without the edge interpreting your life.

That is the opposite of “be everything to everyone as freeform text.” It is closer to a disciplined database of personal assets—still local-first, still zero-knowledge—where structure is a security and usability feature.

What we refuse

We refuse a Notion-style blank canvas as the vault model. Rich freeform pages are excellent for thinking. They are a poor default home for high-value secrets that need masking, typed attachments, and controlled disclosure.

We refuse one mega Note for every domain. A secure note exists for text that does not fit a template. It is not the escape hatch that collapses bank, passport, and API inventory back into paragraphs.

We refuse pretending a login schema is a universal life schema. Credentials matter. They are not insurance policies, patient records, or SSH keys.

We refuse structure-as-optional-decoration. If fields are only labels on a blob of JSON with no shared meaning, you have reinvented the blank page with extra steps.

Structure is the product surface

Stories on this blog often start with a recognizable mistake: the household spreadsheet, the notes app that outgrew groceries, the local database that never learned what a bank field is. Those pieces argue for structured relief in human terms—The spreadsheet on my Desktop, I outgrew Apple Notes, Already local-first, missing structure.

This series argues the engineering claim underneath: slots beat blank pages because domains share a type system. Next: Semantic columns, not form widgets—why field meaning lives in a global registry. Then composition across packs, how searchable metadata stays outside sealed values, and how edit, view, present, and features share one field set.

For how those fields leave RAM as portable ciphertext, the companion essay is CBF is how structured fields leave RAM. For the product pillars in shorter form, see nt2.me/about.

If you want a vault that starts from schemas instead of a blank page, try NT² Vault.