Course contentsShow
← React
Lesson 1578 of 2,39639. Server Components in PracticeFree lesson

Multiple Async Components in Parallel

Multiple server components can fetch data in parallel; React coordinates their resolution.

Multiple Async Components in Parallel

What you'll learn: How React automatically coordinates multiple server components fetching data at the same time, eliminating sequential waterfalls.

The Parallel Execution Model

When you have multiple async server components in your tree, React doesn't wait for one to finish before starting the next — it kicks them all off simultaneously. This is a fundamental shift from traditional component patterns where data fetching often happened in sequence.

Think of it like a restaurant kitchen: instead of one chef preparing appetizers, then waiting to start the main course, multiple chefs work on different dishes at the same time. The meal comes together when everything's ready.

How React Coordinates Resolution

// These components fetch in parallel automatically
async function UserProfile({ userId }) {
  const user = await db.users.find(userId);
  return <div>{user.name}</div>;
}

async function UserPosts({ userId }) {
  const posts = await db.posts.findByUser(userId);
  return <PostList posts={posts} />;
}

// Parent component
export default function UserPage({ userId }) {
  return (
    <div>
      <UserProfile userId={userId} />
      <UserPosts userId={userId} />
    </div>
  );
}

When UserPage renders, React initiates both UserProfile and UserPosts fetches at the same time. It doesn't wait for the profile to load before starting the posts query. React coordinates their resolution behind the scenes, and the page appears when both are ready.

This happens automatically — no Promise.all(), no manual orchestration. You just write async components and compose them naturally.

The Performance Win

Without this parallelism, you'd face sequential waterfalls: fetch user, then fetch posts. With parallel server components, total loading time equals your slowest fetch, not the sum of all fetches.

Key Takeaway: Multiple async server components automatically fetch data in parallel — React coordinates their resolution, giving you waterfall-free data loading without manual orchestration.