Inktrail

Five tools, five logins, five mental models

I mapped the actual working day of the people I interviewed. Docs in Notion, designs in Canva, meetings in Otter, whiteboards in Miro, publishing through WordPress. Every handoff between them was a manual copy, and every copy was a chance for the work to drift out of sync.

The three profiles I built — a solo consultant, a small agency team, an in-house content lead — paid three completely different bills for the same fragmentation. The consultant paid in subscriptions. The agency paid in version confusion. The in-house lead paid in review cycles.

One working day, five tools

The actual working day mapped across five tools. Every handoff between them is a manual copy, and every copy is a chance for the work to drift out of sync.

Tap to inspect the full-resolution artifact

Three profiles, three different bills

A solo consultant, a small agency team and an in-house content lead — three profiles paying three different bills for the same fragmentation.

Tap to inspect the full-resolution artifact

What people named first

What people named first. None of them led with the subscription cost; all three led with the switching.

Tap to inspect the full-resolution artifact

None of them named the subscription cost first. All three named the switching.

Four principles, set before any screen

Before touching a layout I wrote down four rules that then governed every decision. Having them in writing is what let me kill my own IA later without relitigating the strategy.

• AI outputs are real files

  When AI generates a document, it is a real document, not a chat message. When it generates a design, it is editable vector elements on canvas. No copy-paste intermediary.

• One surface, multiple modes

  Docs, canvas, audio and published pages all live in the same project space. Switching between them is a mode change, not an app change.

• Progressive complexity

  A new user should be productive in 30 seconds. Power features reveal themselves through use, not through onboarding wizards.

• Publish is a button, not a process

  Any document becomes a live webpage with one click. No CMS. No deploy pipeline. No waiting.

The architecture I built, then killed

My first information architecture treated docs, canvas and audio as separate apps with a sidebar switcher. Tabs, essentially.

It tested badly for a reason I had not predicted. Users switched to canvas mode and asked "where did my document go?" A shared login does not create a shared mental model. It just moves the tab bar inside the app.

So I killed it and rebuilt around the project: everything lives inside a project, and you create artifacts within it. The mental model shifted from "which app am I in?" to "which project am I working on?"

The architecture I killed

The first architecture, with tools as destinations. It tested at 40% task completion, which is why it did not ship.

Tap to inspect the full-resolution artifact

40% to 100% task completion

Two rounds of usability testing with eight participants. The first round ran on the killed tab-based IA, the second on the project-centric architecture that shipped.

Task completion went from 40% to 100%. Average task time dropped from 30.6 seconds to 7.6 seconds. Context-loss incidents went from 62% to zero.

40% to 100%, same task script

The same task script run against both architectures. Completion went from 40% on the version I killed to 100% on the one that shipped.

Tap to inspect the full-resolution artifact

That last number is the one that mattered. The project-centric model did not make the product faster to learn. It removed the "where am I?" anxiety entirely.

The project became the container

The shipped architecture centres everything on the project. Sidebar navigation gives access to projects, search, templates and shared content. Inside each project, users create documents, canvases, recordings and published pages as artifacts rather than as separate apps. The AI layer runs across all surfaces, with a model chooser, inline commands and context pulled from connected apps.

I mapped four primary paths through it: AI document creation, canvas diagramming, template quick-start, and meeting-to-document conversion. Each is completable in under 60 seconds with minimal navigation.

The project as container

The shipped architecture: the project is the container, and documents, canvas and transcripts live inside it rather than beside it.

Tap to inspect the full-resolution artifact

No task leaves its surface

Flows through a project, showing that no task requires leaving the surface it started on.

Tap to inspect the full-resolution artifact

AI that writes into the file, not into a chat window

The category convention was a chat panel beside the document. I refused it. Chat output has to be read, judged and copied somewhere before it becomes work, and that copy step is the same context break we were trying to remove.

So generation writes directly into the document, the canvas or the deck as real editable content. The home screen answers exactly one question — what do you want to make — with templates rather than a dashboard. Model choice sits per generation rather than in settings, because the right model for a PRD is not the right model for a social post, and connectors pull context from the tools people already have instead of asking them to re-upload it.

One question on the home screen

The home screen asks exactly one question — what do you want to make — and answers it with templates rather than a dashboard.

Generated work stays filed

Inside a project: everything generated stays in the container it belongs to, so nothing has to be filed afterwards.

AI writes into the document

Generation writes directly into the document as real editable content. The category convention was a chat panel beside the doc, and that copy-out step is the same context break we were trying to remove.

Model choice per generation

Model choice sits per generation rather than in settings, because the right model for a PRD is not the right model for a social post.

Context from tools already in use

Connectors pull context from the tools people already have, instead of asking them to re-upload what they have already written.

Intrusive would have been AI that interrupts. Native is AI that produces the artifact you were already going to make.

The canvas, and why editable output was the breakthrough

The canvas handles diagrams, flowcharts, wireframes, mind maps and data visualisation on an infinite zoomable surface.

AI generates charts and diagrams from natural language, and the outputs are fully editable vector elements rather than flat images. I designed the interaction model; engineering built the rendering engine.

This is the thing that separated Inktrail from design tools where AI output arrives as a picture you cannot change. An image you have to regenerate to edit is not a deliverable, it is a suggestion.

Editable output, not a picture of one

The canvas. AI output arrives as editable objects rather than as a picture of a diagram — the difference between generation being useful and being decorative.

A design system built in parallel, not after

Every component had to work across all four surfaces, so the system grew alongside the product rather than being retrofitted onto it.

Geist for the interface, Playfair Display for published content. Dark mode from day one because the canvas surface demanded it. Every component carried three states: resting, AI-active with a subtle pulse, and collaborative with live cursors.

Built in parallel, not after

The design system built alongside the product rather than documented after it, which is the only reason a four-month 0→1 held together visually.

Every component, across four surfaces

The system had to hold docs, canvas, transcripts and published pages at once, so a component was only finished when it worked on all four. That constraint is what kept a four-month 0→1 from becoming four products that shared a logo.

Inktrail · component contract · every element had to satisfy all of it

Pricing designed against the crippled free tier

The free tier is genuinely useful: unlimited docs and canvas, 300 AI credits a month, no artificial walls. The upgrade trigger is volume, meaning more credits, more transcription hours, more collaborators. It is never a locked feature.

That was a deliberate choice against the pattern of making the free tier bad enough to force conversion, which buys revenue by spending trust.

A free tier that is actually usable

Pricing set against the category habit of a crippled free tier: the free plan has to be genuinely usable, or the product never gets evaluated at all.

Reflection

In a multi-surface product, consistency of interaction patterns matters more than consistency of visual style. A canvas and a document look fundamentally different, but if selection, AI invocation and collaboration feel the same, users never feel lost. That was not obvious to me at the start; I assumed visual coherence was the unifying force.

The decision I would defend hardest is killing my own tab-based architecture after building it. It cost time in a four-month schedule, and the testing numbers say it was the highest-leverage change in the project.

What I would do differently: invest earlier in cross-surface linking. Embedding a canvas element inside a document was deprioritised for launch, and it is the feature that would make the "one surface" promise feel complete rather than merely true.