Julie West
← Back to the cabin

Case study · Developer experience

Designing Beyond the UI

Treating APIs, developer tools and agent-ready platforms as products, to lower integration cost and grow the platform beyond its UI.

Role
Senior Product Designer / Retail Media UX Lead
Focus
Developer Experience, API Design, Product Strategy, UX Research

The opportunity

What does product design look like when there isn't a UI?

Most of my career has been spent designing interfaces. Helping people navigate products, complete tasks, and make sense of complex systems.

But at Criteo, I became increasingly interested in the experiences happening outside of our UI.

Our customers weren't always using the platform the way we designed it. Some were integrating directly with our APIs, building their own tools, and managing advertising workflows programmatically.

For these customers, the product experience wasn't necessarily a dashboard.

It was documentation, authentication, API responses, errors, and the effort required to connect everything together.

And with AI coding tools and agents becoming more capable, those experiences were taking on even greater importance.

I started asking a question:

If APIs are products, why aren't we designing them like products?

That question became the foundation for my work on Criteo's developer experience.

The problem

A developer journey nobody was designing

Criteo operates a complex advertising ecosystem, with APIs supporting advertisers, retailers, technology partners, and their developers.

While we had established design processes for our user interfaces, the developer experience had not received the same level of design attention.

Several challenges emerged:

  • Fragmented experiences. Developers interacted with multiple touchpoints, from documentation to API responses to support tickets, without necessarily having a cohesive journey.
  • Inconsistent language. The same concepts could be represented differently in the UI, APIs, and emerging MCP tools, requiring developers to translate between them.
  • Unclear error recovery. Error messages did not always provide the context or next steps developers needed to resolve a problem independently.
  • Complexity around change. API updates and versioning introduced questions about compatibility, migration effort, and how customers could anticipate changes.
  • A changing technology landscape. AI-assisted development and agent-based integrations introduced new expectations for how easily platform capabilities could be discovered and used.

The underlying issue wasn't a single broken workflow.

The real problem We needed to consider the developer journey as a connected product experience.

My role

Bringing product design to the developer experience

I initiated and developed a product design direction for Criteo's API and developer experiences, bringing together research, experience audits, industry benchmarking, and proposed standards.

My work included:

  • Conducting research with developers and technical teams outside Criteo.
  • Defining an API-first product design charter.
  • Evaluating the developer portal and the discoverability of API capabilities.
  • Auditing API error experiences and proposing a shared error standard.
  • Researching API versioning and migration practices.
  • Exploring consistency across UI, API, and MCP surfaces.
  • Assessing how the developer ecosystem could better support AI coding tools and agents.

The work required collaboration across product and engineering, while introducing design considerations into an area traditionally led by technical teams.

01 · Understanding how developers actually work

Researching beyond our own platform

Before proposing solutions, I wanted to understand how developers interacted with APIs in practice.

I conducted five external interviews with technical teams from organizations including:

  • Stripe
  • Salesforce
  • Cloudflare
  • Contentful
  • BrowserStack

The conversations explored how teams discover APIs, evaluate integration requirements, use documentation, debug problems, and balance developer tooling with graphical interfaces.

I was particularly interested in the relationship between the developer experience that companies intentionally create and the workflows their customers actually use.

Key insights

  1. Developers build their own workflows.

    Developers often use tools such as Postman, coding environments, custom scripts, and internal tooling instead of relying on a platform's UI. This challenged the idea that improving the UI alone could improve the entire customer experience.

  2. Documentation is part of the product.

    The quality of documentation shapes how quickly developers can understand capabilities, make their first successful request, and independently resolve issues. It's not simply supporting material. It's an active part of the experience.

  3. Errors are moments of product interaction.

    When an API fails, developers need to understand what happened, why it happened, and what to do next. An unclear error creates unnecessary debugging, support requests, and frustration.

  4. Interfaces still matter.

    An API-first approach doesn't mean abandoning graphical interfaces. UIs continue to provide value for discovery, visualization, oversight, and workflows where visual context helps people make decisions.

What changed in my thinking

The research reinforced that the opportunity wasn't to make our developer portal look better.

It was to improve the end-to-end experience of understanding, integrating with, and maintaining connections to Criteo's platform.

02 · Establishing an API-first design strategy

Expanding what counts as a product experience

Based on the research and the gaps I identified, I authored an API-first product design charter.

The goal was to introduce a more intentional design approach to surfaces that historically received less UX attention.

