
Designing App Navigation for the 90%, Not the Loudest 10%
Navigating stakeholder bias to design a navigation experience that worked for everyone.
Company
SYNAPSIS
Year
Q3 2025
Role
Product Designer
Team
Front-end engineer, me
Key Result
Reframed the product direction
We challenged the assumption that personalization was the best solution, and aligned stakeholders on a design that puts the 90% first while still supporting the 10%.
Secured the next project phase
The client signed the contract for the next phase.
The Start of My Initiative
The client wanted to bring their 8 apps together into one super app for 1,300 employees, with shortcuts to each app. During the concept presentation, they asked us to add personalization to the app list. The list would reorder itself based on each employee's most used apps, so the frequent ones stay in front. Their reason was to avoid overwhelming users with too many apps.
My Role
- Defined the navigation and information architecture of the super app
- Segmented users based on their app access, and used it to challenge the personalization request
- Designed the grid, sorting and favourites patterns, and presented the direction to the client's stakeholders
- Built the navigation in code with Next.js, Base UI, Motion and Tailwind CSS
Exploring Design Direction
The concern about overload was valid, but it came from one group of users. I looked at the HR org chart and each role's access in the client's apps, and split users by how many apps they can use.
- Managers, around 10%, can access all 8 apps. They were the ones in the room, and the ones who felt overwhelmed.
- The other 90% only have 2 to 3 apps.
For the 90%, an app list that reorders itself doesn't really help. With 2 or 3 apps there's nothing to sort, and icons moving around between visits only make the screen harder to learn. The solution had to work for both groups, including users who were never part of the stakeholder discussions.

From there we set two directions:
Seamless
For users with many apps, so the list still feels manageable and quick to navigate.
Efficient
For users with few apps, without adding complexity they don't need.
Constraint That Shaped The Decision
The super app didn't exist yet, so we had no usage data. Every decision had to be based on access data and design reasoning.
What We Tried First
Besides the client's personalization idea, my first experiment was a separate favourites section on top of the full app list. It worked well for managers, but for users with only 2 or 3 apps the same apps showed up twice, and the section wasted a lot of space. So I merged favourites into the main grid instead.

Solution Overview
Leveraging spatial memory with grid layout
Each app shortcut stays in a fixed position in the grid. After using it a few times, users can find an app by where it is, without actively searching for it.

Customization over personalization
Instead of automatic personalization, we proposed customization to the client. Users decide how the list is sorted, and the layout only changes when they change it. Because they made the change themselves, they know why things moved and don't need to relearn the interface.
Managers get control over a long list, and the default stays simple for everyone else.

Integrated favourites section
Pinned apps move to the front of the same grid instead of sitting in their own section. Users with 3 apps see one short grid, and users with 8 apps see their favourites first. The layout stays efficient for both groups and scales with the number of apps.

Outcome
I presented the segmentation in a meeting with the client's stakeholders, and they agreed to go with customization instead of personalization. They later signed the contract for the next phase. We couldn't gather proper usage data at this stage, so the direction was approved based on the reasoning behind it.
Building It In Code
I built the navigation as a reusable component with Next.js, Base UI, Motion and Tailwind CSS, including pinned apps, sorting and drag-and-drop ordering. I also wrote custom rules for the AI agent so it reads the exact Figma properties and motion values, instead of guessing with default CSS values.
Building it in code taught me two things. A working prototype makes it faster to learn from users, because they can react to real dragging and sorting. And reusable code makes the handoff faster and more pixel perfect, since engineers start from the real component instead of reading a spec.
What I'd Do Differently
I'd add analytics from day one, to check if the 90% really ignore sorting and how managers use it. That way the next phase can be decided with data.