Zero bundle size for server components in NextJS

Introduction

Server components let you run code only on the server, so your web page sends less code to the browser. This makes your app faster and smaller.

When you want to fetch data securely without exposing API keys to the browser.

When you want to keep heavy logic or libraries only on the server to reduce client load.

When you want to improve page load speed by sending less JavaScript to the user.

When you want to separate UI parts that don't need interactivity from those that do.

When you want to build SEO-friendly pages with server-rendered content.

Syntax

NextJS

export default function MyServerComponent() {
  // This code runs only on the server
  return <div>Hello from server!</div>;
}

Server components are React components that run only on the server.

They do not include client-side JavaScript in the browser bundle.

Examples

A simple server component that renders a paragraph.

NextJS

export default function ServerComponent() {
  return <p>Rendered on server only</p>;
}

Server component can fetch data securely on the server before rendering.

NextJS

import { fetchData } from '@/lib/data';

export default async function ServerComponent() {
  const data = await fetchData();
  return <pre>{JSON.stringify(data, null, 2)}</pre>;
}

Client components include "use client" directive and run in the browser.

NextJS

"use client";

export default function ClientComponent() {
  return <button>Click me</button>;
}

Sample Program

This server component fetches a user name on the server and renders a greeting. No JavaScript for this component is sent to the browser, so the page loads faster.

NextJS

import React from 'react';

// This is a server component
export default async function Greeting() {
  // Simulate fetching user name on server
  const userName = await Promise.resolve('Alice');

  return (
    <main>
      <h1>Hello, {userName}!</h1>
      <p>This text is rendered on the server only.</p>
    </main>
  );
}

Important Notes

Server components cannot use browser-only APIs like window or document.

They help reduce the JavaScript bundle size sent to the client.

Use client components only when you need interactivity like event handlers.

Summary

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

This reduces bundle size and improves page load speed.

Use server components for static or data-fetching UI parts without interactivity.

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