UX Capabilities Handbook 101
A comprehensive guide to every UX concept, method, process, and tool required for the UI/UX Manager, Neo Platform (Capgemini) role. From foundations to Figma mastery, design systems governance to interview preparation — everything you need in one place.
UX Fundamentals
The foundational principles that every UX professional must internalize. These are non-negotiable in any technical interview and form the bedrock of all design decisions.
What is User Experience?
User Experience (UX) encompasses every aspect of end-users' interaction with a company, its services, and its products. The term was coined by Don Norman at Apple in 1993. UX is not just about screens — it spans the entire journey a user takes, including their emotions, perceptions, and responses before, during, and after use.
The 5 Planes of UX (Jesse James Garrett)
Core UX Principles (Pioneer Reference)
User-Centered Design
Design decisions driven by user needs, goals, and contexts through iterative research and testing. Originated by Don Norman at UCSD and formalized in ISO 9241-210.
Usability
Effectiveness, efficiency, and satisfaction with which users achieve goals. Measured through learnability, memorability, errors, efficiency, and satisfaction (Jakob Nielsen).
Accessibility
Designing products usable by people of all abilities. WCAG 2.2 AA is the current enterprise standard. Perception, operability, understandability, and robustness (POUR).
Desirability-Viability-Feasibility
Great products live at the intersection of what users want (desirable), what the business needs (viable), and what technology enables (feasible). The IDEO innovation sweet-spot.
Design Thinking & Process Frameworks
The structured methodologies used to solve complex design problems. As a UX Manager, you orchestrate these processes across multiple workstreams.
IDEO's Design Thinking (5 Stages)
Other Key Frameworks to Know
Lean UX
Build-Measure-Learn cycles with minimum viable experiments. Focuses on outcomes over outputs. Perfect for Agile/SAFe environments like Neo. Key text: Lean UX by Jeff Gothelf.
Design Sprints (Google)
5-day structured process: Map → Sketch → Decide → Prototype → Test. Created by Jake Knapp at Google Ventures. Ideal for rapid problem-solving on Neo features.
Jobs-to-be-Done (JTBD)
Users "hire" products to accomplish a job. Focus on the outcome, not features. Created by Clayton Christensen. Powerful for prioritizing Neo platform features.
User Research Methods
Research is the foundation of evidence-based UX. As a UX Manager, you need to know which methods to deploy at each stage and how to synthesize findings into actionable design decisions.
Research Methods by Project Phase
| Phase | Goal | Methods | Deliverable |
|---|---|---|---|
| Discover | Understand user needs & context | Stakeholder interviews, contextual inquiry, competitive analysis, analytics review | Research report, personas, empathy maps |
| Define | Frame the problem | Affinity mapping, card sorting, journey mapping, HMW workshops | Problem statements, journey maps, opportunity areas |
| Develop | Generate & validate concepts | Design studios, rapid prototyping, concept testing, co-design | Wireframes, prototypes, design concepts |
| Deliver | Validate before launch | Usability testing, A/B testing, accessibility audit, heuristic evaluation | Test reports, iteration recommendations, go/no-go findings |
| Post-Launch | Measure & improve | Analytics, NPS/SUS surveys, feedback loops, diary studies | Insights backlog, iteration roadmap |
Information Architecture (IA)
The structural design of shared information environments. IA determines how content is organized, labeled, and navigated — critical for a complex enterprise AI platform like Neo.
Organization Systems
How information is categorized: hierarchical, sequential, matrix, database. For Neo: feature-based hierarchy with role-based access layers.
Labeling Systems
How information is represented: headings, links, navigation labels, icons. Consistency of labeling across Neo's features is a UX Manager responsibility.
Navigation Systems
How users browse: global nav, local nav, contextual nav, breadcrumbs, utility nav. Critical for enterprise platforms with deep feature hierarchies.
Search Systems
How users search: query interfaces, search results display, filtering, facets. AI-powered search is especially relevant for Neo's AI platform.
Key IA Techniques
Card Sorting (open & closed) to understand users' mental models. Tree Testing to validate navigation structure. Content Inventory to audit what exists. Sitemap to visualize the structure. Content Model to define relationships between content types. For Neo, you'll govern IA consistency as new AI features are added to the platform.
UX Deliverables
The artifacts you'll be ensuring quality and consistency for across every feature entering Neo. Each deliverable serves a specific purpose in the design-to-development pipeline.
Deliverable Quality Checklist
As UX Manager, you ensure every deliverable meets these standards before it enters the dev pipeline:
- ✓ Aligned to product requirements and feature intake
- ✓ Consistent with Neo's design system tokens & patterns
- ✓ Addresses edge cases, error states, empty states
- ✓ Meets WCAG 2.2 AA accessibility requirements
- ✓ Responsive/adaptive for target devices
- ✓ Annotated with interaction specifications
- ✓ Validated through usability testing or review
- ✓ Design tokens and specs ready for dev handoff
Fidelity Levels
Low-Fidelity (Lo-fi)
Sketches, paper prototypes, basic wireframes. Focus on structure, flow, and content hierarchy. Used early in discovery/define phases. Quick, cheap, disposable.
Medium-Fidelity (Mid-fi)
Grayscale wireframes with real content, basic interactions. Used for user flows, layout validation, and stakeholder alignment. The sweet spot for most UX work.
High-Fidelity (Hi-fi)
Pixel-perfect designs with design system components, real content, and full interactions. Used for usability testing, stakeholder sign-off, and dev handoff.
Design Systems Architecture & Governance
A design system is a collection of reusable components, guided by clear standards, that can be assembled to build any number of applications. This is central to the Neo role.
Design System Governance Models
Centralized (Solitary)
One dedicated team owns the system. Ensures maximum consistency but can bottleneck. Best for early-stage systems like Neo where standards are being established.
Federated
Representatives from product teams contribute while a core team governs. Balances consistency with team autonomy. Recommended for Neo at scale.
Distributed
All teams contribute equally with lightweight governance. Maximum flexibility but risks inconsistency. Requires mature UX culture.
Industry-Leading Design Systems to Reference
| System | Company | Why It Matters |
|---|---|---|
| Material Design 3 | Token-based theming, adaptive layouts, dynamic color | |
| Carbon | IBM | Enterprise-grade, excellent governance model |
| Polaris | Shopify | Outstanding documentation, contribution model |
| Atlassian DS | Atlassian | Enterprise platform context similar to Neo |
| Lightning | Salesforce | Scalable enterprise system with accessibility focus |
| Fluent 2 | Microsoft | Cross-platform consistency, AI-era design patterns |
Usability Evaluation & Nielsen's Heuristics
Jakob Nielsen's 10 usability heuristics are the gold standard for evaluating interfaces. Published in 1994 and still universally relevant. You've already applied these at Ericsson — now articulate them fluently.
1. Visibility of System Status
Keep users informed about what's going on through appropriate, timely feedback. Example: progress bars, loading indicators, save confirmations.
2. Match Between System & Real World
Speak users' language. Use concepts, words, and conventions familiar to them rather than system-oriented terms. Follow real-world conventions.
3. User Control & Freedom
Provide clearly marked "emergency exits" — undo, redo, cancel. Users often choose functions by mistake and need a way to leave the unwanted state.
4. Consistency & Standards
Users shouldn't wonder whether different words, situations, or actions mean the same thing. Follow platform conventions. This is where design systems shine.
5. Error Prevention
Design to prevent errors before they occur. Eliminate error-prone conditions or check and present users with a confirmation option. Better than good error messages.
6. Recognition over Recall
Minimize memory load. Make options, actions, and objects visible. Users shouldn't have to remember information from one part of the interface to another.
7. Flexibility & Efficiency of Use
Accelerators for expert users — keyboard shortcuts, customizable workflows. Allow users to tailor frequent actions. Cater to both novice and expert users.
8. Aesthetic & Minimalist Design
Every extra unit of information competes with relevant information. Dialogues should not contain irrelevant or rarely needed information. Less is more.
9. Help Users Recognize & Recover from Errors
Error messages should be in plain language, precisely indicate the problem, and constructively suggest a solution. No error codes.
10. Help & Documentation
Ideally the system is usable without documentation. But when needed, help should be easy to search, focused on user tasks, list concrete steps, and be concise.
Accessibility & WCAG 2.2
Enterprise platforms must meet WCAG 2.2 AA as a minimum. Accessibility isn't an add-on — it's a design constraint you embed from day one. The POUR principles frame everything.
Quick Reference: Common WCAG 2.2 AA Requirements
| Criterion | Requirement | Design Impact |
|---|---|---|
| 1.4.3 Contrast | 4.5:1 text, 3:1 large text | Color palette design, text on backgrounds |
| 1.4.11 Non-text Contrast | 3:1 for UI components & graphics | Borders, icons, focus indicators |
| 2.1.1 Keyboard | All functionality via keyboard | Focus management, tab order, skip links |
| 2.4.7 Focus Visible | Visible keyboard focus indicator | Focus ring design in design system |
| 2.5.8 Target Size (New in 2.2) | 24×24px minimum for touch targets | Button/link sizing, spacing |
| 3.3.7 Redundant Entry (New in 2.2) | Don't ask for same info twice | Form design, multi-step flows |
| 4.1.2 Name, Role, Value | Proper ARIA labels for custom components | Component library accessibility specs |
Figma: Zero to Mastery
Your accelerated path from Figma fundamentals to confident proficiency. Structured as a progressive skill tree with the best free resources, organized for maximum speed.
Progressive Mastery Track
Navigator
Interface orientation, layers panel, frames, pages, navigation, zooming, commenting, inspect mode
Builder
Shapes, text, colors, images, constraints, grids, auto layout basics, boolean operations
Systematizer
Components, variants, component properties, styles, variables, design tokens, team libraries
Prototyper
Interactions, transitions, smart animate, overlays, scrolling, variables for prototyping, presentation
Core Figma Concepts Explained
Frames & Auto Layout — The Building Blocks
Frames are Figma's fundamental container. Unlike groups, frames clip content, can have fill/stroke, and support auto layout and constraints. Think of them as <div> elements in HTML.
Auto Layout is Figma's flexbox equivalent. It automatically positions child elements in a row or column with configurable padding, gap, alignment, and distribution. Key properties:
Direction Padding Gap Alignment Sizing (Hug/Fill/Fixed)
Nested Auto Layout is how you build responsive, production-ready layouts. A card component might have: outer auto layout (vertical) containing a header row (horizontal auto layout) and content stack (vertical auto layout).
Manager Focus: When reviewing designs, check that auto layout is used consistently. Designs built with auto layout translate more cleanly to CSS Flexbox/Grid during dev handoff.
Components, Variants & Properties
Components are reusable design elements. The main component is the source of truth; instances inherit from it. Changes to the main component propagate to all instances.
Variants combine related component variations into a single component set. A button might have variants for: Size (sm/md/lg), Style (primary/secondary/ghost), State (default/hover/active/disabled).
Component Properties (added 2022) reduce variant explosion:
Boolean Show/hide layers (e.g., icon visibility)
Text Override text content directly
Instance Swap Swap nested component instances
Variant Switch between variant states
Manager Focus: A well-structured component library with proper variants and properties is the hallmark of a mature design system. You govern this structure.
Design Tokens & Variables
Figma Variables (released 2023) are the tool's design token implementation. They store reusable values for: colors, numbers, strings, and booleans. Variables support:
Modes Light/Dark/High-contrast themes
Aliasing Semantic tokens referencing primitive tokens
Scoping Restrict where variables can be applied
Collections Group related variables (colors, spacing, etc.)
Token Architecture follows a 3-tier pattern:
1. Primitive tokens — raw values (blue-500: #3B82F6)
2. Semantic tokens — purpose-driven aliases (color-action-primary: blue-500)
3. Component tokens — component-specific (button-bg-primary: color-action-primary)
Manager Focus: Token governance ensures design-dev consistency. Variables in Figma should mirror the token structure in code. Sync tools like Tokens Studio bridge this gap.
Team Libraries & Publishing
Team Libraries let you share styles, components, and variables across files. Publishing a library makes its assets available to the entire team.
Library Structure for Enterprise:
📁 Foundation Library — Colors, typography, spacing, icons
📁 Component Library — Buttons, inputs, cards, navigation
📁 Pattern Library — Forms, data tables, dashboards
📁 Brand Library — Logos, illustrations, photography
Branching & Merging (Figma feature): Design teams can branch library files to work on updates without affecting production, then merge changes back. Critical for design system governance.
Manager Focus: You govern the publishing workflow. Who can publish? What's the review process? How are breaking changes communicated? How do teams update their instances?
Prototyping & Interactions
Prototype mode connects frames with interactions to simulate user flows. Key interaction types:
Navigate To Move between screens
Overlay Modals, tooltips, dropdowns
Swap Instance Component state changes
Scroll To Anchor links within a page
Open Link External URL navigation
Triggers: On Click, On Hover, On Drag, While Pressing, Mouse Enter/Leave, After Delay, Key/Gamepad
Smart Animate automatically tweens matching layers between frames. Name layers consistently to enable smooth transitions.
Variables in Prototyping enable conditional logic (if/else), counting, and multi-state interactions without duplicating frames.
Manager Focus: You need to review prototypes for interaction quality, edge case coverage, and whether the prototype communicates intent clearly enough for usability testing and dev handoff.
Dev Mode & Handoff
Dev Mode (Figma's dedicated developer view) provides:
● CSS/Swift/XML code snippets for selected elements
● Spacing measurements (auto-calculated)
● Asset export (SVG, PNG, JPG at multiple resolutions)
● Variable and style inspection
● Component documentation and links
● "Ready for dev" status markers
● VS Code extension integration
"Ready for Dev" Workflow: Designers mark sections as ready → devs see what's available → comments and annotations in-context → specs auto-generated.
Manager Focus: You structure the design-to-dev workflow. Define what "ready for dev" means, ensure annotations are complete, and govern the handoff checklist.
Recommended Video Tutorials (Prioritized for Speed)
Figma Design for Beginners (Official)
Hands-on course from Figma's own team. Build a portfolio site from scratch covering shapes, text, frames, auto layout, components, and prototyping.
Bring Your Own Laptop — Full Figma Course
30+ video playlist from basics to project completion. One of the highest-rated beginner-to-intermediate courses. ~3 hours total.
Figma UI Design Tutorial (AJ&Smart)
Learn Figma basics in under 30 minutes. Frames, shapes, colors, importing elements. Perfect for day-one orientation.
Free Figma Make Course 2026
Latest course covering Figma Make (formerly Figma Design), updated for 2026 features including variables and advanced prototyping.
Supercharge Design — Advanced Figma
5-star rated course for mid-senior designers. Auto layout mastery, design system architecture, advanced prototyping, tokens. Lifetime updates.
Figma Community Tutorials
Official community hub with free tutorials, templates, and design files you can duplicate and explore hands-on.
Prototyping & Design-to-Dev Handoff
The bridge between design intent and engineering implementation. This is where UX quality lives or dies at scale.
Handoff Best Practices
Design annotations document interaction behaviors that aren't visible in static mockups: hover states, loading sequences, error handling, edge cases, and animation specifications. These live alongside the design in Figma using annotation components or comments.
Design tokens ensure the handoff is value-based, not pixel-based. Instead of saying "use #3B82F6", the spec says "use color-action-primary" — which maps to the correct value in any theme or mode.
Handoff Checklist for Your Team
- ✓ All states covered: default, hover, active, disabled, focus, error, loading, empty
- ✓ Responsive breakpoints specified
- ✓ Design tokens referenced (not raw values)
- ✓ Interaction annotations complete
- ✓ Accessibility specs (ARIA labels, tab order, contrast)
- ✓ Content edge cases (long text, missing data, empty states)
UX Management & Governance
This is the core of the Neo role. You're not primarily designing — you're orchestrating design delivery at scale. This module covers UX operations, workflow governance, and cross-functional leadership.
Key Responsibilities Framework
Feature Intake & Planning
Translate product requirements into UX workstreams. Estimate design effort, sequence work, and assign to designers. Maintain a UX backlog aligned to the product roadmap.
Quality Governance
Define and enforce UX quality standards. Run design reviews, heuristic evaluations, and accessibility audits. Gate design readiness before handoff to engineering.
Team Coordination
Manage multiple parallel UX workstreams. Resource allocation across features, managing dependencies, and ensuring designers aren't blocked or siloed.
Stakeholder Management
Communicate UX progress, decisions, and trade-offs to product, engineering, and leadership. Advocate for user needs while balancing business constraints.
UX Maturity & Scaling
Understanding where an organization sits on the UX maturity curve — and how to advance it — is strategic leadership. The NN/g model is the industry standard.
Design-to-Development Collaboration
The JD explicitly asks you to "structure and govern the design-to-development workflow." This is your operational playbook.
Agile UX Integration Model
Interview Question Bank & Answers
Curated questions for UI/UX Manager technical interviews. Click each question to reveal the answer framework. Practice answering aloud.
1. Feature Intake: Receive product requirements, understand user stories, success metrics, and constraints. Identify which user segments are affected.
2. Scoping: Break the feature into UX workstreams. Estimate design effort. Identify research needs (do we need new research or can we leverage existing insights?).
3. Discovery: Rapid research if needed — competitive analysis, stakeholder interviews, existing analytics review. Output: problem statement, user needs.
4. Design: User flows → wireframes → prototype. Use the design system for consistency. Include all states (happy path, errors, edge cases, empty states).
5. Validation: Usability testing or design review with stakeholders. Iterate based on findings.
6. Handoff: Mark as "Ready for Dev" with full specs, annotations, and design tokens. Support engineering during implementation.
7. QA: UX review of implemented feature before release. Post-launch feedback loop.
Link to your Ericsson experience: "At Ericsson, I owned end-to-end UX from stakeholder interviews through GA release, coordinating design workstreams across India, Ireland, and Canada."
• Single source of truth: Figma team library with versioned components, variables, and published styles. No local overrides without governance approval.
• Token architecture: Primitive → Semantic → Component tokens. Figma Variables synced with code tokens.
• Contribution model: Federated governance — product teams propose additions, core team reviews and integrates.
• Design reviews: Regular cadence where new work is checked against the design system. Deviations documented and evaluated for potential system updates.
• Documentation: Every component has usage guidelines, dos/don'ts, accessibility specs, and implementation notes.
• Adoption metrics: Track component usage, detach rates, and custom component creation to identify coverage gaps.
Link to your experience: "At Ellucian, I established the company-wide UI Pattern Library and design standards in collaboration with global usability experts."
• Planning: Define research questions, recruit representative users (5-8 per segment per NN/g), prepare task scenarios and success criteria.
• Execution: Moderated or unmoderated sessions. Think-aloud protocol. Record screens and audio. Capture task success/failure rates, time-on-task, error rates, and satisfaction (SUS/SEQ).
• Analysis: Affinity map findings, severity-rate issues (critical/major/minor), calculate task completion rates.
• Reporting: Themes, recommendations, and prioritized fix list mapped to the roadmap.
Your evidence: "I validated D&R workflows with Telstra and Optus customer users, achieving 100% completion across 15 required task attempts and shipping 12 GA improvements."
• Start with shared goals: Both teams want to ship a great product. Frame discussions around user outcomes and business metrics, not personal preferences.
• Understand the constraint: Is it a true technical limitation, a timeline issue, or an unfamiliarity? Each requires a different response.
• Offer alternatives: If the ideal solution isn't feasible, propose a design that achieves 80% of the UX value at 20% of the engineering cost. Document the ideal state for the roadmap.
• Escalation path: If the trade-off significantly impacts user experience, escalate with data (usability findings, analytics, competitor benchmarks) to product leadership.
• Document decisions: ADRs (Architecture Decision Records) for significant UX/eng trade-offs. Prevents revisiting settled decisions.
Frame your approach: "I believe in collaborative tension — design pushes for user excellence, engineering grounds it in reality. The manager's job is to find the best outcome within those constraints."
1. Behavioral (what users do): Task completion rate, time-on-task, error rate, feature adoption rate, daily/weekly active users, navigation paths, search usage patterns.
2. Attitudinal (what users feel): System Usability Scale (SUS) scores, Net Promoter Score (NPS), Customer Satisfaction (CSAT), Single Ease Question (SEQ) per flow.
3. Business Impact: Support ticket reduction, training time reduction, feature adoption velocity, employee productivity gains (since Neo serves Capgemini employees).
UX-specific operational metrics: Design system adoption rate, design-to-dev handoff quality (rework rate), heuristic evaluation scores, accessibility compliance percentage.
Framework to mention: Google's HEART framework (Happiness, Engagement, Adoption, Retention, Task Success) is well-suited for enterprise platforms.
"At Ellucian, I built and led a 21-person UX organisation spanning Research, Analysis, Design, and Development — both full-time staff and contractors across the U.S., India, and EMEA."
Cover these dimensions:
• Vision & Strategy: Set vision, KPIs, and annual goals for the UX division.
• Process: Embedded WCAG accessibility and i18n as standard practice. Structured the design-to-development workflow.
• People: Recruitment, performance reviews, mentoring, training. "The hardest lesson: scaling a UX org is as much about building trust across functions as it is about hiring."
• Cross-geography: Managed resource allocation and design reviews across time zones.
• Budget: Owned budgeting and escalation handling.
This is your strongest differentiator for the Neo role. Lead with it.
"I work with Figma for design system governance, prototype review, and design-to-dev handoff at an enterprise level. My focus is on the operational side: ensuring team libraries are structured and versioned, components follow naming conventions, design tokens align with code implementation, and the 'Ready for Dev' workflow is clean."
Key areas to emphasize:
• Team library architecture and publishing governance
• Component structure (variants, properties, auto layout)
• Design token management via Variables
• Branching and merging for library updates
• Dev Mode and handoff workflows
• Figma + JIRA/Confluence integration for tracking
If pressed on hands-on skills: "I've used Figma for prototyping and wireframing. My portfolio at uvwx.me demonstrates Figma-based work with embedded Atomic Design systems."
5-Day Study Plan & Learning Resources
Your accelerated preparation roadmap. Each day has a focused theme, specific activities, and curated resources. Track your progress below.
- UX Foundations — Read Modules 1-2
- Watch: Figma Beginners Course (Official)
- Figma: Interface, frames, auto layout
- Review: Double Diamond & Design Thinking
- Practice: Navigate a Figma community file
- Research & IA — Read Modules 3-4
- Figma: Components & variants deep dive
- Watch: BYOL Figma playlist (first 10)
- Study: Nielsen's 10 Heuristics (Module 7)
- Practice: Create a simple component set
- Design Systems — Read Modules 5-6
- Figma: Variables, tokens, team libraries
- Study: WCAG 2.2 AA essentials (Module 8)
- Review: Carbon/Polaris design systems
- Practice: Build a mini token set in Figma
- Prototyping & Handoff — Read Modules 9-10
- Figma: Prototyping & Dev Mode
- Study: UX Management (Modules 11-13)
- Review: Dual-track Agile workflow
- Practice: Prototype a simple 3-screen flow
- Interview Prep — Module 14
- Practice Q&A answers aloud
- Review your portfolio stories (STAR format)
- Final Figma review of all concepts
- Rest, hydrate, and trust your experience
Essential Reading & Pioneer References
The Design of Everyday Things
Don Norman's seminal work on usability and human-centered design. The book that defined the field.
Don't Make Me Think
Steve Krug's practical guide to web usability. Quick read, high impact. The title itself is a design principle.
Lean UX
Jeff Gothelf's guide to applying Lean principles to UX in Agile environments. Directly relevant to Neo's SAFe context.
Information Architecture (4th Ed)
Rosenfeld, Morville & Arango's definitive guide. The "polar bear book" of IA. Essential for enterprise platforms.
Nielsen Norman Group (NN/g)
The gold standard for UX research and articles. Free articles on every UX topic. Start with their "UX Research Cheat Sheet."
Interaction Design Foundation (IxDF)
Comprehensive UX courses and encyclopedia. Great for structured learning with certificates.
Figma Best Practices
Figma's official guide to building design systems, managing libraries, and team collaboration at scale.
WCAG 2.2 Quick Reference
W3C's official quick reference for WCAG 2.2 success criteria. Filterable by level and topic.
UX Pioneers to Know (Name-Drop Ready)
| Pioneer | Contribution | Key Concept |
|---|---|---|
| Don Norman | Coined "User Experience," authored Design of Everyday Things | Affordances, signifiers, mental models |
| Jakob Nielsen | Co-founded NN/g, 10 usability heuristics | Discount usability, heuristic evaluation |
| Alan Cooper | Invented personas, authored About Face | Goal-directed design, personas |
| Jesse James Garrett | Authored Elements of UX, coined "Ajax" | 5 Planes of UX |
| Jared Spool | Founded UIE/Center Centre | UX strategy, design maturity |
| Steve Krug | Authored Don't Make Me Think | Usability testing democratization |
| Peter Morville | Co-authored Information Architecture | UX Honeycomb (useful, usable, findable, desirable, accessible, credible, valuable) |
| Tim Brown | CEO of IDEO, popularized Design Thinking | Human-centered innovation |
| Jeff Gothelf | Authored Lean UX | Lean UX in Agile environments |
| Brad Frost | Created Atomic Design methodology | Atoms → Molecules → Organisms → Templates → Pages |