Ioan Sameli
One codebase, three themes
All work

Building cross-functional processes

Connecting a three-person product team directly with five engineering teams, and cutting the design-to-release cycle from five sprints to three.

Facts
Company
Rakuten
Role
Product & UX designer, Front-end engineer
Timeline
2018–2021
Duration
About a year to put the processes in place
Team
Product and design team of 3, ~40 engineers in 5 teams
Tools
Jira, Figma, HTML/CSS
5 → 3
sprints from design to release
3 → 1
handoffs between designer and engineers
10–20
issues caught per feature before QA
Contents

At a glance

  • Designs used to pass through two managers before reaching engineers, a game of telephone replaced with direct collaboration
  • The typical feature went from about five sprints to three, from the start of design to release-ready
  • A design QA step catching 10–20 issues per feature before formal QA
  • Rolled out over about a year, one change at a time, each one solving a real problem

Overview

Rakuten is one of Japan's largest ecommerce platforms. BOSS is its order management system for online sellers: it brings orders from marketplaces such as Rakuten, Amazon and Yahoo! Shopping into one back office and automates the work of processing them. More than 8,500 businesses use it today.

From 2018 to 2021, I was a UX designer on BOSS's product and design team, a team of three, while five engineering teams relaunched the product on a new tech stack. I quickly found that the biggest obstacle to a good product wasn't design or engineering on their own: it was the space between them. Over about a year, I introduced a series of processes that connected our team directly to the five engineering teams, about 40 engineers in total, and changed how features moved from idea to release.

The product design work itself is covered in the BOSS redesign case study.

Problem

One day, browsing the production site, I came across a feature I had designed months earlier. It had shipped without my knowledge, with a broken layout and plenty of bugs.

That wasn't bad luck; it was the system working as designed. The organisation had two separate groups: our small product and design team, and five engineering teams under their own manager. They worked in silos, with no direct contact. A design travelled from me to my team's manager, then to the engineering manager, then to the engineers. Questions made the same trip back, or were answered along the way by a manager who might not know the answer. It was a game of telephone, and it showed in four ways:

  1. Designer
  2. to Product team manager
  3. to Engineering manager
  4. to Engineers
  5. to QA
  6. to Production
  1. 1
    At Product team manager: Lost in translation
    Engineers received designs without context. Specs were written by non-technical managers working from second-hand understanding, and sometimes there were no specs at all.
  2. 2
    Nothing reached Designer from Engineers: No feedback loop
    After handing off a design, I heard nothing until the feature reached testing, several sprints later, often riddled with errors that a single conversation would have prevented.
  3. 3
    At Engineers: Isolated engineering teams
    The five teams rarely talked to each other either, so they ended up implementing the same components several times over.
  4. 4
    At QA: No UX quality gate
    QA focused on functionality, not on visual or UX quality, so pages with broken UI reached production, and getting them fixed was hard once engineers had moved on.

Coming from cross-functional teams, and with a background as a front-end engineer, I knew how much smoother this could be.

Role & process

Simulation of the feature I found in production, shipped with a broken layout.

I treated the process like a product: identify the pain point, propose a solution, explain how to roll it out and how it would help. The broken feature I found in production started that conversation with management, and the first changes came out of it: a design QA step before formal QA, and meetings that brought designers and engineers into the same room.

All five engineering teams reported to the same manager, who took the suggestions seriously, and my own manager was open to trying practices I had seen work elsewhere. Over about a year, the changes came one at a time, and were welcomed rather than resisted, because each one solved a problem people already felt.

Solution

Each problem got its own answer:

  1. Lost in translation
  2. to Direct handoff meetings, and specs that answer the questions upfront
  1. No feedback loop
  2. to Engineers involved before and during development
  1. Isolated engineering teams
  2. to Shared components and standards, and a weekly all-hands
  1. No UX quality gate
  2. to Design QA before formal QA, and a standing UX backlog

Lost in translation → direct handoffs and complete specs

