Unbabel — 2025
My role
Product Design Lead
Industry
Translation & Localization
Problem
Unbabel is a language operations platform that combines AI and human expertise to deliver fast, high-quality multilingual customer communication and localization at scale.
To manage translations, the platform includes internal apps designed to support LangOps, the internal specialists who configure and maintain tailored environments for each customer. Central to this ecosystem is the Pipelines app, responsible for orchestrating translation workflows, which had major usability issues by the time I joined the company and needed a full redesign.
Outcome
Over four months, we streamlined complex concepts, rethought the Pipelines app, and collaborated across the company to make it usable for both internal experts and external customers. I led the design effort hands-on while managing another designer, shaping strategy, execution, and cross-functional alignment along the way.
Background
This was a classic case where complexity couldn't be removed, only better managed. And that's what we did.
The main issues
Low efficiency
Making one change across several pipelines meant hours of manual work or asking the development team to run specific scripts, which wasn't scalable
Poor usability
Even frequent users had questions on how to perform basic actions
Low visibility
No easy way to spot configuration differences across pipelines, which made mistakes to be common
The symptoms
In the space of six months, this was the cost of keeping the app as it was:
Over 60% drop-off between opening a module and saving any change
126 support tickets for the development team to run scripts manually
175+ hours spent on changing modules one by one
56 questions from LangOps around how to perform basic actions
Understanding the landscape
This was my first project after joining the company, and while I was still ramping up on the translation and localization landscape, I had to quickly dive into one of the most complex parts of the product.
The app was built on top of a highly intricate codebase that couldn’t be easily or rapidly changed, so beyond understanding the user experience, I had to deeply understand the technical constraints behind the interface. This meant every design decision needed to be carefully considered, not just for usability, but also for feasibility, stability, and development effort.
My process
I focused on identifying the most critical pain points and adapted my way of working to meet the specific needs of LangOps and the way the development team worked, so my integration could be seamless. At the same time, I aimed for more simplicity in the experience to support both power users and those new to the platform, aligned with the company’s strategy. The main steps I took included:
Auditing the platform independently, even before the official discovery kickoff, to form an unbiased view of the current experience
Holding technical sessions with backend and frontend developers to understand system constraints and legacy limitations
Reviewing existing LangOps feedback to identify recurring pain points and areas of friction
Gathering internal data to assess the cost and impact of unresolved issues
Conducting weekly conversations with LangOps, first to gather insights, then to validate ideas and share design iterations
Working closely with the PM and engineers on a daily basis to stay aligned and make sure proposed solutions were feasible
Testing designs and prototypes with LangOps and other internal users across the company
Documenting all key trade-offs and decision rationale to ensure shared understanding and long-term clarity
The changes
Once I had a solid understanding of the environment I was designing within, it was time to move into design work. I began rethinking the app through wireframes, but even before diving into specific screens, it was clear that the way users interacted with each module inside a pipeline had to change. The existing side panel was cramped, visually outdated, and full of interaction issues. It needed to evolve into something more visual, spacious, and intuitive, a layout that could better support complex workflows without overwhelming the user.
The builder
I proposed a new approach to how pipelines were created and managed, shifting toward a more visual experience that would help new users better understand what pipelines are and how to orchestrate them effectively to meet their translation goals. And that's how we landed on a visual canvas where customers can clearly see what are the steps and how they're building their workflows.
Reimagining the
creation of a pipeline
I also redesigned the pipeline creation flow, once again leveraging the builder and its visual structure to improve clarity and usability. Before the redesign, the experience was confusing, key actions were hard to find, the interface felt cramped, and interaction issues often got in the way of completing tasks smoothly.
BEFORE
AFTER
Overall UI
There was a lot of room for improvement in the UI. The icons felt outdated, the layout lacked clarity, and the overall screen wasn’t optimized for usability. Additionally, users had no way to organize or group pipelines, which made navigation and management cumbersome. To address this, I introduced the concept of folders, allowing users to structure their pipelines in a way that suited their workflows. I also updated the iconography to improve clarity and give the interface a more modern, intuitive feel.
My role as an IC
and as a lead
SHE WENT FROM THIS
TO THIS ✨🤩
Testing
The new app is currently in production, available to LangOps, who have been using it everyday for over 2 months. The feedback has been super positive and we can already see concrete metrics that show we're on the right path.
"The designs are more efficient, aesthetically pleasing, and
performance seems faster, it's just what we needed!"
"Overall, the new Pipelines app is a clear step forward in both functionality and user experience. Pipeline groups are organized logically and intuitively, while key details like integrations, tags, and pricing types are now easier to find and visually well-presented!"
Business impact
While the new app hasn’t been released to external customers yet, its impact is already visible internally. By streamlining LangOps workflows and reducing manual effort, we’ve freed up the team to focus on higher-value tasks that directly enhance the quality of service and overall customer experience.
Designing for simplicity and power is hard
Balancing simplicity for new users and the flexibility required by experts was one of the biggest challenges in this project. I had to constantly negotiate where complexity was necessary and where we could introduce clarity without limiting capabilities, especially in a domain as nuanced and technical as language operations;
Collaboration made all the difference
Coming into a new company and diving straight into one of the most complex parts of the platform was overwhelming. I couldn’t have ramped up so quickly without the openness and support of the LangOps team, engineers, and PM. This project was a reminder that good design is never done in isolation, but rather built on strong, collaborative partnerships;
3
The joy of enabling others
Guiding another designer through the redesign of a critical part of the app was a big learning moment for me. Delegating with trust, offering support without micromanaging, and watching her grow and deliver high-quality work made me a better manager, and was one of the most fulfilling parts of this project.
"The Pipelines app, what a journey! Finally tackling something that was long overdue and actually seeing it through to production was really satisfying. I enjoyed our iterative process and all the feedback loops we had. Each iteration brought something valuable and made the final product so much better!"
