All work

InfoTrax Systems · ValueLabs · 0→1 platform

FlexCloud

The brief said developer portal.

Thirteen interviews later, the unit of design had changed. FlexCloud wasn't a portal, it was a platform shell, and everything depended on getting the hierarchy right before touching a single screen.

  • 13Interview sessions, 13 roles
  • 5Scope levels, set before any screen
  • 3Testing rounds before handoff
Presentation board of FlexCloud's final UI screens, including My Integrations and environment views.
Client
InfoTrax Systems (Orem, Utah), via ValueLabs
Role
UX and product design: IA, foundation design, flows, UI, visual design and the design system. One of two lead designers, alongside a UX researcher.
Team
Two designers (UX research, and me on UX and product) with three product managers
Timeline
At ValueLabs · about 8 months
Platform
Web platform: developer console, integrations, API documentation
Status
Phase I delivered. No post-launch metrics: I moved to another engagement before they could be collected.

Confidentiality Delivered through ValueLabs. Stakeholders are referred to by role, InfoTrax's own clients are described generically, and the scenario below is illustrative.

A monolith trying to become a platform.

InfoTrax provides back-end operations for direct-sales enterprises on a legacy full-stack system, with every deployment customised. FlexCloud was the strategic bet: one SaaS platform, every service as a subscription API. Phase I was the developer portal. Phase II was the commissions engine.

Five constraints from day one

ConstraintWhat it meant
No industry precedentThe service blueprint had to be built, not benchmarked
Every role had to fitInternal and external users in one ecosystem
Users didn't ask for this migrationLegacy-fluent people becoming beginners
Agile cycle, internal testing firstDesign had to stay ahead of build
Under-developed style guideA design system was a prerequisite, not a deliverable

Three stakeholders. Three different products.

StakeholderPositionWhat it meant
VP of ProductSelf-service is the business caseClients need their own API access on their own login
Product ManagerFunctional, but not rightIt works, but there's a better approach
VP of R&DInternal teams firstHear complaints from our own people before clients do

The third position reorganised everything. If internal teams were the first users, this wasn't a client-facing portal. It was a system internal and external users would both live in, with very different permissions.

In practice: a developer managing five integrations needed the one scoped to their test environment and had no way to filter by environment, owner or status. They kept a bookmark for each environment. That was the interface.

No direct-sales company had done this, so we looked sideways at Shopify, Box and Slack, and built a side-by-side IA comparison between Box's console and FlexCloud's structure. It made the gaps arguable, not just assertable: permission scoping, environment isolation and developer-specific views were all missing.

Research board summarising ethnographic findings, insights and the hypothetical service blueprint.
Research findings and the hypothetical blueprint, as presented to the client.

What thirteen sessions changed.

Thirteen sessions across thirteen roles, then six weeks of synthesis. Each session walked participants through a deliberately hypothetical blueprint, then through the legacy services they actually used. Putting a wrong version in front of people surfaces what nobody thinks to mention.

Three tiers, not three personas

TierWhoRelationship to FlexCloud
CustomerCTO, CXOBuy it, never use it
UsersDevelopers, IT admins, implementation managers, system adminsLive in it daily
ServedAccount managers, BAs, support analysts, PMs, salesAffected without touching it

The tier structure is what made the permission model fall out naturally later. Participants also kept trying to do things the blueprint had no place for: switching organisations, isolating work to an environment, seeing only what their scope allowed. The blueprint assumed a portal. Their corrections assumed a platform. That gap was the finding.

Recommendations were prioritised as must, maybe and ignorable, which turned a list of good ideas into a roadmap the client could act on.

FlexCloud isn't a portal. It's five levels of hierarchy.

  1. L1UserWho you are, and what scope you see
  2. L2OrganisationsInternal users span several; external users sit in one. Switching is first-class.
  3. L3EnvironmentsDev, QA, Staging, Preview, Live, Commissions, gated by scope
  4. L4ApplicationsIntegrations Manager, API Docs, SDKs, legacy access, IDE
  5. L5Sub-apps and tasksWhere the actual work happens
Diagram The five levels every later decision had to satisfy.

The existing build treated FlexCloud as a flat set of pages. It couldn't handle internal users spanning several organisations, or environments gated by scope. I defined the hierarchy before drawing anything. Once it was settled, the IA, navigation, permission model and environment switcher resolved almost mechanically.

