Ask Luma

3S builds software for shipping companies. Tide Trace was one of its products, and it had accumulated features faster than structure: each addition went wherever it fit, and after enough releases nothing had an obvious home.

The work ran in two phases. First I rebuilt the information architecture. Then the product itself changed, from a basic retrieval tool into a document memory that asks before it answers and checks a vessel's documentation against the regulations it has to satisfy, and it shipped under a new name.

Three journeys carried nearly all of the product's value, and all three were scattered the same way. Their entry points sat in groups named after whichever release had shipped them, so one journey was split across unrelated menus. Page layouts changed from screen to screen, so each screen had to be learned separately. That showed up as training overhead, support load, and a cost on every new feature, because there was nowhere correct to put one.

I rebuilt the information architecture rather than restyling the screens on top of it. Every feature was inventoried, reduced to the task it served, and tagged with the journey it belonged to. Once each feature carried a label the scatter was visible, and the new navigation followed from the tags.

Rejected Redesigning screen by screen, leaving the structure as it was.

Every screen got the same anatomy. A context header, then controls, then the data surface, assembled from the design system's ~140 tokens and 41 base components. Screens became predictable to use and quick to produce. A single release cycle became workable.

Then the brief changed. What existed was a basic retrieval tool: ask a question, get a passage back from a document. What the fleet needed was something that could hold a vessel's entire documentation set, reason across several documents at once, ask for what it needs before answering, and check the set against the regulations a company works to.

That is not a feature bolted onto the old thing. It needed a document store, an ingest pipeline, folders, teams and permissions, usage limits, and an answer surface built around evidence rather than around text. The interface went with it: the old build was dark throughout, and not one screen survived the change. I built it ground up, and it shipped as Ask Luma.

BEFORE · TIDE TRACE

AFTER · ASK LUMA

Zoom

Two full screens of the same product, one before the rebuild and one after. The first, labelled Tide Trace, is dark throughout. A question about the temperature readings in an air compressor is answered with a numbered list of five readings, each with its figures, and under it a heading reading Source with two document chips beside it, one a PDF and one an image. A quota panel in the sidebar counts searches used against a limit, and the composer reads Start Searching. The second, labelled Ask Luma, is light. A question about a fire monitor is answered in prose, above a collapsed reasoning control and a source document given as an openable row. The navigation down the left edge is the same five items in both: home, memory, team, plans and usage, history.

The navigation is the one thing that did not move. Home, memory, team, plans and usage, history: the same five entries carried through a rebuild that replaced everything underneath them.

Documents go into the memory and are filed into folders. A question runs against the folders you put in scope. The system reasons across whatever it needs, which is usually more than one document, and returns an answer with the documents it drew on attached.

The sources are openable, and they sit under every answer. A part number or a pressure spec is going into a maintenance order, so the operator has to be able to reach the page it came from, and so does the inspector who audits it afterwards. A citation you cannot follow is decoration.

Rejected Naming the source documents in text underneath the answer.

The reasoning is shown, and collapsed. Left open it pushes the answer down the page and makes every reply look like an essay. Removed altogether there is no way to tell a good answer from a confident one.

The system asks before it answers, because “descriptive” is a relative term. People type Deck crane and wait. To them that is a complete question, and telling them to be more specific asks them to know what a model needs. So a thin prompt gets questions back, and the operator replies in the words they already use.

An answer can come back as a chart. This came out of a client showcase, where what people asked about the output was whether it could go into a report or a meeting. A figure they have to rebuild in a spreadsheet is a figure they will not use, so the system draws it.

The chat ends before the answers get worse. Accuracy falls away as a conversation gets long, so the product says so and offers a new one rather than quietly returning worse answers in the same thread.

The folders are the tags, and that is a migration rather than a preference. Retrieval quality first depended on documents being tagged, which made the tags the user's problem; autotagging helped and did not remove it, because somebody still had to check what the tagger decided. Putting the same signal behind a folder structure attached it to something people were doing anyway, and the product picked up document management on the way.

Documents are filed under the names the crew already use, and filing and scoping are the same act. Machinery, hull, electrical, certificates, instructions. A memory that answers questions gets worse as it grows, unless the person asking can say which part of it they mean. So the folders are chosen on the same screen the question is typed on, and the number of documents in scope is stated up front, not inferred from a poor answer afterwards.

Two roles, split on who can write to the memory. A member views and searches; an owner uploads, manages access and sees usage. A shared memory is only worth trusting if not everyone can add to it.

Ask Luma is in production. The re-architecture landed inside a single release cycle. Two add-on features shipped after launch and fit the new structure without needing a new top-level home or a special-case layout.

Certificate and survey validity checking is designed and queued, not shipped. The compliance work in production is the regulation check and the audit trail.

None of the costs in 02 were measured. Training overhead and support load are what the team reported before the work, not a baseline I can compare against. The evidence the structure held is the one in 03: the product was rebuilt underneath the navigation without the navigation changing.

I was the sole designer across both phases: research, information architecture, the layout system, flows, high-fidelity design, and design QA against the live build.

• Re-architected, then rebuilt ground up, in one release cycle
• 2 features shipped after launch without bending the structure
• Every answer shows the pages it came from

The answer screen is the product, with placeholder records. The two architecture figures and the memory screen are drawings: they show structure and states no single capture holds.