100+ Figma Interview Questions and Answers

Figma is a cloud-based UI/UX design and prototyping tool that enables real-time collaboration. Unlike traditional tools like Adobe XD or Sketch, Figma runs entirely in the browser — meaning a designer in Mumbai and a developer in New York can work on the same file simultaneously without sending files back and forth.

UI (User Interface) Design focuses on the visual aspects of a product, including colors, typography, spacing, icons, buttons, and layouts.
For example, deciding that a primary button should be blue with white text, 16px font, and 12px padding is a UI decision.

UX (User Experience) Design focuses on usability, accessibility, user journeys, and overall satisfaction while interacting with a product.
For example, simplifying a 5-step checkout flow into 2 steps to reduce cart abandonment is a UX decision.

Empathize, Define, Ideate, Prototype, and Test. For example, when designing a food delivery app: Empathize (interview users about ordering habits), Define (users need faster reordering), Ideate (brainstorm a one-tap reorder feature), Prototype (build a clickable Figma flow), Test (validate with real users).

One-Line Summary

Empathize: Understand users and their needs.

Define: Clearly state the problem.

Ideate: Think of possible solutions.

Prototype: Create a sample solution.

Test: Check the solution with users and improve it.

Frames act as containers for screens, sections, and responsive layouts. For example, when designing a mobile app, each screen (Login, Home, Profile) is a separate Frame set to 375×812px (iPhone 14 dimensions). Frames can also be nested inside each other to create complex layouts.

Components are reusable design elements that help maintain consistency. For example, creating a Button component once and reusing it across 50 screens means that changing the button's color in the master component automatically updates all instances throughout the entire file.

Variants group related component states such as default, hover, active, and disabled into a single component set. For example, a Button component can have Variants for Type (Primary, Secondary, Ghost) and State (Default, Hover, Disabled), making it easy to swap between states in your designs.

Auto Layout automatically arranges and resizes elements based on content, similar to CSS Flexbox. For example, a navigation bar with Auto Layout will automatically expand when you add a new menu item, and a button with Auto Layout will grow or shrink based on the label text length.

A prototype simulates user interactions and navigation flows without writing any code. For example, linking the Login button on the Login screen to the Home screen with a "Navigate to" interaction creates a clickable prototype you can share with stakeholders for feedback.

A wireframe is a low-fidelity representation of a screen layout that focuses on structure and content placement rather than visual design. For example, using simple gray rectangles to represent images, black lines for text, and boxes for buttons to map out an e-commerce product page before adding real visuals.

A mockup is a high-fidelity visual representation of a design that includes real colors, typography, images, and branding. For example, a pixel-perfect design of a banking app dashboard showing the actual UI with charts, icons, and typography — but without interactive links.

A design system is a collection of reusable components, styles, guidelines, and documentation that ensures consistency across a product. For example, Google's Material Design and IBM's Carbon Design System are well-known design systems that define everything from button sizes to motion principles.

Constraints control how layers behave when a frame is resized, similar to responsive CSS rules. For example, setting a top navigation bar's constraint to "Left and Right" with "Top" ensures it always stretches full width and stays fixed to the top when the frame is resized for different screen widths.

Typography is the styling and arrangement of text for readability and visual hierarchy. For example, using Inter 32px Bold for headings, Inter 16px Regular for body text, and Inter 12px Medium for captions creates a clear typographic hierarchy that guides the reader's eye.

Visual hierarchy guides the user's attention through deliberate use of size, color, contrast, and spacing. For example, on a landing page, a large bold headline draws the eye first, followed by a medium subheading, then body text, and finally a high-contrast CTA button.

Grids help align content consistently across layouts. For example, using a 12-column grid with 24px gutters on a desktop frame ensures all cards, text blocks, and buttons align perfectly — just like Bootstrap's grid system used in web development.

White space (also called negative space) improves readability, visual balance, and perceived quality. For example, Apple's product pages use generous white space around product images and text, making the design feel premium and easy to scan.

Responsive design adapts layouts to different screen sizes and devices. For example, designing a 3-column card grid for desktop that stacks into a single column on mobile, ensuring a seamless experience across all device sizes.

Accessibility ensures products are usable by people with disabilities. For example, ensuring text has a 4.5:1 contrast ratio for users with low vision, adding alt text to images for screen readers, and making all interactive elements reachable via keyboard for users who cannot use a mouse.

