Enterprise asset lifecycle management · 2026
uPALMS
Refactoring a 10-year-old asset lifecycle system — entirely co-designed with AI.
- Client
- UBIVELOX (South Korea)
- Role
- UI/UX Designer with AI
- Outcome
- 61 screens shipped as interactive prototype, now in client review.
















Context
uPALMS is a full refactor of a ten-year-old asset lifecycle management system that UBIVELOX has run internally for most of the last decade. Three roles — Administrator, Manager, Auditor — work across 61 screens grouped into 10 modules covering master data, assignment, audit, depreciation, and disposal. The constraint set the tone of the entire engagement: every operational workflow had to stay faithful to the process the client had already validated. Only the interface and the technology underneath it were allowed to change.

Problem
The old system worked, but it had aged into the kind of tool people tolerated rather than used. Field auditors carried laptops into warehouses to do work that should have been a phone scan. Managers and auditors saw the same dense screens regardless of context. Ten years of feature accretion had blurred the line between configuration and core workflow. The team needed a faster, role-aware interface that respected mobile reality — without re-litigating a single business rule the client had already operationalized.
- 01
Laptops carried into the field
Auditors hauled laptops into warehouses to do work that should have been a phone scan. The system never met the device where the work happened.
- 02
One screen for every role
Administrators, managers, and auditors saw the same dense surface regardless of context. Density priced into the design even when the role didn’t need it.
- 03
Configuration tangled with workflow
Ten years of feature accretion blurred the line between system configuration and daily operations. The two surfaces had grown into each other.
What the refactor untangles
Mobile gets a field instrument; web gets a control center; configuration moves out of the everyday workflow. The business rules underneath stay exactly where they were.
Insight
Watching how the three roles actually used the system surfaced two ideas that reorganized everything that followed. Web is a control center; mobile is a field instrument. And an asset record is not an inventory row — it is a lifecycle artifact moving through purchase, assignment, audit, depreciation, and disposal. Once those two ideas were named, the 61 screens stopped feeling like a flat list and split themselves cleanly into 10 modules with clear ownership.
An asset is not stock — it has a life. Web controls that life; mobile witnesses it.
Decisions
Co-design the entire UI prototype with Claude Code, not Figma
Instead of opening Figma and drawing 61 screens, the prototype was built directly as a working React 19 + Vite + Tailwind app, designed turn-by-turn with Claude Code as the design partner. The output isn't a clickable mock — it's the actual frontend, with real state, routing, and a GlobalDB layer that mirrors the eventual backend schema. AI handled the mechanical parts of UI assembly; the design work moved up the stack to system structure, role-aware flows, and decision documentation.
Some of Figma's craft surface — the comp-level polish, the design-tooling ergonomics — was deliberately given up. In return, the prototype became the handoff: stakeholders could click through real flows, and the dev team inherited working code instead of a static spec.
▾ uPALMS/ # repository root├── ▸ .claude/ # AI working memory├── ▾ upalms/ # spec layer · source of truth│ ├── CLAUDE.md # project-wide working contract│ ├── README.md │ ├── ▸ docs/ │ ├── ▸ data-schema/ # per-module schemas · 12 files│ ├── ▸ design-system/ # tokens · status colors · mockups│ ├── ▸ i18n/ # en · ko translations│ └── ▸ outputs/ ├── ▾ upalms-demo/ # production prototype · React 19│ ├── package.json │ ├── vite.config.js │ ├── eslint.config.js │ ├── index.html │ ├── ▸ public/ │ ├── ▸ src/ │ └── ▸ docs/ └── upalms-demo-source/ # mirror of upalms-demo/
Honor the client's existing process; refactor only the surface
UBIVELOX has spent ten years tuning the operational logic of this system. Approval chains, role permissions, the boundary between Administrator, Manager, and Auditor — all of it stayed exactly as it was. The redesign was scoped strictly to the UI layer, the interaction patterns, and the move to a modern stack (NestJS, NextJS, Flutter for mobile). No business rule was reopened.
Several 'obvious' UX simplifications were left on the table because they would have shifted semantics the client had already operationalized. The discipline was to resist the redesign instinct wherever the existing process still served the user.


SRS as source of truth; Figma demoted to a reference surface
A 7,943-line SRS document, per-module schema files, and a project-wide CLAUDE.md formed the working contract for the project. Every screen had to be read against its SRS section before it was designed. Both Claude Code and human developers read from the same documents — the prototype, the schema, and the spec stayed in lockstep because they all referenced one source. Figma stopped being the system of record and became a walkthrough surface for stakeholders.
Each screen took longer to start because the spec had to be read first. In return, drift between spec and prototype dropped to near zero, and onboarding a developer (or another AI agent) became a question of pointing at the right markdown file.
Design partner
Reader 01
UI/UX designer
Holds direction and navigation. Sets the brief, decides the system shape, and steers Claude Code turn-by-turn.
Reader 02
Claude Code
Holds execution capability. Reads the spec, generates the surface, applies revisions on direction from the designer.
Source of truth
Artefact 01
SRS document
7,943 lines · the operational truth.
Artefact 02
Per-module schemas
One file per module · the data shape.
Artefact 03
CLAUDE.md
Project-wide working contract.
Reader 03
Human developers
Read the same markdown to onboard, then implement backend and API against the schema. Also refactor the prototype code and fix bugs directly — the prototype is shipping code, not a static spec.
Figma · walkthrough surface for stakeholders
Reference surface · not source of truth
Sits on the side
Execution
The deliverable is a single-file React 19 + Vite + Tailwind v4 prototype, backed by a custom GlobalDB layer that mirrors the planned NestJS schema and persists to localStorage. 61 screens, 10 modules, 3 roles. Six asset status states are locked at the design-system level — Available, Leased, Checked Out, Broken, Disposed, Lost — each rendered through a single StatusTag component so that color and meaning never drift across screens. Documentation lives next to the code: the SRS, data-schema files, and CLAUDE.md form a working contract that both AI agents and human developers can read.
Asset status · 6 locked states
- Available#10803a
- Leased#3b6cb8
- Checked Out#b07a14
- Broken#b8423a
- Disposed#4a4f57
- Lost#1f2228
Indigo brand scale
Neutral ramp
All six status states route through a single StatusTag component, so colour and meaning never drift across the 61 screens. The same discipline holds for Tag and the rest of the surface primitives.
Outcome
The prototype is now in the client's hands for hands-on evaluation, not as a clickable mock but as a real frontend that responds to real interaction. Because the prototype is shipping code, the development team's remaining work is mostly backend and API — an experienced frontend engineer can refactor the prototype directly rather than rebuild it from a spec. The case is honest about where the work ends: this is a foundation handed forward, not a launched product. What it proves is that an AI-augmented design pipeline can take a decade-old enterprise system through a full UI refactor without losing fidelity to the process the business runs on.
Try the prototype yourself (opens in a new tab)