Part 0 explained the feeling I wanted to recover: thought velocity.

This chapter is where that feeling turns into UI decisions.

I did not optimize for feature count first. I optimized for interruption cost. Every extra click, hidden mode, or ambiguous icon steals cognitive bandwidth from the idea itself.

So the UI direction was keyboard-first and friction-minimal:

• common actions reachable without mouse travel
• fast node creation and editing loops
• predictable, stable interaction patterns
• visual structure that supports scanning, not decoration

A keyboard-first interface is not nostalgia. It is a throughput strategy.

When a person is deep in a problem, they should not negotiate with the UI. The interface should be almost mechanical, so attention stays on thinking.

There is always tension here.

Modern apps reward adding controls, toggles, and contextual actions everywhere. Some are useful. Too many create noise. For this product, I repeatedly chose less surface area when that preserved speed.

The second tension is accessibility versus complexity.

Keyboard-first does not mean mouse-hostile. It means every key path should be meaningful, discoverable, and reliable. It also means visual focus states, labels, and interaction feedback must stay clear.

The frontend backbone we built on

The core model for the editor is built on the React Flow ecosystem (@xyflow/react). For this project, it was the most reliable and practical foundation I found for a mind-map-style UI.

Project link: https://reactflow.dev/

This mattered a lot because the whole frontend editor is effectively built around that graph viewport model. In simple terms, the canvas/viewport layer handles the graph rendering and interaction surface, and most of our product-specific work sits on top of it.

In practice, a big part of the app is then "buttons and keyboard actions talking to the graph canvas":

• creating and deleting nodes
• connecting and re-ordering structure
• focusing, selecting, and navigating
• applying styling and metadata actions

That may sound obvious, but this choice was a huge helper. It gave the project a stable backbone early, so I could spend energy on product behavior (keyboard speed, encryption-aware flows, vault UX) instead of rebuilding graph rendering primitives from scratch.

In practical product terms, this chapter connects directly to trust:

• fast interaction encourages regular use
• regular use creates real workflow dependence
• dependence only happens when the tool gets out of the way

That is still the bar for MindMapVault.

If a user has to think about the interface more than the idea, the product failed for that moment.

Thanks and credits

This part of the project also sits on top of a lot of other people's work.

Huge thanks to the maintainers, contributors, communities, and companies behind React, React Flow, Tauri, TypeScript, Vite, Tailwind, Zustand, the Rust ecosystem, and the many smaller libraries that made this UI direction realistic for an independent product.

React Flow deserves a specific mention here because it gave the editor a serious, practical backbone early. That let me spend time on keyboard speed, interaction clarity, and product behavior instead of rebuilding graph rendering and viewport interaction from zero.

There is a fuller acknowledgement and licensing summary here: MindMapVault credits and licenses.