The product had everything. Users still didn’t know where to begin.
Translate.video lets enterprise teams transcribe, translate, subtitle, and dub videos into 75+ languages inside one editor. The AI worked. The interface around it didn’t. This is how I fixed that.
A product used by 250,000 creators — and enterprise teams at Target, HDFC, and Mahindra.
Video localization used to require separate tools for transcription, translation, dubbing, and voice. Translate.video collapses all of it into one editor. Upload a video, get subtitles, translate into 75+ languages, swap the voiceover, export.
For individual creators, that’s impressive. For enterprise teams shipping branded video across regions at scale, the stakes are higher. Getting one language wrong is a problem. Getting it wrong across five is five separate problems.
I came to this straight after the Aero design system. That was abstract and invisible. This was a real interface that real users were struggling with every day, with real consequences when they got it wrong.
My role in this project.
I was the only designer, working directly with the CEO, COO and three engineers. I owned the experience end-to-end: research, IA, every screen and interaction state, stakeholder pushback, and engineering feasibility.
One constraint: the product couldn’t stop shipping. The redesign had to happen in parallel with new features being built. Every structural decision I made had to be defensible to engineers actively building on top of it.
The first version didn’t work. And that was okay.
When I joined, the editor already had a design. It wasn’t built carelessly, it was built fast by a team trying to ship. The logic made sense on paper: show everything, lay it out in a table, source text left, translation right, timestamps in the middle.
Everything was visible. Nothing was hidden. That was the philosophy.
There was even a timeline. It showed source and target audio tracks against a ruler, but it was decorative. It couldn’t be scrubbed. No waveform. Clicking a position didn’t jump to that moment. For a product where subtitle timing is critical, that was a critical gap.
In practice it didn’t match how teams worked. New users froze. Experienced users hesitated before actions they’d done before. Everyone spent more time navigating than editing.
Everything surfaced at once. No visual hierarchy. Language selection buried in a dropdown. Timeline present but non-functional.
What we learned from enterprise teams.
I spoke with localization managers, operations leads, content strategists, and media teams. Professionals under pressure, with real deadlines and no tolerance for uncertainty. The consistent finding wasn’t “we need more features.” It was something harder to fix: teams couldn’t build a reliable mental model of how the product worked.
“I can see everything, but I still don’t understand what I’m supposed to do first.”
The editor treated all actions as equally accessible at all times. No visual signal of where a user was in their workflow or what a logical next step might be.
The editor treated all actions as equally accessible at all times. No visual signal of where a user was in their workflow or what a logical next step might be.
It was unclear whether an action would affect a single card or the entire project. Teams avoided making changes at scale because they couldn’t predict what would propagate.
It was unclear whether an action would affect a single card or the entire project. Teams avoided making changes at scale because they couldn’t predict what would propagate.
Voice controls, AI tools, and subtitle styling were all visible during basic transcript review. Users were doing extra work just to filter out what wasn’t relevant.
Voice controls, AI tools, and subtitle styling were all visible during basic transcript review. Users were doing extra work just to filter out what wasn’t relevant.
Teams had low confidence that what they’d edited would match the final exported video. No way to verify before committing to a render.
Teams had low confidence that what they’d edited would match the final exported video. No way to verify before committing to a render.
Every session had the same shape: open the editor, stare at it, figure out what
it’s asking. The problem wasn’t missing features. It was that the system had no
visible logic. The AI was doing its job. The interface wasn’t helping users understand
what it had done, or what to do next.
Every session had the same shape: open the editor, stare at it, figure out what it’s asking. The problem wasn’t missing features. It was that the system had no visible logic. The AI was doing its job. The interface wasn’t helping users understand what it had done, or what to do next.
The old editor — a detailed teardown.
Before redesigning anything, I needed to be precise about what was broken and why. “The interface is confusing” is not a design brief. This is what I found.
Every problem had a specific solution.
I mapped each problem to a design principle, then a concrete change. The goal wasn’t to add features. It was to make the existing capability legible.
8 toolbar actions, equal weight, no grouping
4-tier IA: actions organised by frequency and intent
No distinction between segment vs. project actions
Explicit scope indicators on every action
Languages buried in dropdown, no status visible
Persistent context panel — all active languages always visible
Transcript and video preview disconnected
Active card synced to video playhead — one click, both update
Timeline present but non-functional
Fully interactive timeline — scrubbable, waveform visible, always live
Card options not reliably anchored to active card
Options rebuild on every card selection — always in sync
Export outcome unpredictable
Live preview + clear export paths — see before you commit
8 toolbar actions, equal weight, no grouping
No distinction between segment vs. project actions
Languages buried in dropdown, no status visible
Transcript and video preview disconnected
Timeline present but non-functional
Card options not reliably anchored to active card
Export outcome unpredictable
4-tier IA: actions organised by frequency and intent
Explicit scope indicators on every action
Persistent context panel — all active languages always visible
Active card synced to video playhead — one click, both update
Fully interactive timeline — scrubbable, waveform visible, always live
Options rebuild on every card selection — always in sync
Live preview + clear export paths — see before you commit
The stakeholders wanted more features. I wanted to fix the structure.
When I presented the research, the first response was: “Let’s take more features live.” More AI tools. More export options. A command palette. The instinct made sense. The product was growing and adding features looks like progress.
But adding more to an interface users already couldn’t navigate was going to make the core problem worse while looking like improvement.
I played back recordings of users hesitating, staring at the toolbar, clicking the wrong thing. The argument wasn’t aesthetic. It was about confidence. Enterprise teams won’t scale on a tool they don’t trust. The path to more features working was getting the foundation right first.
They agreed to run the restructure alongside feature development, not instead of it.
Three directions. Two dead ends. One that worked.
I explored three fundamentally different ways of restructuring the editor before arriving at the final direction. Two of them taught me important things. Neither of them shipped.
The moment the IA framework clicked.
Every action in the editor was mapped against two axes: how often it’s used, and how much deliberate intent it requires. Four tiers. Every control has a principled home, not based on available space, but on how people actually work.
The redesigned editor — calm on the surface, capable underneath.
Same product. Every feature still present. Context panels on the left, transcript cards in the centre, video preview on the right, a fully interactive timeline at the bottom. Four zones, each with one clear responsibility.
The active card is always synced to the video playhead. Click a card, the video jumps to that segment. The timeline is live and scrubbable with a waveform. Context panels surface exactly what’s relevant to the current task, not everything at once.
Context panels left. Transcript cards centre. Video preview right. Persistent interactive timeline bottom. Four zones, one mental model.
Context panels — the actual solution to the toolbar problem.
The original approach put everything in one place. Context panels do the opposite. They surface the right controls at the moment the user needs them, based on what they’re currently doing. Each panel is a focused set of related controls around one type of task, not a dump of everything the system can do.
Editing a transcript card? You see AI rewrite options, timing for that segment, and audio settings for that language. Not the export settings for the whole project. The panel responds to where the user is, not to what exists in the system.
Six focused panels, each anchored to a specific decision context. The right controls at the right moment.
Subtitles as a dedicated workspace.
Subtitle creation involves multiple layers: line length (CPL), timing, visual style, on-screen behaviour. In the original editor these were scattered across the toolbar and side panels. Typographic decisions in one place, timing in another, style in a third, with no way to see all three together.
The redesign treats subtitles as their own workspace. Switch to subtitle mode and you get CPL tracking, timing controls, preset styles, and a live video preview all visible at once.
Structuring Subtitle Controls into clear layers
Subtitle configuration was organized into three layers — Basic styles, Preset styles, and Behavior settings — each reflecting a different type of decision made while editing subtitles.
Basic styles handle core typographic adjustments such as font, spacing, alignment, and color. Preset styles offer faster visual starting points, with the option to refine details when needed. Behavior settings focus on how subtitles appear over time and space, including line length, delay, and screen position.
Separating these concerns helps changes stay predictable, allowing teams to adjust one aspect of the subtitle without unintentionally affecting others.
What testing revealed — including what didn’t work.
I tested with 8 to 12 enterprise users in structured prototype sessions with real tasks. The signal was clear: the new structure was easier to understand and faster to work with. Two moments stood out.
The moment that made the whole thing worth it.
A localization manager was working through the language validation task. She clicked into the languages panel, scanned the list, and said out loud: “Oh, so that’s where the languages are.” Not frustrated. Just satisfied. That’s the sound of a mental model forming correctly. She spent the rest of the session working without pausing to figure out what to click.
The thing that didn’t work — and how we fixed it.
The Translate button on each transcript card was positioned between the source and translation columns. Visually logical, invisible in practice. Users edited the source text, looked for a way to re-run the translation, and missed it entirely because it looked like a separator, not a clickable action.
We moved it to the bottom of the card, gave it more visual weight, and made it only activate when the source text had changed since the last translation. That one change reduced translation errors significantly in the second round of testing.
These insights come from prototype testing with 8–12 enterprise users, not live product analytics. The signals were directional and consistent across sessions — pre-launch validation, not post-ship measurement.
Impact — what prototype testing showed.
In structured prototype testing sessions with enterprise teams, users completed localization tasks significantly faster and with fewer navigation errors than with the original editor. These are directional signals, consistent across sessions but not yet backed by live product analytics. Here’s what the testing showed.
Teams moved through localization workflows with significantly fewer pauses the tier structure meant the right action was always where they expected it.
Teams moved through localization workflows with significantly fewer pauses the tier structure meant the right action was always where they expected it.
The persistent context panel replaced a dropdown that required multiple clicks — teams could check the status of all active languages in one glance.
The persistent context panel replaced a dropdown that required multiple clicks — teams could check the status of all active languages in one glance.
Users triggered the wrong action and had to undo far less often once scope was made explicit in the interface.
Users triggered the wrong action and had to undo far less often once scope was made explicit in the interface.
New users grasped the editor’s structure much earlier in their first session — the mental model formed without explanation.
New users grasped the editor’s structure much earlier in their first session — the mental model formed without explanation.
New designers shipped production-quality UI in their first week — previously a
multi-week onboarding curve.
New designers shipped production-quality UI in their first week — previously a multi-week onboarding curve.
“Super easy to understand compared to the previous version — and faster task completion.”
These numbers come from structured prototype testing sessions with 8–12 enterprise users. They represent directional signals from pre-launch validation, not post-ship product analytics.
What I actually learned.
Clarity is a feature. It just doesn’t show up in a roadmap.
Every stakeholder conversation started with “can we add more?” The research kept saying “we can’t find what’s already there.” Those aren’t compatible problems to solve at the same time. Clarity isn’t a nice-to-have. It’s what makes every other feature usable. I’d have made that case earlier, with user recordings as evidence, before a single screen was discussed.
The first version taught me more than the research did.
The existing editor wasn’t bad design. It was honest design that revealed its assumptions under pressure. The table layout made sense for one language and one user type. It stopped making sense when enterprise teams brought multiple languages, multiple stakeholders, and high-stakes outputs. Reading those failures carefully was more valuable than any competitive audit.
Two failed directions aren’t waste. They’re proof.
The toolbar reduction and the tabbed flow both taught me something research alone couldn’t: the problem wasn’t visibility or sequence in isolation. It was the combination of both, filtered through intent. I wouldn’t have arrived at the tier framework without first proving why the simpler solutions didn’t hold.
Test earlier than feels comfortable.
The Translate button problem was fixable in prototypes and would have been expensive in production. The localization manager who said “oh, so that’s where the languages are” gave me feedback I couldn’t have gotten from looking at my own design. Next time I’d put half-finished concepts in front of users much sooner.
Complex products don’t fail because users can’t find features. They fail because users can’t understand the system.
Reach out and get in touch
Contact me and let’s create magic
with design. amithcmyk@gmail.com
OR find me here
