Frontend School

Dynamic Candidate Pipeline Dashboard

Machine Coding
hard

Dynamic Candidate Pipeline Dashboard

Hard
Data Table
Sorting
Filtering
React
Frontend

Overview

LinkedIn's Talent Solutions empower recruiters to efficiently manage their hiring pipelines. A crucial component of this suite is an interactive dashboard that provides a consolidated view of job applications. This problem challenges you to build a core feature of such a dashboard, enabling recruiters to quickly find, sort, and filter through a dynamic dataset of candidate applications.

What you need to do / Task

Your goal is to implement a React component that displays a list of job applications in a table, allowing users to interactively sort and filter the data. The application data will be provided as a static mock dataset.

  1. Render Application Data: Display the provided mock Application data in a well-structured HTML table.
  2. Client-Side Sorting: Implement sorting functionality for the 'Applicant Name', 'Status', and 'Last Updated' columns. Clicking a column header should toggle between ascending and descending order. The current sort direction should be indicated visually (e.g., with an arrow icon).
  3. Client-Side Filtering: Implement two filter controls:
    • Applicant Name Search: A free-text input field that filters the table rows to show only applications where the applicant's name (case-insensitive) contains the entered text.
    • Status Filter: A dropdown (select) that allows filtering applications by their status (e.g., 'Applied', 'Interviewing', 'Offer Extended', 'Rejected', 'Hired'). An 'All Statuses' option should be available to clear this filter.
  4. Combined Logic: Ensure that sorting and filtering work together seamlessly. Filters should apply first, and then the visible data should be sorted.
  5. Application Count: Display the total number of applications currently visible in the table (after all filters and sorting have been applied).

UI/UX expectations

  • Layout: A clear header for the dashboard, filter controls positioned above the table, and the table itself. Ensure basic readability and spacing.
  • Interactions: Clicking a sortable column header should visually indicate the active sort order. Typing in the name filter or selecting a status should immediately update the table.
  • Accessibility: Basic keyboard navigation should be supported for filter inputs and sortable column headers (e.g., using tabIndex and onKeyDown for sorting). aria-label and aria-sort attributes should be used where appropriate.

Acceptance criteria

  • The table successfully renders all initial mock application data.
  • Clicking on 'Applicant Name', 'Status', or 'Last Updated' column headers sorts the data correctly in both ascending and descending order.
  • Typing text into the 'Applicant Name' filter instantly updates the table to show matching applications (case-insensitive).
  • Selecting an option from the 'Status' filter instantly updates the table to show applications with the chosen status.
  • Applying both name and status filters simultaneously yields the correct intersection of results.
  • The displayed count of applications accurately reflects the number of rows currently visible in the table after filtering.
  • The UI provides clear visual feedback for the active sort column and direction.

Constraints

Constraints & assumptions

  • Data Source: All application data is provided client-side as a static array in App.tsx. No API calls are required.
  • Processing: All sorting and filtering must be performed client-side using JavaScript/TypeScript.
  • Data Size: The mock dataset will contain up to ~1000 records. Performance should be considered for this scale, though extreme optimizations are not expected within the time limit.
  • Technology: Use React functional components and hooks (useState, useMemo are highly recommended for performance and state management).
  • Styling: Basic CSS is provided; focus on functional correctness and clear layout over pixel-perfect design.

Out of scope

  • Pagination or infinite scrolling.
  • Server-side sorting or filtering.
  • Complex UI libraries (e.g., Material UI, Ant Design) – use native HTML elements and basic CSS.
  • Advanced accessibility features beyond the basic requirements listed.
  • Real-time data updates or WebSocket integration.

What interviewers evaluate

  • Correctness and Robustness: The accuracy of sorting and filtering logic, especially when combined.
  • Code Quality: Readability, maintainability, adherence to React best practices, and effective use of hooks.
  • Performance: Efficient state management and avoidance of unnecessary re-renders for a moderately sized dataset.
  • Problem Solving: Ability to break down the problem, manage complexity, and deliver a functional solution within the time constraints.

Loading editor...