Overview
A Danish telecom provider was simultaneously expanding its customer portal and self-service platform, serving more than 800,000 customers.
The roadmap was growing, but design delivery was becoming a bottleneck. New features required multiple workshops, concept iterations, reviews and approvals before reaching development.
I joined the project to understand where that friction was coming from and help the team increase delivery capacity without increasing headcount — introducing governance and roadmap alignment that later improved concept production by 32% and cut end-to-end delivery cycles by 50%.
Finding the Bottleneck
My initial investigation focused on the team’s workflow.
After auditing how features moved from discovery to handoff, I found a recurring pattern: the design system covered common scenarios, but complex interactions were still being solved from scratch.
Designers frequently encountered similar problems across eCare, ecommerce flows and operational dashboards, yet those solutions rarely became reusable assets.
The result was predictable:
- duplicated work
- inconsistent patterns
- longer review cycles
- growing pressure on delivery timelines
At the same time, the design system evolved independently from the product roadmap. New requirements appeared faster than the system could support them.
Building a System That Could Evolve
I worked directly with product teams and client-side designers in Copenhagen to connect roadmap planning with design system evolution.
Instead of reacting to new requirements feature by feature, we established a process that allowed the system to grow proactively alongside upcoming initiatives.
To accelerate implementation, we adopted Material UI’s token architecture as the foundation for a new structure.
My contribution included:
- token architecture
- component taxonomy
- documentation standards
- governance rules
- contribution workflow
When designers encountered a new interaction pattern, they could design locally first. If the solution showed reuse potential, it would be reviewed, documented and promoted into the shared system.
This allowed the design system to evolve continuously without becoming bloated with one-off solutions.
Scaling Without Slowing Down
The platform was already live and actively shipping new features.
A complete redesign of the system was not an option.
Every improvement had to coexist with ongoing product development, active roadmaps and existing handoffs.
Instead of rebuilding everything at once, we introduced changes incrementally, validating each batch before moving forward.
This approach reduced disruption while allowing the system to mature alongside the product itself.
Documentation turned those decisions into something designers could reuse without starting from a blank frame.
Slot-based layouts made complex portal patterns configurable instead of one-off.
The same modular patterns showed up in the customer portal — from product detail configuration on desktop to listing and detail flows on mobile.
Results
32% faster concept production
By auditing existing components, mapping future roadmap requirements, and reorganizing the design system around reusable patterns, designers were able to create and validate new concepts significantly faster.
50% faster end-to-end delivery
A clearer component structure, stronger governance, and improved collaboration between design and engineering reduced friction throughout the entire delivery cycle—from feature request and concept creation to validation, approval, and developer handoff.
Additional outcomes:
- Improved consistency across customer-facing products
- Reduced duplicate work and component fragmentation
- Faster onboarding for designers joining the team
- Better alignment between design, engineering, and product stakeholders
- Design system still actively used across the organization
Reflection
This project changed how I think about scale.
The biggest challenge wasn’t creating components. It was creating a decision-making framework that could evolve alongside the product.
Once the roadmap and design system started informing each other, the team spent less time rebuilding solutions and more time solving new problems.