Zero bundle size for server components in NextJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does "Zero bundle size for server components" mean in Next.js?

It means server components do not add any JavaScript to the client bundle. They run only on the server, so the client downloads less code, making the app faster.

beginner

Why do server components have zero bundle size on the client?

Because server components render HTML on the server and send it to the client without sending their JavaScript code, so no client-side JavaScript is needed for them.

intermediate

How does zero bundle size for server components improve user experience?

It reduces the amount of JavaScript the browser downloads and runs, leading to faster page loads and less CPU work on the user's device.

intermediate

Can server components use client-side hooks like useState or useEffect?

No, server components cannot use client-side hooks because they run only on the server and do not have access to browser APIs or client state.

advanced

What happens if you import a client component inside a server component in Next.js?

The client component and its JavaScript will be bundled and sent to the client, but the server component itself remains zero bundle size.

What is the main benefit of zero bundle size for server components?

A Makes the server components run on the client

B Allows using client-side hooks on the server

C Enables offline support automatically

D Faster page loads by sending less JavaScript to the client

Zero bundle size means no JavaScript for server components is sent to the client, reducing load time.

Where do server components run in Next.js?

A Both server and client

B Only on the server

C Only on the client

D In the browser's service worker

Server components run only on the server and send rendered HTML to the client.

Which hook is NOT allowed in server components?

A useState

B useMemo

C useCallback

D useServerAction

useState is a client-side hook and cannot be used in server components.

If a server component imports a client component, what happens?

A Client component code is bundled and sent to the client

B Client component code stays on the server

C Server component loses zero bundle size

D The app crashes

Client components are bundled for the client even if imported by server components.

Zero bundle size helps improve which of the following?

A Server CPU usage

B Database query speed

C JavaScript bundle size on the client

D CSS styling

Zero bundle size means less JavaScript sent to the client, improving bundle size.

Explain how zero bundle size for server components works and why it matters for web performance.

Think about what code the browser downloads and runs.

Describe the difference between server components and client components in Next.js regarding bundling and execution.

Focus on where the code runs and what is sent to the browser.

Practice

1. What is the main benefit of using server components in Next.js with zero bundle size?

easy

A. They send no JavaScript to the browser, reducing bundle size and improving load speed.

B. They allow client-side interactivity without any server code.

C. They automatically cache data on the client for offline use.

D. They enable real-time updates without refreshing the page.

Solution

1. Step 1: Understand server components behavior

   Server components run only on the server and do not send JavaScript to the browser.

2. Step 2: Identify the benefit of zero bundle size

   Because no JavaScript is sent, the bundle size is smaller, which improves page load speed.

3. Final Answer:

   They send no JavaScript to the browser, reducing bundle size and improving load speed. -> Option A

4. Quick Check:

   Zero bundle size = faster load [OK]

Hint: Server components send zero JS to browser, so bundle size shrinks [OK]

Common Mistakes:

• Thinking server components run on the client
• Assuming server components add client interactivity
• Confusing caching with zero bundle size

2. Which of the following is the correct way to declare a server component in Next.js to ensure zero bundle size?

easy

A. "use client"; export default function MyComponent() { return <div>Hello</div>; }

B. "use server"; export default function MyComponent() { return <div>Hello</div>; }

C. export default function MyComponent() { return <div>Hello</div>; }

D. import React from 'react'; export default function MyComponent() { return <div>Hello</div>; }

Solution

1. Step 1: Identify server component syntax

   By default, components without "use client" directive are server components in Next.js.

2. Step 2: Check the options for client/server directives

   export default function MyComponent() { return <div>Hello</div>; } has no "use client" directive, so it is a server component with zero bundle size.

3. Final Answer:

   export default function MyComponent() { return <div>Hello</div>; } -> Option C

4. Quick Check:

   No "use client" means server component [OK]

Hint: No "use client" means server component with zero bundle size [OK]

Common Mistakes:

• Adding "use client" which makes it a client component
• Using "use server" which is not a valid directive
• Assuming import React affects server/client distinction

3. Given this Next.js server component code, what will be sent to the browser?

export default function Greeting() {
  const message = 'Hello from server';
  return <h1>{message}</h1>;
}

medium

A. An HTML <h1> element with text 'Hello from server' and no JavaScript bundle.

B. An empty page because server components do not render anything.

C. An HTML <h1> element plus JavaScript to hydrate the component on the client.

D. A JavaScript bundle only, no HTML content.

Solution

1. Step 1: Understand server component rendering

   Server components render HTML on the server and send only HTML to the browser, no JS bundle.

2. Step 2: Analyze the code output

   The component returns an <h1> with the message string, so the browser receives that HTML.

3. Final Answer:

   An HTML <h1> element with text 'Hello from server' and no JavaScript bundle. -> Option A

4. Quick Check:

   Server component sends HTML only [OK]

Hint: Server components send HTML only, no JS bundle [OK]

Common Mistakes:

• Thinking server components send JS for hydration
• Assuming server components render nothing
• Confusing client components with server components

4. You wrote this server component in Next.js:

"use client";
export default function UserName() {
  const name = fetchUserName();
  return <div>{name}</div>;
}

What is the main issue here?

medium

A. Missing async keyword on the function causes fetchUserName() to fail.

B. Using "use client" makes it a client component, but fetchUserName() is a server-only function causing an error.

C. Server components cannot return JSX elements.

D. The component will work fine with zero bundle size.

Solution

1. Step 1: Identify component type from directive

   "use client" makes this a client component, so server-only functions like fetchUserName() cannot run here.

2. Step 2: Understand server-only function usage

   fetchUserName() likely fetches data on the server, so calling it in a client component causes an error.

3. Final Answer:

   Using "use client" makes it a client component, but fetchUserName() is a server-only function causing an error. -> Option B

4. Quick Check:

   Client component cannot call server-only functions [OK]

Hint: Client components cannot run server-only functions [OK]

Common Mistakes:

• Forgetting "use client" changes component type
• Assuming fetchUserName() works on client
• Thinking async keyword fixes server/client mismatch

5. You want to build a Next.js page that fetches user data from a database and displays it without sending any JavaScript to the browser. Which approach ensures zero bundle size for this page?

hard

A. Fetch data in getStaticProps and pass it to a client component.

B. Create a client component with "use client" that fetches data using useEffect and displays it.

C. Create a server component but add "use client" to enable interactivity.

D. Create a server component that fetches data inside and returns JSX, without "use client" directive.

Solution

1. Step 1: Identify zero bundle size requirement

   Zero bundle size means no JavaScript sent to browser, so no client components.

2. Step 2: Choose correct data fetching method

   Fetching data inside a server component without "use client" sends only HTML with data, no JS bundle.

3. Step 3: Evaluate other options

   Client components or getStaticProps with client components send JS bundles, so they don't meet zero bundle size.

4. Final Answer:

   Create a server component that fetches data inside and returns JSX, without "use client" directive. -> Option D

5. Quick Check:

   Server component + data fetch = zero bundle size [OK]

Hint: Use server component with data fetch, no "use client" [OK]

Common Mistakes:

• Adding "use client" which sends JS bundle
• Using client-side data fetching hooks
• Assuming getStaticProps alone ensures zero bundle size