Zero bundle size for server components in NextJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark a component as a server component in Next.js.

NextJS

"use client" directive is for client components, so for server components, [1] at the top.

Drag options to blanks, or click blank then click option'

Ano directive (default)

B"use server"

C"server component"

D"client component"

Attempts:

3 left

💡 Hint

Common Mistakes

Using "use server" (that's for Server Actions)

Using "use client" which bundles to client

In Next.js App Router, components are server components by default with no directive. This ensures zero bundle size on the client as they render entirely on the server. "use server" is reserved for Server Actions.

2fill in blank

medium

Complete the code to import a server component correctly without increasing client bundle size.

NextJS

import ServerComponent from '[1]';

Drag options to blanks, or click blank then click option'

A./ServerComponent.server

B./ServerComponent.client

C./ServerComponent

Dnext/server

Attempts:

3 left

💡 Hint

Common Mistakes

Importing from a .client file which increases bundle size

Using a generic import without suffix causing confusion

A common convention is to use the .server file suffix for server-only components. This clarifies intent and helps avoid accidental client bundling, contributing to zero client bundle size.

3fill in blank

hard

Fix the error in this server component export to ensure zero client bundle size.

NextJS

export default function [1]() { return <div>Server Component</div>; }

Drag options to blanks, or click blank then click option'

AClientComponent

BuseServerComponent

CuseClientComponent

DServerComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Naming the component as a client component causing confusion

Adding "use client" directive

Naming the function ServerComponent clarifies its role as a server component. Ensure no "use client" directive is present in the file for zero client bundle size.

4fill in blank

hard

Fill both blanks to create a server component that fetches data without adding to client bundle size.

NextJS

export default async function [1]() {
  const data = await fetch('[2]');
  return <div>{JSON.stringify(data)}</div>;
}

Drag options to blanks, or click blank then click option'

AServerDataComponent

Bhttps://api.example.com/data

Chttps://client.api.com/data

DClientDataComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using client component names

Fetching from client-side only URLs

The component is named ServerDataComponent (server by default) and fetches data from a server API URL on the server side. No client bundle increase since it runs server-only.

5fill in blank

hard

Fill all three blanks to create a server component that imports a client component and passes data correctly.

NextJS

import ClientComponent from [1];

export default async function [2]() {
  const data = await fetch('[3]');
  return <ClientComponent data={data} />;
}

Drag options to blanks, or click blank then click option'

A"./ClientComponent.client"

BServerWithClient

Chttps://api.example.com/info

D"./ClientComponent.server"

Attempts:

3 left

💡 Hint

Common Mistakes

Importing client component from a server file suffix

Using wrong component names

Fetching from incorrect URLs

The server component (default) imports the client component from a .client file (convention), fetches serializable data on the server from an API, and passes it as props to the client component. Keeps client bundle minimal.

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