← Apple Interview InsightsFrontend Engineer

Apple·Frontend Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say
May 2026

Summary

Apple frontend interview that went deep on React architecture. The RSC vs Client Components question was basically the whole technical conversation, and it covered a lot more ground than I expected.

Questions Asked (2)

Q1

Walk me through the differences between React Server Components and Client Components. How do they each work, where do they run, and how do you decide which to use?

Technical Trade-offsSystem Design
Author's notes

Started okay with the basics: server components run on the server, no useState or useEffect, can hit the database or filesystem directly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining React Server Components (RSC) and Client Components in terms of where they run and their capabilities, then contrast their rendering and interaction models. Finally, explain a decision framework based on data fetching, interactivity, and performance needs, using examples to illustrate trade-offs.

Pro tip: Emphasize that RSC reduce bundle size by keeping dependencies on the server, but you must carefully manage the boundary between server and client to avoid over-fetching or losing interactivity. At Apple, where performance and seamless UX are critical, highlight how you'd measure and optimize this boundary.

1. Define RSC and Client Components

Clearly state that RSC run only on the server, have no state or lifecycle, and can directly access backend resources. Client Components run in the browser (and server for SSR), handle interactivity, and use hooks like useState and useEffect.

2. Explain rendering and execution

Describe how RSC are rendered on the server to a special format (e.g., React Flight) and streamed to the client, while Client Components are rendered on both server (for initial HTML) and client (for hydration and interactivity).

3. Discuss data fetching and dependencies

Highlight that RSC can fetch data directly without exposing API keys or adding to the client bundle, whereas Client Components typically fetch data via APIs and include their dependencies in the bundle.

4. Outline decision criteria

Explain that you choose RSC for static content, data fetching, and reducing bundle size, and Client Components for interactivity, browser APIs, and stateful logic. Mention that you can compose them, with RSC as parents and Client Components as leaves.

5. Address trade-offs and best practices

Discuss trade-offs like increased server load, complexity in state management, and the need for clear boundaries. Mention best practices such as keeping Client Components small, using Suspense for loading states, and avoiding unnecessary client-side JavaScript.

Key Points to Mention

  • RSC never ship to the client, reducing bundle size and improving load performance.
  • Client Components are necessary for interactivity, state, effects, and browser-only APIs.
  • RSC can access server-side resources directly (databases, file system) without an API layer.
  • The 'use client' directive marks the boundary where client-side code begins.
  • Composition patterns: RSC can import and render Client Components, but not vice versa (except via children props).
  • Performance implications: RSC enable streaming and selective hydration, but overuse of Client Components can bloat the bundle.

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

Q2

What are the common mistakes engineers make when placing 'use client' boundaries in a Next.js app, and how do you think about props serialization across that boundary?

Technical Trade-offsAPI & Integrations
Author's notes

This was a follow-up and I did not see it coming.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by acknowledging that 'use client' boundaries are about optimizing the server-client split, then discuss common mistakes like over-using 'use client' at the root or passing non-serializable props. Emphasize a mental model of pushing boundaries as low as possible and designing props to be serializable, with trade-offs around performance and developer experience.

Pro tip: Frame the discussion around the cost of crossing the boundary: every serialized prop adds to the RSC payload, so treat it like an API contract. Mention that Apple values performance and predictability, so highlight how you measure and minimize boundary crossings.

1. Define the boundary's purpose

Explain that 'use client' marks a subtree as interactive, so boundaries should be placed at the leaves where interactivity is needed, not at the root. This minimizes client bundle size and maximizes server rendering.

2. Identify common mistakes

List mistakes: marking entire pages or layouts as client, passing functions or class instances as props, over-serializing large data, and not leveraging server components for data fetching. Also mention forgetting that context providers need client boundaries.

3. Explain props serialization rules

Describe that props crossing the boundary must be serializable: primitives, arrays, plain objects, Dates, and Promises are allowed; functions, Symbols, and class instances are not. Emphasize that serialization has a cost in payload size and parsing time.

4. Discuss trade-offs and strategies

Talk about strategies like passing server-fetched data as props, using children prop to compose server components inside client components, and using serializable identifiers instead of complex objects. Mention measuring with React DevTools and Next.js bundle analyzer.

5. Conclude with a mental model

Summarize your approach: treat the boundary as an API, design props for serialization, and push boundaries down. Highlight that this improves performance, maintainability, and aligns with React's server-first philosophy.

Key Points to Mention

  • Over-using 'use client' at the root causes unnecessary client-side JavaScript and hydration.
  • Props must be serializable: no functions, class instances, or Symbols; Dates and Promises are okay.
  • Serialization cost: large props increase RSC payload and slow down initial load.
  • Use the children prop to pass server components into client components without serializing them.
  • Context providers and hooks require client boundaries, so place them strategically.
  • Measure boundary impact with React DevTools, Next.js bundle analyzer, and performance profiling.

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