Hooh Document Workspace — from understanding a document to acting on it

After Hooh shipped the reading experience, the next gap was action: people understood their documents but still retyped the same data — name, ID, address, tax number — into every new form.

Smart Fill closes that gap. Hooh recognizes form fields and fills them from documents the user has already uploaded, then lets them sign and save without leaving the app. Around it grew a full workspace — ten tools on shared rules, from markup and translate to merge and compress, one tap from the open document.

Delivery: 6 weeks, end to end
System: 10 flows, one scaffold
Handoff: Engineering-ready

Team: PM, Art Director, iOS and Web Developer
My Role: Product designer. Responsible for UX, UI, prototyping, and design decisions for Smart Fill, signature, version management, and supporting document actions
Year: 2026

Problem

Even when a document is clear, action still costs time. People retype the same personal data into every new form, search for where to sign, then convert the result to share or store — and each step that pushed them out to another app was a place where the workflow — and the reason to keep using Hooh — quietly leaked. Reading was solved by the first release; everything after it was still manual.

Task

Extend Hooh from a reading tool into a complete document workflow. Let users fill and sign any form on iOS using data already available in their previously uploaded documents — without losing control over what gets submitted.

Users

The same audience as the first Hooh release — expats, digital nomads, and people without a legal background. Most of them process a handful of new forms every month: visa applications, lease agreements, school paperwork, banking contracts.

Scope

Smart Fill mode with manual fallback, a signature flow that supports both drawing and camera capture, an explicit save and version model, and seven more tools on shared rules — markup, translate, scan to text, merge, pages, convert and compress.

Design process

Sessions with the first-release cohort surfaced a clear pattern: the data a form needed was almost always already sitting in a document the user had uploaded. Smart Fill grew out of that — instead of asking the user to retype, recognize the fields and reuse what Hooh already knows.

The constraint shaping every decision below was trust. Auto-fill is only useful if the user can see what was filled, override it, and turn it off entirely. The whole flow was designed around that veto.

1. Smart Fill — automation with a veto

Hooh recognizes form fields and fills them from the user's stored documents — and nothing is submitted silently. When Smart Fill has a match, the documents it drew from stay pinned at the top, so the user sees its sources; any value can be overridden in place; and a single toggle hands the whole form back to manual entry. It defaults to on because the time saved is the point, but the user is never more than one tap from doing it by hand. When a field has no match, the form highlights it and keeps moving — an unfinished form is a first-class state, not an error.

The More guidance sheet — the form explains exactly what a field expects before the user types — Smart Fill fills every field it can source from the user's own documents — then hands back control: tap More and any field explains exactly what it expects, unsourced fields stay flagged in place (save now, finish later), and a single tap empties the form back to manual entry.

A tapped field opens with its explanation and the exact source document pinned to the value — Control at field level — a tapped value opens with its explanation and the exact source document, enumerated fields use a picker, and the eye previews the filled document before anything is saved.

Marital status — enumerated fields pick from a native list instead of free typing — Control at field level — a tapped value opens with its explanation and the exact source document, enumerated fields use a picker, and the eye previews the filled document before anything is saved.

2. Signature — captured once, reused everywhere

One signature, made once. Draw it on the canvas or capture an existing one with the camera — either way it becomes a reusable asset, saved to a library and ready to drop into the next document.

Capturing an existing signature with the camera — Same outcome, two routes — draw it once on the canvas, or capture an existing signature with the camera. Either way it lands in the library and drops onto the next document in one tap.

The saved signature dropped onto the W-4's signature line — drag to move, pinch to resize — Same outcome, two routes — draw it once on the canvas, or capture an existing signature with the camera. Either way it lands in the library and drops onto the next document in one tap.

3. Annotations & editing — powerful, without a learning curve

Markup is usually where an editor turns into a cockpit. Hooh keeps one tool switcher and one colour system for everything — marker, text, shapes, freehand ink — so the controls never multiply. The tool appears where the user touches, its parameters live in a single sheet, and everything drawn sits as a separate layer above the original. Undo one mark or clear the whole markup: the source page never changes.

Every mark is a removable layer — undo peels them off and the original is back. One switcher and one colour system drive every tool, and any placed mark can be picked back up, tweaked, or deleted.

4. Saving — without fear of overwriting

Saving never overwrites by accident. The original file stays untouched — the user can save a new copy or branch off a brand-new document, and every version lives inside the document itself: switchable from the nav bar and renamable in place. Iterating on the same form keeps every state without cluttering the document list.

Versions are a property of the document, not separate files — switch between them, rename a copy right in the list, or branch a new document, without ever touching the original.

Other tools

Six more tools round out the workspace — all on the same rules, all reachable from the same document screen. Each is a complete scenario in brief: pick, one amber confirm, done.

Every tool is one tap away — the All-actions sheet rises over whatever document is open; nothing lives more than one level deep.

Translate & Scan to text — one pipeline reads the page: the whole document in another language, then the same result as key data, every field one tap to copy.

Merge — pick documents from the library, reorder, optionally compress; the result saves as a new version.

Pages — drag pages into a new order, straighten a sideways scan, add or duplicate pages in place.

Convert — Word, Excel, PowerPoint, text or images; the export saves as a new copy, never over the original.

Compress — three quality presets, from gentle to maximum; the result lands as a new copy.

What's next? — share, email, download, print, convert or compress, offered the moment a flow completes — And every flow ends the same way — never in a dead end: “What's next?” lines up the follow-up actions the moment the work is saved.

Outcome

Designed end-to-end in about six weeks and handed off to engineering. Every decision pulled in one direction: the app removes the repetitive work while the user keeps the final word. This scope didn't reach a public release within the engagement — it's ready to ship when the product picks the work back up.

Ten flows, one scaffold: the four deepest flow maps alone run to almost sixty screens, yet every tool shares one header, one confirm pattern and one completion screen — nothing lives more than one level deep.

Prototyped on the device: every screen ran live on iOS — the looped captures of each flow drive the engineering spec.

Handoff, complete: design system, components and all ten flows documented — buildable without another design pass.