The biggest change: no more relay. Every handoff became a meeting between the product team and all the engineers of the team building the feature. We presented the feature first-hand, explained the reasoning behind it, and answered questions on the spot. Once that contact existed, engineers no longer hesitated to reach out to the designer directly instead of going back through the chain.

Before 3 handoffs
  1. Designer
  2. to Product team manager
  3. to Engineering manager
  4. to Engineers
After 1 handoff
  1. Designer
  2. with Engineers

A design used to reach engineers through two managers, and questions made the same trip back. Handoff meetings replaced the relay with a direct conversation.

Specs got the same attention. Engineers used to fill gaps in them on their own, and every gap filled differently became an inconsistency. I created checklists and templates so every Jira ticket answered the easily forgotten questions upfront.

What every spec had to answer

The details that most often went missing from specs, and the checklist that meant engineers no longer had to guess.Side quest

The checklists covered the details that most often went missing, and that engineers otherwise had to improvise:

  • Validation rules for every form field
  • Every possible error message, written out
  • Empty states, designed rather than improvised
  • How to handle long text that doesn't fit its container

Each answer written upfront was a decision engineers no longer had to make alone.

No feedback loop → engineers involved early and throughout

  1. Kickoff
  2. to Design
  3. to Handoff
  4. to Build
  1. 1
    At Kickoff: Feature kickoffs
    For large, complex features, engineers joined before the design was settled, so constraints and data questions surfaced early instead of mid-build.
  2. 2
    At Design: Weighing in on the options
    I usually explored three solutions (a quick win, an ambitious ideal and a balanced recommendation). Engineers reviewed them with us, so the trade-offs took feasibility and engineering effort into account from the start.
  3. 3
    From Design to Build: Weekly design and engineering syncs
    For larger features, both before and after handoff. Before, engineers could weigh in early ("Can we build this? Do we have that data?"); after, we tracked progress and resolved questions as they came up.

Isolated engineering teams → shared foundations and visibility

  • Components built once, by design. Instead of each team rebuilding components from static designs, our team built them once in a shared UI library, and handed off designs as working HTML. The BOSS design system case study covers both in depth.
  • Interaction design guidelines and front-end coding conventions, so every team followed the same rules for details like error messages, and code from five teams read like one codebase
  • A weekly all-hands for the product team and all five engineering teams to present their work, so engineers knew what was coming in future sprints instead of being handed anonymous designs

No UX quality gate → design QA

  • Design QA before QA: I made this review by the product team a mandatory step before any feature reached formal QA. We typically caught 10 to 20 issues per feature, while they were still cheap to fix and the engineers were still on the project.
  • A standing UX backlog: small UX bugs and improvements spotted outside of feature work went into a prioritised list of Jira tickets, which engineers could pick up whenever they had capacity. Small issues got fixed instead of being forgotten.

Outcome / impact

Before About 5 sprints, roughly 10 weeks
After About 3 sprints, roughly 6 weeks

A typical feature, from the start of design to release-ready. Each block is one two-week sprint.

  • From about five sprints to three: with two-week sprints, a typical feature went from roughly ten weeks to six between the start of design and release. Larger features, with database changes, extended research or major new components, still took longer. The extra meetings paid off in less rework and fewer bugs, and the shared UI library sped up development considerably.
  • From three handoffs to one: designers and engineers talked directly, with no managers relaying the message
  • 10–20 issues caught per feature in design QA, before formal QA and before reaching production
  • Components built once: our team built components in the UI library, instead of each engineering team reconstructing them from static designs
  • A consistent experience: every piece of front-end UI came from the shared library, and direct communication and complete specs kept it as designed
  • Less frustration on both sides: engineers got answers first-hand, and designers saw their work shipped as intended
  • One team instead of two: product and engineering went from having no contact to working side by side. The best side effect: real friendships, team lunches, and colleagues I still keep in touch with.

Reflection

The few retrospectives I joined were some of the most useful hours of the project: engineers could tell us directly how to improve the process. But they were occasional, because five teams' retrospectives were too many to attend. Next time, I'd set up a dedicated cross-team retrospective, monthly for example, bringing the product team and all engineering teams together, so feedback on the process doesn't depend on chance.