Mondrian AI · Yennefer

From an engineering concept to a connected enterprise AI platform

Defining a 0→1 enterprise AI platform around the real research lifecycle, from data discovery to experimentation to infrastructure governance.

Role
Founding product designer
Timeline
12 months, concept to launch
Team
Founders, 4 engineers, no PM
Scope
Enterprise AI / MLOps, 0→1 product strategy and design
app.mondrian.ai / studio
The shipped Yennefer Studio home, projects and status first
Data Catalog · Discover Studio · Build Admin · Govern
Three product surfaces, one platform. Studio home, shipped.
Context Problem Decisions Impact
Context

Working infrastructure, but no product model

Engineering had already validated the technical infrastructure. What the company had not yet defined was who the core users were, how their workflows connected, where the product should begin and end, and what success looked like.

I joined as the founding product designer, working directly with the founders and four engineers. There was no dedicated PM or researcher, so my role began with defining the product problem before designing any interface.

Undefined
Who the core users were
Undefined
How their workflows connected
Undefined
Where the product began and ended
Undefined
What success looked like
The inherited prototype home: a profile banner, a Start My Server button, and four cards reading Off, N/A, N/A, N/A
Inherited The prototype I joined. It opened on server state, CPU, memory and disk. Nothing on it belonged to a piece of research.

My job was not to redesign an existing product. It was to help define what the product should become.

Research

Researchers were losing time before an experiment even started

I proposed and led the research myself: 10+ user interviews, 10+ domain reports, and 20+ competitive products. One AI engineer described spending roughly two weeks just collecting usable data: asking colleagues, searching shared drives, downloading files, discovering inconsistent labels or licensing restrictions, and starting again.

10+
interviews with researchers and administrators
10+
domain and industry reports synthesized
20+
competitive products taken apart, feature by feature
2
documents the team had been building without: the IA and the product requirements
The research lifecycle
Discover
Outside
Evaluate
Outside
Prepare
Outside
Build
In product
Run
In product
Monitor
In product
Share
Partial
Solid outline: inside the original product boundary. Dashed: happening in shared drives, chat threads and email.

The infrastructure worked. The research lifecycle around it was fragmented.

User tension

Researchers optimized for velocity. Administrators optimized for control.

Both were core users of the same enterprise platform, but their jobs pulled in opposite directions. The solution could not be one generic interface.

AI researchers
Optimized for velocity
Start work quickly
Preserve context between sessions
Reduce infrastructure decisions
Access the compute needed to experiment
Administrators
Optimized for control
Understand usage
Allocate scarce compute
Maintain accountability
Govern resources and permissions
Key principle
Different jobs. Shared system.
Problem framing

The prototype solved infrastructure. The product had to solve the research lifecycle.

Research led me to frame three systemic problems. They became the structure of the product, and of every decision after.

01

Discover

Finding and evaluating reusable data happened entirely outside the platform.

02

Build

Researchers had to reconstruct context around machines and environments instead of returning to their work.

03

Govern

Administrators could inspect usage, but the interface did not support meaningful resource-allocation decisions.

Collaboration and shared context connected all three.
01
Design decision

Expand the product boundary: the workflow broke before execution started

The original product boundary began at infrastructure execution: launch an environment, provision compute, run an experiment. Research showed users were already struggling before reaching that point.

So I recommended expanding the product upstream, making data discovery and evaluation part of the platform.

This increased scope and engineering effort. It also meant solving the actual end-to-end workflow rather than optimizing only the middle of it.

Before
Build Run Monitor
After
Discover Build Run Monitor
Product decision
Move the platform boundary upstream, to where the work actually begins.
Solution · Data Catalog

Connect discovery directly to experimentation

Instead of building another isolated repository, I designed the catalog around one connected workflow.

Find Evaluate Collaborate Import into Studio
Data Catalog search: one million datasets found, filtered by organization and topic, sorted by relevance
Find Search across indexed public and organization sources, filtered by organization and topic.
A dataset detail page with description, publisher, update date, tags and an activate server action
Evaluate Source, licensing and freshness before a researcher commits time to a dataset.
A comment thread on a dataset page with replies
Collaborate The discussion sits on the artifact, so evaluation knowledge stays with the data.
Import into an existing Studio project: a dataset card with a project selector
Import Straight into an existing Studio project, so discovery ends inside the work, not in a download folder.
Key decisions
Show licensing before users commit to a dataset
Support public, organization and project-level visibility
Import directly into an existing Studio project
Design for incomplete or inconsistent metadata

The catalog had to provide value before asking users to contribute

A new catalog risks being empty on day one. So the experience was seeded with indexed public sources and designed to stay useful when metadata quality was incomplete.