I proposed thinking about the experience through several connected layers:

  1. Discoverability Can developers understand what capabilities exist and where to start?
  2. Learnability Can they understand the underlying concepts, requirements, and expected behaviors?
  3. Integration How much effort does it take to connect and successfully execute a workflow?
  4. Recovery When something fails, can they understand and resolve the problem?
  5. Continuity Can customers confidently maintain their integrations as the platform evolves?

Together, these became a framework for thinking beyond individual API endpoints.

Designing for multiple ways of interacting

One of the principles I wanted to establish was that the UI, API, and emerging agent interfaces should not be treated as entirely separate products.

They are different ways of interacting with the same underlying capabilities.

A customer configuring an advertising campaign through the UI and a developer creating one through the API should encounter consistent concepts and predictable behaviors.

The interaction methods will differ, but the mental model shouldn't have to change completely.

My guiding principle Design the capability, not just the interface.

This reframed developer experience as a shared responsibility across product design, product management, and engineering.

03 · Making API errors more useful

Turning failure into a recoverable experience

One of the most tangible opportunities emerged around error handling.

Poorly communicated API failures create a frustrating experience for developers.

Imagine receiving an error that tells you a request is invalid but doesn't explain which field caused the problem or how to correct it.

The system knows why it rejected the request, but the developer is left to investigate.

We had identified poor error context as a recurring source of developer support requests.

I audited our existing error patterns and explored how we could make them more consistent, actionable, and understandable.

Introducing an error experience standard

I proposed aligning API errors with RFC 9457, the Problem Details for HTTP APIs standard.

But rather than treating it as purely a technical specification, I approached it as a content and interaction design problem.

A useful error should answer four questions:

1. What happened?

A clear explanation of the failure.

2. Why did it happen?

The relevant cause or validation issue.

3. What can I do?

An actionable next step.

4. Where can I learn more?

Relevant documentation or support.

This led to recommendations around error structure, terminology, documentation links, and actionable messaging.

An illustrative example

Before
400 Bad Request: Invalid parameter
Proposed experience
400 Bad Request: Budget below minimum

The daily budget is lower than the minimum allowed for this campaign configuration.

Increase the daily budget to meet the minimum requirement, then retry the request.

The difference is relatively small in implementation terms, but significant in usability.

The intention was to help developers recover independently rather than forcing them into a support workflow.

The broader opportunity

Better errors aren't simply nicer messages.

They can reduce integration friction, improve developer confidence, and create opportunities to reduce avoidable support requests.

I also explored how error quality could become measurable through indicators such as repeated failures, resolution time, and support escalation.

This work produced a proposed standard and recommendations for improving the developer experience.

04 · Designing for API evolution, not just initial integration

The developer journey doesn't end at the first successful request

Another important challenge was API versioning.

For a platform like Criteo, an API change can create substantial downstream work for customers who have built their own integrations.

Even when a technical change is well documented, customers still need to understand whether it affects them, what action is required, and when they need to act.

I investigated how leading API platforms manage versioning, deprecation, and migration experiences.

My benchmark included approaches from Stripe, Shopify, Atlassian, and Microsoft Graph.

  • Stripe
  • Shopify
  • Atlassian
  • Microsoft Graph

Finding the experience opportunity

Across these practices, several important principles emerged.

  • Predictability matters. Developers benefit from understanding how frequently changes are introduced and what compatibility guarantees exist.
  • Relevance matters. Not every change affects every customer. Communication should help developers identify what actually matters to their integration.
  • Migration needs guidance. A changelog describes what changed. A migration experience explains how to adapt.
  • Continuity builds trust. Customers need confidence that platform evolution won't create unexpected disruptions to their business.

A more customer-centered versioning experience

I proposed a direction that would help developers understand:

  • Which API version they're currently using.
  • Whether a new version affects their integration.
  • What changes are required.
  • How much migration effort may be involved.
  • When an older version will no longer be supported.
  • How they can validate their integration before making the switch.

I also explored a longer-term vision for making this information more visible and actionable through developer-facing tools and dashboards.

The ambition was to move from communicating platform changes to helping customers manage them.

Good versioning is not just about releasing change. It's about protecting customer continuity.

05 · Making the platform ready for AI-assisted development

A new kind of developer experience

As I explored our developer ecosystem, another shift was becoming clear.

Developers were increasingly using AI assistants to discover documentation, write integration code, debug issues, and interact with tools.

Model Context Protocol (MCP) introduced an additional way for AI-enabled tools to connect with platform capabilities.

This raised a new question:

How well can an AI agent understand and use our platform?

A developer might no longer begin an integration by reading documentation page by page.

They might ask a coding assistant to find the correct API, explain its parameters, and help implement a workflow.

In that scenario, the quality and consistency of our developer infrastructure becomes even more important.