Contrast improves readability and visual distinction between elements. For example, white text (#FFFFFF) on a dark blue background (#1A237E) has a high contrast ratio of 12:1, exceeding WCAG AA requirements, while light gray text on white background would fail accessibility standards.

A user flow maps the steps a user takes to complete a specific task. For example, the user flow for "Purchase a product" might be: Home → Search → Product Page → Add to Cart → Checkout → Payment → Order Confirmation. This helps designers identify friction points before building screens.

A persona is a fictional but research-based representation of a target user. For example, "Priya, 28, a working professional who orders lunch online daily, values speed and ease of reordering, and gets frustrated by apps with too many steps." Personas keep the team aligned on who they are designing for.

User research gathers qualitative and quantitative insights about user needs and behaviors. For example, conducting 10 user interviews about a banking app reveals that users find the transfer flow confusing — a direct insight that shapes design decisions before a single pixel is designed.

Usability testing observes real users interacting with a product to identify friction and issues. For example, asking 5 users to "find and purchase a product" on your prototype and watching where they hesitate, click the wrong element, or get confused reveals real usability problems to fix.

An icon system is a consistent, unified collection of icons used throughout a product. For example, using Google's Material Icons or a custom icon set where all icons share the same stroke weight (2px), size (24×24px), and visual style ensures a cohesive look across the entire product.

A style guide is a document defining visual standards and usage rules for a product. For example, Airbnb's style guide specifies exact color hex codes, typography scales, spacing units, button states, and tone of voice — ensuring every designer and developer builds consistently.

Sections are labeled containers that help organize screens and workflows on the Figma canvas. For example, grouping all onboarding screens under a "Onboarding" section and all dashboard screens under a "Dashboard" section makes large files much easier to navigate.

Pages organize a Figma file into logical, separate canvases. For example, a project file might have separate pages for Wireframes, UI Design, Design System, Prototype, and Developer Handoff — keeping each phase clean and separated without creating multiple files.

Multiple users can view and edit the same Figma file simultaneously in real time. For example, a designer, product manager, and developer can all be in the same file at once — the designer updating components while the PM adds comments and the developer inspects spacing values.

Commenting is a built-in Figma feature for leaving feedback and conducting design reviews directly on the canvas. For example, a product manager can pin a comment on a specific button saying "This CTA copy needs to be stronger" and the designer can resolve it once updated — keeping all feedback in one place.

Developer handoff is the process of sharing design specifications, assets, and measurements with developers. For example, using Figma's Inspect panel, developers can view exact spacing values, font sizes, HEX colors, and export assets directly — reducing back-and-forth communication.

Assets are reusable resources such as components, styles, and icons accessible from the Assets panel. For example, once a Button component is published to a Team Library, any designer on the team can find it in the Assets panel and drag it directly onto their canvas.

A design token is a named, reusable value for colors, spacing, typography, shadows, and more that bridges design and code. For example, a token named "color/primary/500" with value "#6200EA" can be used in both Figma and the codebase, ensuring the exact same color is always used in both.

A color style is a saved, reusable color definition in Figma. For example, saving "#6200EA" as "Primary/Purple" means you can apply this color to any element in one click, and changing the style updates every element using it across the entire file.

A text style is a saved typography definition including font family, size, weight, line height, and letter spacing. For example, defining a "Heading/H1" style as Inter 32px Bold with 40px line height ensures every H1 across all screens looks identical and can be updated globally in one place.

Consistency improves usability, reduces cognitive load, and builds user trust. For example, if the primary action button is blue on one screen and green on another, users get confused about which action is most important. Consistent patterns make products feel intuitive and professional.

Auto Layout creates flexible components that adapt automatically to content changes, like CSS Flexbox. For example, a Tag component with Auto Layout will automatically resize when the label text changes from "Design" to "User Experience Research" — no manual resizing needed. This makes maintaining large component libraries much faster.

Variants should be used when a component has multiple related states or configurations that designers need to switch between. For example, an Input Field component with Variants for State (Default, Focused, Error, Disabled) and Size (Small, Medium, Large) lets designers quickly swap between all combinations from a single component set.

Interactive Components allow components to simulate interactions internally within a prototype without requiring separate frames. For example, a Toggle Switch component can animate between ON and OFF states when clicked in prototype mode — all within the single component, without linking to a new frame for each state.

Team Libraries publish components and styles from one file so they can be used across all projects in an organization. For example, a central Design System file publishes a Button component, and all product teams across 10 different projects can use and stay in sync with that button. When the design system team updates the button, all teams receive the update.

Breakpoints are screen-width thresholds at which the layout changes for responsive design. For example, common breakpoints are Mobile (375px), Tablet (768px), and Desktop (1440px). In Figma, designers create separate frames at each breakpoint to show how the layout adapts across devices.

Atomic Design is a component methodology that builds UI from the smallest units upward: Atoms (Button, Input), Molecules (Search Bar = Input + Button), Organisms (Header = Logo + Nav + Search Bar), Templates (page layout), and Pages (final design with real content). This creates a highly scalable and consistent design system.

Creating a design system involves defining foundations (colors, typography, spacing, elevation), building components (buttons, inputs, cards), writing documentation (usage guidelines, dos and don'ts), and establishing governance (who owns updates). For example, starting with a token-based color palette and a set of 10 core components before expanding based on team needs.

Information Architecture (IA) is the structure and organization of content within a product. For example, designing the navigation of an e-commerce site so products are grouped logically under categories like "Men → Clothing → Shirts" instead of a flat, unsorted list makes it faster for users to find what they need.

Card sorting is a UX research method where users group topics or features into categories that make sense to them. For example, writing 30 app features on individual cards and asking 10 users to group them reveals how real users mentally categorize information — directly informing your navigation structure.

A user journey map is a visualization of the complete experience a user has with a product over time, including actions, emotions, and pain points. For example, mapping the journey of booking a flight from "feeling the need to travel" to "arriving at the destination" reveals emotional highs and lows that help prioritize design improvements.

Heuristic evaluation is a usability inspection method where experts review a design against established usability principles (Nielsen's 10 heuristics). For example, checking if an error message clearly explains what went wrong and how to fix it (Heuristic: Help users recognize, diagnose, and recover from errors).

Microinteractions are small, focused animations or feedback moments that respond to user actions. For example, a heart icon that animates and turns red when you like a post, a loading spinner while content fetches, or a subtle button press animation — these small details make an interface feel alive and responsive.

Progressive disclosure shows only the most essential information initially, revealing more detail as the user needs it. For example, a form that first asks only for email and password, then reveals additional profile fields after account creation — reducing the initial cognitive load and improving completion rates.

Affordance refers to visual cues that suggest how an element can be interacted with. For example, a button with raised styling and a shadow suggests it can be pressed; underlined blue text suggests it is clickable; a handle icon on a list item suggests it can be dragged and reordered.

Fitts's Law states that the time to reach a target depends on its size and distance — larger and closer targets are faster to interact with. For example, making the primary CTA button larger and placing it within thumb reach on mobile (bottom of screen) reduces friction and increases click rates.

Hick's Law states that decision time increases with the number of choices available. For example, a navigation menu with 3 options is faster to process than one with 12 options. This is why good UX design focuses on reducing unnecessary choices and simplifying decision-making at every step.

Optimize forms by minimizing fields, using smart defaults, showing inline validation, grouping related fields, and using the right input types. For example, reducing a registration form from 10 fields to 4 essential fields (name, email, password, phone) can significantly increase form completion rates.

Design patterns are proven, reusable solutions to common UI problems. For example, the "Hamburger Menu" pattern solves navigation on mobile, the "Card" pattern organizes content in scannable units, and the "Infinite Scroll" pattern loads content progressively — all established solutions designers can apply confidently.

Large Figma files stay organized through consistent use of pages (one per design phase), sections (grouping related screens), clear naming conventions (e.g., "01 - Onboarding / Login"), and separating the design system into its own file. For example, a file with 200+ screens becomes manageable when screens are grouped into sections by user flow.

Nested components are components placed inside other components, enabling complex, flexible UI elements. For example, a Card component can contain a Button component, an Avatar component, and a Badge component — each independently managed, so updating the Button component automatically updates it everywhere it appears including inside all Card instances.

Component properties allow designers to control text content, layer visibility, and instance swapping directly from the properties panel without entering the component. For example, a Card component with a Boolean property called "Show Badge" lets designers toggle the badge on or off across all card instances without detaching the component.

A prototype flow is a named, linked sequence of screens that represents a specific user journey for testing. For example, creating separate flows for "Sign Up", "Purchase Item", and "Edit Profile" in the same Figma file lets you share and test each journey independently with different stakeholders.

User-centered design (UCD) is a process that places user needs, goals, and limitations at the center of every design decision. For example, before redesigning a hospital app, conducting interviews with doctors and nurses to understand their actual workflow constraints leads to solutions that genuinely improve their daily experience rather than just looking modern.

Usability tests involve recruiting representative users, giving them specific tasks to complete, observing without guiding, and analyzing patterns in their behavior. For example, asking 5 users to "Find and add a product to your wishlist" on a prototype — watching where they hesitate reveals navigation or labeling issues before development begins.

A/B testing compares two design versions with real users to measure which performs better against a specific metric. For example, testing a green CTA button (Version A) against an orange CTA button (Version B) with 50% of users each, then measuring which drives more sign-ups over two weeks.

Empty states are screens shown when there is no content to display, and they should always guide users toward the next action. For example, a new user's inbox showing an illustration with the message "No messages yet — start a conversation!" with a CTA button turns a potentially confusing empty screen into an onboarding opportunity.

Error states are UI messages that communicate what went wrong and how to fix it. For example, instead of showing a generic "Error 500" message, a well-designed error state says "We couldn't process your payment. Please check your card details and try again." — giving users clear, actionable guidance.

Mobile-first design starts by designing for the smallest screen (mobile) and progressively enhancing the layout for larger screens. For example, designing a dashboard as a single-column scroll for mobile first, then adapting it to a 2-column layout for tablet and a 3-column grid for desktop ensures core functionality works on all devices.

Improve accessibility by meeting WCAG contrast ratios, adding descriptive labels to all interactive elements, supporting keyboard navigation, using semantic structure, and testing with screen readers. For example, adding aria-label="Close dialog" to an X button ensures screen reader users understand its purpose without relying on the icon alone.

Design reviews are structured evaluation sessions where designs are presented to stakeholders, developers, or other designers for structured feedback. For example, a weekly design review where the team evaluates new screens against design system guidelines and usability heuristics before moving to development.

A UI audit is a systematic review of an existing product to identify inconsistencies, outdated components, and accessibility issues. For example, auditing a legacy app and discovering 14 different button styles, 7 inconsistent font sizes, and multiple unbranded form elements — creating a clear prioritized list for standardization.

Visual consistency means maintaining the same styles, spacing, and patterns across all screens of a product. For example, if cards on the Home screen have 16px padding and 8px border radius, the same treatment should be applied to cards on the Search and Profile screens — creating a unified, professional experience.

Design metrics are measurable values used to evaluate the success of design decisions. For example, tracking Task Completion Rate (did users successfully complete the checkout?), Time on Task (how long did it take?), and Error Rate (how often did they make mistakes?) provides quantitative evidence of design effectiveness.

Effective designer-developer collaboration involves providing clear specs via Figma's Inspect panel, using consistent naming conventions, documenting component behavior, and participating in developer handoff meetings. For example, annotating a complex animation with timing values, easing curves, and trigger conditions removes ambiguity and reduces revision cycles.

Design debt is the accumulation of inconsistencies, workarounds, and shortcuts that build up over time when design decisions are rushed or undocumented. For example, creating one-off button styles under deadline pressure instead of using the design system results in dozens of inconsistent buttons that require expensive cleanup later.

Scaling a design system requires governance (clear ownership and contribution process), versioning (tracking changes), comprehensive documentation, and token-based foundations. For example, Shopify's Polaris design system uses a dedicated team, public documentation, contribution guidelines, and semantic tokens — enabling consistent design across hundreds of product teams.

Variables in Figma store dynamic values for colors, spacing, typography, and numbers that can be scoped to modes like light and dark themes. For example, creating a Variable "color/background/primary" with value #FFFFFF in Light mode and #121212 in Dark mode, then applying it across all components, lets you switch the entire product between themes with a single click.

Design tokens centralize reusable design decisions and create a shared language between designers and developers. For example, a token "spacing/4" = 16px used in both Figma components and the development codebase (as a CSS variable --spacing-4: 16px) ensures pixel-perfect alignment between design and implementation without manual cross-referencing.

Multi-brand design systems use shared foundational components with brand-specific token overrides. For example, a fintech company managing three regional brands (India, UAE, UK) maintains one component library but applies different color tokens, typography tokens, and icon sets per brand — allowing one Button component to render correctly in all three brand identities.

UX success is measured through both quantitative and qualitative metrics. For example, after a checkout redesign, tracking Task Completion Rate (improved from 64% to 89%), Average Time on Task (reduced from 4.2 min to 1.8 min), Customer Satisfaction Score (CSAT), and Net Promoter Score (NPS) provides a comprehensive picture of the redesign's impact.

WCAG (Web Content Accessibility Guidelines) is an internationally recognized set of accessibility standards for digital products published by the W3C. For example, WCAG 2.1 Level AA requires a minimum 4.5:1 color contrast ratio for normal text, keyboard accessibility for all interactions, and text alternatives for all non-text content like images and icons.

Designing for accessibility means considering the full spectrum of human ability from the start. For example, designing for vision impairment (high contrast, scalable text), motor impairment (large touch targets minimum 44×44px, no hover-only interactions), hearing impairment (captions for video), and cognitive impairment (simple language, clear navigation, consistent patterns).

Enterprise UX focuses on designing complex, data-dense tools for professional users in large organizations. For example, designing an HR management dashboard for 500 daily users who perform repetitive, time-critical tasks requires prioritizing efficiency, keyboard shortcuts, data density, and power-user features over simplicity and visual appeal.

Prioritize UX issues by evaluating severity (how badly does it affect the user?), frequency (how many users encounter it?), and business impact (does it affect conversion or retention?). For example, a broken checkout button is Critical (high severity, high frequency, high business impact) while a misaligned icon is Low priority (low severity, low impact).

Service design is the practice of designing end-to-end experiences across all customer touchpoints including digital, physical, and human interactions. For example, designing a hospital patient experience involves not just the app but also the waiting room signage, nurse communication scripts, and discharge paperwork — all working together as a unified service.

DesignOps (Design Operations) is the practice of optimizing people, processes, and tools to improve design team efficiency and output quality. For example, establishing a shared component library, standardizing file naming conventions, automating design-to-developer handoff, and creating onboarding documentation for new designers are all DesignOps initiatives.

Effective stakeholder management involves identifying stakeholders early, communicating design rationale with evidence, and managing feedback constructively. For example, presenting a redesigned onboarding flow to a skeptical VP by leading with user research data showing a 40% drop-off at step 3 — then showing how the redesign addresses that specific pain point — makes the case objectively.

UX strategy is a long-term plan that connects user experience goals with measurable business outcomes. For example, a UX strategy for a SaaS product might focus on reducing onboarding time-to-value from 7 days to 2 days over 12 months — aligning every design initiative to that north star metric.

Validate assumptions through a combination of qualitative research (user interviews, usability tests), quantitative data (analytics, heatmaps), and rapid experimentation (A/B tests, prototypes). For example, before building a complex filtering system, validating the assumption that users need filters by analyzing search logs and interviewing 5 users first.

Cognitive load is the mental effort required to understand and use a product. For example, a settings screen with 40 unlabeled options grouped randomly creates high cognitive load, while grouping related settings under clear headings with descriptive labels and hiding advanced options reduces it significantly.

Reduce cognitive load by simplifying interfaces, chunking information into logical groups, using familiar patterns, and removing unnecessary elements. For example, breaking a 10-field registration form into 3 clearly labeled steps ("Account → Profile → Preferences") feels far less overwhelming than presenting all fields at once.

Dark patterns are deceptive UI techniques that manipulate users into unintended actions against their own interests. For example, a "Roach Motel" pattern makes it extremely easy to sign up for a subscription but hides the cancellation option deep in account settings — a manipulative practice that erodes user trust and is increasingly regulated by law.

Prevent design inconsistency through a maintained design system, regular design reviews, shared component libraries, and clear documentation. For example, implementing a rule that all new UI elements must use existing design system components — and any new component must be reviewed and added to the system before use — prevents one-off styles from proliferating.

Cross-functional collaboration means working closely with product managers, engineers, data analysts, marketing, and business teams throughout the design process. For example, involving an engineer early in the design phase to flag technically complex animations before they are finalized saves significant rework time during development.

Create scalable components by building with Auto Layout, using variants for all states, defining component properties for content flexibility, and documenting usage guidelines. For example, a Table component built with Auto Layout and row variants (Default, Hover, Selected, Disabled) can accommodate any number of rows and column configurations without needing custom one-off designs.

Localization adapts a product for different languages, cultures, and regional preferences beyond simple translation. For example, designing a date picker that shows DD/MM/YYYY for Indian users and MM/DD/YYYY for US users, supporting right-to-left text for Arabic layouts, and adjusting color symbolism (red means danger in the West but luck in China).

Handle conflicting feedback by anchoring decisions to user research data and defined success metrics rather than personal opinions. For example, when the CEO wants a red button but user testing shows green performs 30% better, presenting the data objectively moves the conversation from preference to evidence-based decision making.

Data-informed design uses analytics, user research, and behavioral data to guide design decisions without being solely dictated by numbers. For example, using heatmap data showing users ignoring the right sidebar to justify removing it, combined with qualitative interviews confirming it was unhelpful, creates a stronger case than data or intuition alone.

Product thinking means balancing user needs with business objectives, technical constraints, and market context when making design decisions. For example, a designer with product thinking doesn't just make a feature look good — they question whether the feature should exist, who it serves, and how its success will be measured before designing anything.

Effective design workshops use structured activities to align teams, generate ideas, and make decisions collaboratively. For example, a Design Sprint workshop uses Day 1 for mapping the problem, Day 2 for sketching solutions, Day 3 for deciding on one direction, Day 4 for prototyping, and Day 5 for testing with real users — compressing months of work into one week.

Journey orchestration coordinates and personalizes user experiences across multiple channels and touchpoints in real time. For example, when a user abandons a cart on the website, journey orchestration might trigger a personalized push notification 30 minutes later, followed by an email with a discount the next morning — all coordinated to feel seamless rather than repetitive.

Design maturity is assessed by evaluating the organization's design processes, tooling, team structure, and measurable business impact. For example, a company at Level 1 maturity has no design system and no user research practice, while a Level 5 company has a fully governed design system, dedicated research team, and design metrics tied directly to business KPIs.

Behavioral design applies psychology and behavioral economics principles to influence user actions. For example, showing "Only 3 left in stock!" on a product page uses Scarcity principle; displaying "4,200 people bought this today" uses Social Proof; and offering a free trial uses Loss Aversion — all behavioral design techniques that drive conversions.

Mentoring designers involves regular 1:1s, structured feedback on work, stretch assignments, and creating psychological safety to take creative risks. For example, assigning a junior designer to lead a small feature end-to-end with your guidance — letting them make decisions, learn from mistakes, and build confidence — is more effective than simply correcting their work.

Design governance is the set of rules, processes, and ownership structures that maintain design quality and consistency at scale. For example, establishing a Design System Council with representatives from each product team who review and approve new component proposals, deprecate outdated patterns, and communicate changes — ensuring no team goes rogue with inconsistent UI.

Improve conversion rates by reducing friction, clarifying value propositions, optimizing CTAs, and removing distractions from the critical path. For example, removing the "Create Account" requirement from checkout and adding a Guest Checkout option increased conversion by 45% for one major retailer — proving that reducing friction directly impacts revenue.

Inclusive design creates solutions that work for the widest possible range of users, abilities, and contexts. For example, designing captions for all videos benefits not only deaf users but also people watching in noisy environments, non-native speakers, and users who prefer to read — a solution that starts with an edge case and improves the experience for everyone.

Competitive analysis evaluates competitors' products to identify strengths, weaknesses, and design opportunities. For example, analyzing 5 competing food delivery apps across dimensions like onboarding flow length, reordering ease, delivery tracking UX, and payment options — then creating a comparison matrix that reveals gaps your product can fill.

A North Star Metric is the single most important measure of a product's core value delivery to users. For example, Spotify's North Star Metric is "Time Spent Listening" — every design decision from playlist recommendations to the mini-player UX is evaluated against whether it increases the time users spend listening to music.

Align UX with business goals by connecting design outcomes to measurable business KPIs. For example, framing a redesigned onboarding flow not just as "better UX" but as "reducing 7-day churn by 15% which retains an estimated 2,400 users per month at $29/month ARR" — translating design value into language that resonates with business stakeholders.