← DoorDash Interview Insights

DoorDash·Frontend Engineer·Onsite - Coding / Algorithms·Senior

Senior
Apr 2026

Summary

DoorDash frontend coding round, building on top of a prior phone screen project. Three features to implement in TypeScript, and the scope felt manageable until I actually started thinking through the tag filtering logic.

Questions Asked (3)

Q1

Add three filter buttons to an existing list page that filter results based on values from an API response.

API & IntegrationsTechnical Trade-offs
Author's notes

Pretty straightforward on the surface.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: which fields to filter on, whether filters are single or multi-select, and how they interact. Then outline a component design that fetches filter options from the API, manages filter state, and triggers a refetch or client-side filtering of the list. Emphasize clean separation of concerns, loading/error states, and performance considerations like debouncing and caching.

Pro tip: Mention that you would derive filter options from the same API response used for the list to avoid extra network calls, and use URL query params to make filter state shareable and bookmarkable—this shows you think about UX and deep linking.

1. Clarify requirements and constraints

Ask about the filter fields, whether they are single or multi-select, if filtering is server-side or client-side, and how filters combine (AND/OR).

2. Design the component structure

Plan a FilterButtons component that receives options and selected values as props, and a parent container that manages state and data fetching.

3. Implement data fetching and state management

Fetch filter options from the API (or derive from list response), store selected filters in state, and trigger a refetch or filter the list when selections change.

4. Handle edge cases and UX

Add loading indicators, error handling, empty states, and debouncing to prevent excessive API calls. Ensure accessibility with proper button roles and keyboard navigation.

5. Optimize and test

Consider caching filter options, memoizing filtered results, and writing unit tests for filter logic and integration tests for the interaction.

Key Points to Mention

  • Server-side vs client-side filtering trade-offs (performance, data freshness, complexity)
  • State management: local state vs URL query params for shareable filters
  • API integration: fetching filter options, handling loading/error states, and avoiding redundant calls
  • Performance: debouncing, caching, and memoization to reduce re-renders and network requests
  • Accessibility: semantic HTML, ARIA attributes, and keyboard support for filter buttons
  • Testing: unit tests for filter logic and integration tests for user interactions

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

Add a new filter category that supports multi-tag selection with AND/OR semantics.

Technical Trade-offsAPI & Integrations
Author's notes

This is where I actually slowed down.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints, then propose a data model and UI for multi-tag selection with AND/OR semantics. Discuss the trade-offs between client-side and server-side filtering, and outline an API contract that supports the semantics efficiently. Finally, address edge cases and performance considerations.

Pro tip: Demonstrate awareness of real-world constraints like URL state persistence, debouncing, and caching to show you think beyond the happy path. Mention how you'd handle large datasets and ensure the solution scales.

1. Clarify Requirements

Ask questions to understand the exact use case: which filters, expected data volume, and whether AND/OR applies within a category or across categories. Confirm if the filter should be shareable via URL and if real-time updates are needed.

2. Design Data Model & UI

Propose a data structure for selected tags and the logical operator (e.g., { category: 'cuisine', tags: ['Italian', 'Mexican'], operator: 'OR' }). Sketch a UI that allows toggling between AND/OR and selecting multiple tags.

3. Define API Contract

Outline how the frontend will communicate with the backend: either send the full filter object or encode it in query params. Discuss pagination, caching, and how to handle complex queries efficiently.

4. Discuss Trade-offs

Compare client-side vs. server-side filtering: client-side is faster for small datasets but limited; server-side scales but adds latency. Consider hybrid approaches and how to optimize performance.

5. Address Edge Cases & Testing

Cover scenarios like no tags selected, conflicting operators, and error handling. Mention testing strategies: unit tests for logic, integration tests for API, and E2E tests for UI.

Key Points to Mention

  • Data structure for multi-tag selection with AND/OR operator
  • API design: query parameters vs. request body, and how to represent AND/OR
  • Performance considerations: debouncing, caching, pagination, and server-side filtering
  • URL state persistence for shareable filters
  • Trade-offs between client-side and server-side filtering
  • Edge cases: empty selection, conflicting operators, and error states

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

Implement a 'See More' / 'See Less' toggle button that expands and collapses a truncated list.

Technical Trade-offs
Author's notes

Easiest of the three.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then walk through a component design that balances usability, performance, and accessibility. Discuss trade-offs between CSS-only, React state, and virtualized rendering approaches, and justify your choice based on the context (e.g., list size, dynamic content).

Pro tip: Mention that you'd use a CSS line-clamp for the collapsed state to avoid layout thrashing, and only switch to full rendering when expanded—this shows you care about performance without over-engineering.

1. Clarify requirements and constraints

Ask about list size, whether items are dynamic, and if the toggle should be accessible and responsive. This ensures your solution fits the actual use case.

2. Choose an implementation strategy

Decide between CSS-only (e.g., max-height with transition), React state with conditional rendering, or virtualization for large lists. Explain why your choice balances simplicity and performance.

3. Design the component API and state

Define props like initialVisibleCount, items, and onToggle, and manage expanded state internally. Consider controlled vs. uncontrolled component patterns.

4. Address accessibility and UX

Ensure the button has aria-expanded and aria-controls, and that keyboard navigation works. Add smooth transitions and avoid content jumps.

5. Discuss performance and edge cases

Talk about memoization, avoiding unnecessary re-renders, and handling empty or single-item lists. Mention testing strategies for the toggle behavior.

Key Points to Mention

  • Accessibility: aria-expanded, aria-controls, and keyboard support
  • Performance: CSS line-clamp vs. conditional rendering vs. virtualization
  • State management: controlled vs. uncontrolled component, and lifting state
  • UX details: smooth transitions, preserving scroll position, and avoiding layout shifts
  • Edge cases: empty list, single item, dynamic content updates
  • Testing: unit tests for toggle logic and visual regression tests

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.