02
Design decision · Studio

Researchers returned to projects, not machines

The original Studio home centered the experience on infrastructure: servers, machines, environment status. Users came back with a different mental model.

So I changed the primary object from server to project.

“I want to see overall projects’ status and latest projects, rather than data and AI model resources, on the main page.”

AI researcher · usability testing
Project became the entry point
Run state visible at the project level
Shared work became part of the main workflow
Infrastructure moved into supporting context
Before: Studio home built around server state, with CPU, memory and disk cards
Before Server first. To resume work, a researcher had to remember which machine it lived on.
app.mondrian.ai / studio
After Project status, ownership, collaborators and last modified time, before anything about infrastructure.
Design principle
Organize around the user’s work, not the implementation model.
03
Design decision · Admin

Manage scarce capacity, not individual people

The original dashboard centered each row on a person, and the main action was stopping that person’s server. But the administrator’s real job was not monitoring people.

It was answering one question: how should scarce compute be allocated across important work?

GPU and resources became first-class
Project became the unit of analysis
Owner became supporting context
Infrastructure terms translated into work terms
Before: the inherited dashboard: a user profile banner, one default server, and CPU, memory and disk figures
Before One user, one default server, three numbers. No project anywhere on the page.
The shipped admin dashboard: gauges with absolute values, a shared-axis usage trend, the GPU usage table, and a project table with actions in each row
After Capacity, trend, cause and action, top to bottom, every row keyed to a project.

In a shared GPU pool, the waste is capacity that is held and never used

Someone finishes a run, leaves the session open and goes home. Total utilization never catches it, because the GPU looks busy. Any one number on its own lies.

So state, time held and actual usage sit in one row, sorted by longest held, with the owner right there, so the admin has an option other than killing someone’s job.

The GPU usage table: GPU ID, occupied state, occupied for, project ID, project owner and usage in one row, sorted by occupied for
One row per GPU: state, time held, project, owner, actual usage.
What changed
From a monitoring surface into a resource-allocation tool.
Tradeoff
Making projects and resources primary made “which person should I contact?” less immediate. Owner stayed in the row, but it is no longer the way in.
Deep dive · Data visualization

The visualization followed the decision, not the available data

The administrator needed three things in a single scan.

Which resource is constrained? Is the problem temporary or persistent? Which work is consuming it?
A · Detailed trends
Deep diagnosis, weak cross-resource comparison.
Option A: four gauges above four separate full-width trend charts
B · Dense comparison
Fast horizontal scan, insufficient detail for diagnosis.
Option B: four narrow columns, each a gauge above a small trend chart
C · Current state + trend Chosen
Supports comparison and diagnosis, at the cost of vertical space.
Option C: one row per resource, gauge on the left and its trend chart on the right

I chose C because it was the only layout that supported the allocation decision, not because it showed the most data.

Impact

What we knew at launch

12 mo
Concept to launch
Three applications shipped on one platform model.
15+
Enterprise and education customers
Including Samsung Display, KT, Hyundai and Seoul National University.
70 → 91%
Company-reported task efficiency
Reported internally after the rebuild. Methodology not independently validated by me.
These are the outcomes the project material supports. The framework below is how I would measure the platform today.

Measurement framework I would establish today

North star
Time to first successful experiment
It is the only metric that spans the whole model: discovery, setup, compute access, and successful execution.
Researcher
Discovery to import completion
Environment readiness time
Resume-task success
Experiment abandonment
Administrator
GPU utilization
Idle held capacity
Time to resolve allocation issues
Successful allocation changes
Business
Pilot to paid conversion
Expansion and renewal
Onboarding time
Support burden
Reflection

I got the core objects right. I did not always design for attention.

Each surface answered “what exists” well. Three of them should have answered “what matters now”.

Studio

Inventory → attention

Sorting 68 projects by recency is an inventory. What a returning researcher needs is the exception.

1 failed overnight 3 running 2 completed since you left
Admin

State → action

The dashboard reported the situation accurately. It should have carried the decision further.

Thresholds Alerts Cost context Recommended next actions
Discovery

Search → intent

Search and filters assume the researcher can name what they want. Often the real request is comparative.

“Find a dataset like this one that allows commercial use.”

A product surface should help users understand what matters next, not just show what exists.

What this project taught me

Designing complex enterprise products often starts before the interface. The decisions that mattered most here were:

Expanding the product boundary when research exposed the wrong scope
Designing different experiences for different jobs without fragmenting the platform
Choosing product objects that match how users think about their work
Connecting design decisions to measurable user and business outcomes

My role was not to design three applications. It was to define an end-to-end product model around the AI research lifecycle, and translate it into a connected enterprise platform.