Evaluating agent readiness

I assessed Criteo's developer portal using agent-readiness evaluation tools and reviewed opportunities across three areas.

  • Technical readiness: How easily can automated tools discover and access relevant information and capabilities?
  • Experience readiness: Are documentation, terminology, and tool descriptions clear enough to support both humans and AI systems?
  • Measurement: Can we understand what developers and agents are searching for, where they encounter problems, and which capabilities remain difficult to use?

I also explored MCP setup guidance for tools such as Claude, Cursor, and VS Code, as well as opportunities to instrument searches and unanswered queries.

Consistency across UI, API, and MCP

One particularly interesting challenge was the language used across our product surfaces.

The UI might describe a capability one way, the API another, and an MCP tool a third.

For humans, this creates confusion. For AI agents, it can also make mapping a user's request to the correct platform action less straightforward.

Rather than trying to standardize the entire ecosystem at once, I proposed starting with a small, contained workflow: adding a creative.

The pilot would compare how the same concepts, attributes, and actions appeared across our different surfaces.

From there, we could establish a shared vocabulary and reusable approach for future workflows.

The goal was a more coherent platform experience, regardless of whether the user was a person navigating the UI, a developer calling an API, or an agent using a tool.

Connecting the work

More than functional endpoints

These initiatives began as different investigations, but they all pointed toward the same underlying problem.

A successful integration depends on more than functional endpoints.

Developers need to discover the right capabilities, understand how they work, execute them successfully, recover from failure, and maintain compatibility as the platform changes.

And increasingly, AI systems need to do some of these things on their behalf.

I began connecting these opportunities through a product design perspective, treating the developer ecosystem as a series of related customer experiences rather than isolated technical touchpoints.

The research informed the strategy. The strategy identified opportunities for standardization. The audits made specific usability problems visible. And the emerging AI ecosystem introduced new requirements for clarity and consistency.

Outcomes and impact

A direction for designing the developer experience

5
external interviews with technical teams
4
API platforms benchmarked for versioning
5
experience layers in the API-first charter
1
proposed error standard, based on RFC 9457

Research and discovery

  • Conducted five external interviews with technical teams.
  • Identified developer workflows and experience opportunities beyond the traditional UI.
  • Benchmarked industry approaches to developer tooling, errors, and versioning.

Experience strategy

  • Authored and championed an API-first product design charter.
  • Defined an experience framework spanning discoverability, integration, recovery, and continuity.
  • Expanded design discussions to include APIs, documentation, and agent-facing capabilities.

Standards and recommendations

  • Audited error handling and proposed a consistent structure based on RFC 9457.
  • Researched versioning practices and developed customer-centered migration recommendations.
  • Identified cross-surface terminology inconsistencies and proposed a focused pilot.

Future readiness

  • Evaluated developer-portal readiness for AI-assisted workflows.
  • Explored MCP onboarding and developer-tool integrations.
  • Proposed measurement opportunities to make developer friction more visible.

This work was primarily focused on research, strategic direction, audits, and proposed standards, rather than a completed redesign of Criteo's developer ecosystem. The broader contribution was establishing a direction for applying product design to an increasingly important part of Criteo's platform.

What I learned

Not every user opens your product

  1. Developers are users, even when they never open your product.

    Their experiences may happen in a terminal, IDE, API client, documentation page, or support conversation. That doesn't make those experiences any less deserving of thoughtful design.

  2. The most important UX problems aren't always visual.

    An ambiguous error, an unpredictable version change, or an inconsistent field name can be as disruptive as a confusing interface. Solving these problems requires understanding systems, behaviors, and mental models, not just screens.

  3. API-first doesn't mean UI-last.

    Different interaction methods serve different needs. The goal isn't to eliminate interfaces. It's to make the platform's capabilities understandable and accessible across the ways customers actually work.

  4. AI raises the importance of experience consistency.

    When agents interact with platforms on our behalf, clear terminology, reliable documentation, predictable errors, and well-defined capabilities become even more important. The quality of these foundations will influence how successfully agents can use a product.

Reflection

This project changed the way I think about product design

I entered the work curious about how developers experienced our APIs, and came away with a much broader perspective on what it means to design a platform.

Not every customer journey happens on a screen. Not every usability problem can be solved in Figma. And not every meaningful design contribution results in a new interface.

Sometimes the most valuable work is recognizing an experience that nobody has been intentionally designing, understanding the people who depend on it, and creating a path toward making it better.

For me, that's what product design is ultimately about: understanding how people use technology, finding the friction, and making complex systems easier to work with.

Back to the cabin