PNC | Dashboard Modernization
- Replaced a decade-old static homepage with a customizable, widget-based dashboard.
- Defined a scalable widget framework used by 24+ PINACLE product teams.
- Validated layouts and interactions through 2 sessions, 12 participants, with 4 roles.
The user moment
A treasury manager logs in to get situational awareness—cash position, exceptions, and approvals—before cutoff times and meetings. In the legacy experience, key signals and high-frequency tasks were scattered across services, forcing unnecessary navigation. The goal was to make the first 60 seconds on PINACLE feel immediately relevant: see what matters, then act.
OVERVIEW
The PINACLE dashboard hadn’t been modernized in over a decade, leaving clients with a static homepage that didn’t prioritize day-to-day tasks. I led a redesign to create a task-first, customizable entry point—built to scale across dozens of services without fragmenting the experience.
- A configurable, widget-based dashboard tailored to different roles and workflows
- A shared widget framework so 24+ product teams could contribute consistently
- A validation loop through client sessions and PINACLE User Group testing
ROLE / TEAM
As UX Manager / Design Lead for the PINACLE Dashboard program, I:
- Defined the widget governance model + “widget contract” so 24+ product teams could contribute consistently.
- Participated in client validation across multiple rounds (interviews + live prototype testing at PINACLE User Group).
- Directed and partnered with two lead designers (within a 7-designer UX org) to align widget work across dozens of product teams.
- Established a definition of ready for widgets (states, data needs, edge cases) to reduce late-stage rework.
- Produced key artifacts hands-on (north star flows, prototypes, interaction requirements) to unblock engineering.
CONTEXT / PROBLEM
The legacy dashboard was antiquated, rigid, and cluttered:
- One-size-fits-none: limited customization for very different roles
- Low signal-to-noise: high-value tasks (approvals, exceptions, alerts) are hard to spot
- No consistency: insights and widgets vary across services with no shared model
- Outdated experience: UI didn’t reflect PINACLE’s modern capabilities
Design a flexible, modern dashboard that:
- Scales across dozens of services and evolving use cases
- Balances insights + action (data visualization + clear task prioritization)
- Enables customization without complexity
- Can be maintained by multiple product teams + governance over time
RESEARCH / DISCOVERY
We ran client interviews, workflow walkthroughs, and prototype testing to understand what corporate users expect from a dashboard—and to validate a widget model that can scale across PINACLE services. We also tested iterative prototypes with clients at the annual PINACLE User Group to confirm layout patterns, customization behavior, and widget state expectations.
What we learned:
- Approvals and exceptions must be fast to find (even if final review happens in the full service flow)
- Balances + key indicators need to be visible at a glance without digging through reports
- Roles vary enough that customization is required, but the model must stay simple and predictable
- Trust comes from freshness + clarity: clear labels, consistent widget behavior, and well-defined states (loading, empty, error, no access)
- Many users want a quick “approval inbox” view, but complete approvals in the full service for review + confidence.
DESIGN / SOLUTION
We designed a task-first, customizable dashboard by separating “insight” from “action” and standardizing how widgets behave across services.
- Metrics & Insights (top strip): Always-visible health indicators for quick awareness.
- Main Area: Large, analysis-heavy widgets (balances, reporting, transfers).
- Sidebar: Small, actionable items (approvals, exceptions, contacts, favorites).
- Widget Library: Service-based catalog to add/remove widgets without clutter.
Responsive by Design
Designed to scale down cleanly for mobile use. Widgets stack and resize intelligently, navigation stays usable, and the most important items—approvals, exceptions, and core balances— remain accessible for quick check-ins between meetings or while away from a desk.
TESTING
We validated that clients could understand personalization, trust widget data, and use the dashboard confidently across roles—then iterated based on what we observed.
Method
- Internal validation with design + product teams to refine workflows, edge cases, and widget states.
- Client validation at PINACLE User Group sessions using low-fidelity prototypes and guided tasks.
- Iterative testing to balance customization, simplicity, and performance.
Key takeaways
- Validated: The layout zones + widget model were easy to understand.
- Changed: Improved personalization entry points and clarified feedback/saving.
- Changed: Tightened widget sizing/constraints to make the grid feel predictable.
Customize your dashboard in 5 steps
These updates were rolled into the widget contract / interaction requirements to keep implementation consistent across teams.
IMPLEMENTATION / SCALABILITY
To scale a customizable dashboard across 24+ PINACLE services, we established a shared framework that lets teams ship independently while preserving a consistent client experience.
- Dashboard Shell: standardized layout zones, drag/resize rules, and global states for a consistent base experience.
- Widget Contract + shared components: required header structure, states (empty/loading/error), accessibility rules, and action patterns to keep widgets predictable.
- Delivery kit for teams: interaction requirements + widget workflow docs + reference implementations so product teams can build faster with fewer UX regressions.
- Scale controls: governance/versioning for the contract + telemetry (adoption, edits, failures) to guide roadmap and reduce support load.
IMPACT
- Validated with clients: Tested dashboard concepts in 2 PINACLE User Group sessions with 12 participants across 4 roles, confirming core layout, customization, and priority-action patterns.
- Faster access to critical work: Surfaced high-frequency task widgets (approvals, exceptions, alerts), reducing reliance on deep navigation for daily actions.
- Built to scale: Established a widget framework and interaction contract enabling consistent contributions across 24+ product teams.
- Role-aware first load: Designed the foundation for role-based default dashboards, improving day-one relevance and reducing initial setup friction.
Proof signals (qualitative):
- Observed reduced navigation hopping during early-session tasks, as users could identify priority actions directly from the dashboard.
- Faster orientation in the first 60 seconds of use, with clearer understanding of where to start and what required attention.
- More predictable implementation outcomes across teams due to shared widget constraints, zones, and definition-of-ready standards.
- Fewer late-stage UX escalations as teams aligned earlier on layout boundaries and interaction expectations.
(Directional and qualitative due to platform scale and regulatory constraints.)
REFLECTION
This project required not just design innovation, but orchestration across dozens of teams and stakeholders. My role was to keep the vision unified, ensure client voices were consistently represented, and give developers clear requirements for complex workflows.
Leading this effort reinforced the importance of balancing strategic direction, hands-on design work, and cross-functional facilitation in large-scale enterprise design programs.
- Orchestrate, dont dictate: Align dozens of teams around shared contracts and guardrails.
- Create clarity in ambiguity: Define ownership, states, and expectations before development begins.
- Stay close to users: Validate decisions continuously through client sessions and testing.