Enabling Self-Serve Access Requests at Scale.
Rethinking the access request journey to reduce operational dependency and enable a scalable, self-serve system.
NSS (NielsenIQ Service Suite) is a help and support platform used by internal teams and client users across NielsenIQ products. It enables users to find help content, raise tickets, and request access to products, datasets, or features.
An access request allows users to gain permissions based on their role and needs. The current experience of raising a ticket involved multiple redundant steps and heavy reliance on support teams, making it inefficient and difficult to scale.
Company
NIQ
Role
Lead UX Designer
Team
1 Lead, 1 Researcher, 1 Designer
Timeline
~3 months (2026)
Executive Summary.
Redesigned the access request experience into a structured self-service system, reducing redundant steps and dependency on support teams.
The Approach
Mapped the existing workflow to identify redundancies and defined a simplified model focused on streamlining request creation, enabling bulk actions, and improving clarity across the process.
Outcome
Established a clear system direction and a redesigned access request flow. Development is currently in progress.
Context & Challenge.
The access request workflow spanned multiple systems and teams, requiring repeated handoffs and manual intervention at each step.
A typical flow involved:
- Users raising a ticket in NSS
- Support teams recreating the same ticket in GTS (Global Tech Support)
- Backend processing through MSD (Microsoft Dynamics)
- Manual communication back to the user
Each step introduced redundancy and dependency, resulting in slow turnaround times, duplicated effort, and limited visibility into request status.
Shifting from support-driven to self-service
The workflow was not just inefficient, it was structurally dependent on support teams to move requests forward. To address this, we defined a simplified self-service model that reduces handoffs and enables end-to-end request handling within NSS.
Key Challenges.
- —Forms were difficult to understand due to technical and internal jargon
- —Multiple tickets were required for multiple users
- —Errors were unclear and difficult to recover from
- —No standardized process across teams
- —Heavy reliance on manual work and workarounds such as Excel
- —Duplicate effort across NSS and GTS
- —High operational cost due to support dependency
- —Redundant systems to maintain
- —Limited scalability
The Process.
4.1 Research
We conducted 20+ interviews with internal support teams responsible for managing access requests.
The goal was to understand real workflows, uncover inconsistencies, and identify opportunities for simplification.
A key insight was that there was no standardized way of processing requests. Each team had developed its own methods.
4.2 Synthesis
We mapped the end-to-end journey of access requests, capturing user actions, system interactions, pain points, and opportunities.
This helped us identify which parts of the system had the highest impact and where intervention would be most effective.
4.3 Alignment Workshop
We brought together stakeholders across product, engineering, tech enablement, architecture, and UX.
The workshop included:
- Clustering research insights
- Dot voting on key problems
- Prioritization using an impact vs effort matrix
- Rapid ideation through Crazy 8s
This helped align the team on what to solve and what to defer.
4.4 Scoping the Problem
Given the complexity of backend systems and varying workflows across teams, we narrowed the scope to:
- Ticket creation experience
- Access requests for Discover
This allowed us to focus on a high-volume use case while building a foundation for future expansion.
Key Decisions.
Balancing Speed and Guidance
The system needed to serve two very different user types:
- Internal teams creating hundreds of tickets
- External users creating tickets occasionally
We balanced this by:
- Grouping related fields logically
- Using tooltips for contextual help
- Showing complexity only when needed
- Providing inline validation and actionable feedback
Reducing Cognitive Load
We simplified the form by:
- Removing unnecessary fields
- Using system data wherever possible
- Rewriting labels to be more intuitive and user-friendly
Enabling Scale
We introduced support for:
- Bulk user access requests
- File upload for user data instead of manual entry
This directly addressed one of the biggest friction points.
Moving Towards a System-Driven Model
We redefined the flow to:
- Remove dependency on support teams
- Enable automatic fulfillment through MSD
- Introduce approval workflows where needed
- Automate communication to users
Final Solution.
Guided Entry Point
We introduced a clear and structured entry point that helps users identify their need quickly.
Simplified Ticket Creation
The form was redesigned to be intuitive, flexible, and efficient. Users can:
- Provide only necessary information
- Upload files for bulk requests
- Expand fields only when needed
Clear Feedback and Confirmation
We improved system feedback to ensure users understand what happens next. Users receive confirmation along with guidance on next steps and access instructions.
Outcomes & Impact.
With development in progress, the following represent expected outcomes.
- Simplified ticket creation experience
- Reduced effort for bulk access requests
- Elimination of redundant steps
- Shift towards standardized workflows
- Reduced dependency on support teams
- Improved operational efficiency through automation
- Scalable foundation for handling additional request types
Reflection.
This project reinforced the importance of system thinking in complex enterprise environments.
Not all identified problems were solved through this initiative. Instead, we focused on high-impact areas that could be realistically implemented within constraints.
It also highlighted that clarity of direction is more valuable than attempting to solve everything at once.
By aligning stakeholders early and defining a scalable system model, we created a strong foundation for future improvements.