Access code

This case study requires a six-digit access code. If you do not have one, contact me and ask.

Enterprise Platforms & Complex UX

Enterprise software fails structurally before it fails visually: three teams using one word for different things, approval chains nobody fully mapped, data that will not move between departments. This is the work I have spent most of fifteen years on.

  • Enterprise UX
  • B2B Platforms
  • Data-Dense Interfaces
  • Accessibility

How I work here

The method starts below the interface. I map the domain model first (what the words mean, who decides, where the data lives), because foundations laid there scale and screens drawn without them get redrawn. On the procurement platform that meant carrying a classification model from individual product variants up to globally mandated assortments, and making it actionable for global governance and local operations at once.

Density is a craft problem with a working set. Reconciliation views, tender pipelines, portfolio tables: people sit inside these screens for eight hours a day, so tables get designed to a written spec (column order matched to the scan pattern, tabular numerals, row density tested against real records, filter and sort states that survive a reload), with composed typography and motion that explains a state change rather than decorating it.

Accessibility is handled as an engineering constraint rather than a checklist: WCAG-conscious components, documented for the people who build them, on whatever stack is already in production.

Start with the domain model, not the screens

Every enterprise platform inherits a domain that existed long before the software: procedures, vocabularies, informal rules about who may change what. The first weeks of the work build a usable model of that reality: the entities and their lifecycles, the terms and their competing definitions, the approval chains as they actually run rather than as the org chart implies. The model gets written down as artifacts a team can veto (a term glossary with an owner per definition, entity-lifecycle maps, a permission matrix of who may change what and what leaves a trace) and argued over on paper, because a disagreement found in a glossary costs an afternoon; the same disagreement found in production costs a quarter.

That model makes the hard calls tractable: what is a source of truth and what is a projection of it, which fields are shared and which are local, where a workflow forks by role or by market. Interfaces designed after those decisions tend to survive. Interfaces designed before them get redrawn every time the model shifts underneath.

Density is a material, not a problem

Operational screens carry more information per pixel than anything in consumer software, and the people using them do not want less data; they want faster answers. The craft is not reduction but ordering: typography with strict hierarchy, tables designed around the scan pattern of the person reconciling them, and progressive disclosure that keeps key figures permanently visible while holding configuration depth one level back.

The details that make dense software feel calm are small and cumulative: aligned numerals, consistent units, empty states that say why, motion that explains a change of state instead of decorating it, keyboard paths for the people who live in the screen all day. Accessibility belongs to the same discipline: contrast, focus behavior, and semantics are specified per component, on whatever stack is already in production.

Multi-role systems, governance, and adoption

A platform serves buyers, coordinators, managers, and auditors at once, and each role sees a different slice of the same records. Permission and approval logic is designed as a first-class product surface: who sees what, who may change it, what leaves a trace. In governed organizations an interface that cannot be audited will not ship, so auditability is designed in rather than bolted on.

Adoption is an outcome, not an assumption. Systems that replace spreadsheets win by removing specific, recognizable pain: less manual entry, no duplicate records, visibility that did not previously exist. Designing for that means sequencing releases around visible wins and aligning the interface with the language operations already speaks.

What this covers

  • Information architecture for inherited domain models
  • Complex tables, reconciliation, and audit views
  • Approval chains and permission models
  • Dashboards and analytics built around decisions
  • Progressive disclosure for configuration-heavy tools
  • Multi-market and multi-brand platform structures
  • WCAG-conscious component specification
  • Admin, back-office, and operations tooling

Questions, briefly

How is enterprise UX different from consumer UX?
The user rarely chose the software, the workflows predate the product, and the buyer is not the person inside the screen. That changes the job: less persuasion, more structure. The wins come from domain modeling, terminology alignment, and removing operational pain, and the interface earns trust by being predictable under load rather than novel.
Can dense screens stay usable without hiding data?
Yes; hiding data is usually the wrong instinct for professional tools. The working methods are hierarchy, alignment, and disclosure: keep the figures people act on permanently visible, hold configuration one level back, and design tables around the reconciliation patterns people actually follow. Density done well reads as calm.
How do compliance requirements affect the design work?
Less than teams fear, if governance is treated as a design constraint from the start. Decision logs, auditable flows, and explicit permission models tend to improve a platform's structure. What does not work is designing as if the constraints were temporary.