I explored six foundation layouts, each with annotated trade-offs: where organisation and environment switching lived, how navigation collapsed, how far sub-menus reached, and how visual weight signalled depth of scope.

Decision · Portal or platform shell

Rejected
A developer portal: a flat set of pages for external developers. Faster to a first release, but it breaks the moment internal teams need it, and environment switching stays a bookmark.
Chosen
A platform shell with five scope levels: User → Organisations → Environments → Applications → Sub-apps and tasks. Internal and external users share one model with different views.
Trade-off
The hierarchy had to be fully resolved and agreed before any wireframe, so the first sprint felt slower.

Four problems worth showing.

Every workflow was flow-charted before wireframing, including edge cases, error states and micro-interactions. That discipline caught the read-only gate: letting users edit directly without first seeing a summary created accidental-modification risk in live environments. It came from a flow diagram, not a wireframe, and usability testing later surfaced the same gap independently.

FeatureThe problem it solved
Environment ManagerDevelopers switched environments through bookmarks and credentials. It became a persistent control with per-environment URLs, visible access windows and no-access states with inline request paths.
Scoped searchLegacy and REST docs were split across two systems. One bar, switchable between everywhere and a specific organisation.
Integration cardsThe grid collapsed under real volume. Seven card variants covered collaborators, enable/disable, errors, long names and relative timestamps.
Help and SupportBug reports arrived as descriptions. Feedback now carries an annotatable screenshot plus diagnostic data, so issues arrive reproducible.
Board of final UI screens showing My Integrations with environment tabs, integration cards and detail views.
Final UI: My Integrations with environment scope, card variants and detail views.

Illustrative scenario: fixing a broken integration in production

  1. 01Lands in the organisationThe environment selector shows Production active.
  2. 02Finds the integrationScoped search filters to Production only. No bookmark needed.
  3. 03Checks the docsAPI documentation scoped to this environment, without irrelevant endpoints.
  4. 04Files a reportA bug report with screenshot and diagnostic data attached, reproducible from day one.

Built from a loose colour list.

InfoTrax had colour values and little else, so I built the system alongside the product. The palette was rebuilt as a semantic set from the brand primary and tested against WCAG AA (4.5:1) and AAA (7:1), because enterprise clients required it contractually. A custom icon library on a 24px grid with a 2px stroke, and full component variant sets, each with error and empty states. Sketch, low-fi and high-fi interactive prototypes; nothing skipped a rung.

  • Primary#D93030
  • Hover#B22727
  • Error#FF3A3A
  • Success#27AE60
  • Warning#FFAB00
  • Grey 1#333333
  • Grey 3#555555
  • Grey 2#666666
  • Disabled#DDDDDD
The semantic palette, rebuilt from the brand primary.
Board revisiting the visual design system: colours, iconography and design phases.
Colours, iconography and the three fidelities the work moved through.

The only test a design system has to pass: could the client's developers extend the platform after we left without re-deriving the rules?

Prototypes as the argument.

Moderated testing with real InfoTrax roles: software developers, the implementations team, and product and R&D leadership. One of us facilitated; I observed and took findings back into the designs. We measured time to complete, number of attempts, and behavioural cues like hesitation and backtracking, over three iteration rounds before handoff.

Board about uncovering technical and business process loopholes through remote usability testing.
Testing the architecture before the interface was finished, not after.

What shipped, and what I can't claim.

  • 13Interview sessionsAcross 13 roles
  • 6Foundation layoutsExplored and annotated
  • 3Iteration roundsFrom testing, before handoff
  • Delivered

    Scope hierarchy

    Five-level platform architecture, validated with stakeholder and research output.

  • Delivered

    UI and flows

    Foundation layouts, four feature flows, wireframes and high-fidelity prototypes.

  • Delivered

    Design system

    Token set, AA/AAA-tested palette and a component library with all states.

  • Not collected

    Post-launch metrics

    I'd defined what to measure (API adoption, ticket volume by workflow, error rate in integration creation) but moved on before data existed.

Reflection

  • Defend hardest: the sequencing

    Six weeks of synthesis before a wireframe felt indulgent. Once the five levels were settled, everything else resolved.

  • Change: measurement

    Rigour on the way in, nothing on the way out. Next time a baseline goes in before launch.

  • Foundations look like a detour

    The design system felt like overhead for a month and was the most important work on the project by the end.