Streaming with Suspense in NextJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Streaming with Suspense in Next.js?

It is a way to send parts of a page to the browser as soon as they are ready, using React's Suspense to show loading states while waiting for data.

beginner

How does Suspense improve user experience during streaming?

Suspense shows fallback content (like a spinner) while waiting for data, so users see something immediately instead of a blank page.

intermediate

Which Next.js feature enables streaming with Suspense?

Next.js App Router with React Server Components supports streaming with Suspense by default.

intermediate

What role does the Suspense component play in streaming?

It wraps parts of UI that load asynchronously and shows fallback UI until the content is ready to stream.

beginner

Why is streaming with Suspense better than waiting for the whole page to load?

Because it lets users see and interact with parts of the page faster, reducing wait time and improving perceived speed.

What does Suspense show while waiting for data in streaming?

A The full page content immediately

B A blank white screen

C An error message

D Fallback UI like a loading spinner

Suspense shows fallback UI such as a spinner to indicate loading while data is fetched.

Which Next.js feature is required for streaming with Suspense?

A App Router with Server Components

B Pages Router only

C Static Site Generation

D Client-side routing only

Streaming with Suspense works with the App Router and React Server Components in Next.js.

What is the main benefit of streaming pages in Next.js?

A Smaller page size

B Faster content display to users

C No need for CSS

D Automatic SEO optimization

Streaming sends parts of the page as soon as they are ready, so users see content faster.

In React, what does the Suspense component do?

A Shows fallback UI while waiting for async content

B Handles form submissions

C Manages global state

D Fetches data automatically

Suspense wraps async components and shows fallback UI until they finish loading.

Which of these is NOT true about streaming with Suspense?

A It improves perceived page load speed

B It requires React Server Components

C It blocks the entire page until all data loads

D It uses fallback UI during loading

Streaming with Suspense does NOT block the whole page; it streams parts as they load.

Explain how streaming with Suspense works in Next.js and why it improves user experience.

Think about how loading spinners help users while waiting.

Describe the role of the Suspense component in React when used with Next.js streaming.

Focus on what Suspense shows and when.

Practice

1. What is the main purpose of using Suspense in Next.js streaming?

easy

A. To show a fallback UI while waiting for slow components to load

B. To prevent any component from rendering

C. To disable server-side rendering

D. To cache all components on the client

Solution

1. Step 1: Understand Suspense role

   Suspense is used to wrap components that may take time to load, showing a fallback UI meanwhile.

2. Step 2: Identify the purpose in streaming

   In streaming, it helps parts of the page appear quickly by showing placeholders until content is ready.

3. Final Answer:

   To show a fallback UI while waiting for slow components to load -> Option A

4. Quick Check:

   Suspense fallback = show UI while loading [OK]

Hint: Suspense shows fallback UI during loading [OK]

Common Mistakes:

• Thinking Suspense stops rendering completely
• Confusing Suspense with caching
• Assuming Suspense disables server rendering

2. Which of the following is the correct way to use Suspense in a Next.js component?

easy

A. <Suspense><MyComponent fallback="Loading..." /></Suspense>

B. <Suspense fallback="<Loading />"><MyComponent />

C. <Suspense fallback="Loading..."><MyComponent /></Suspense>

D. <Suspense fallback="<Loading />"><MyComponent /></Suspense>

Solution

1. Step 1: Check Suspense syntax

   The Suspense component requires a fallback prop with a React node, and must wrap the child component properly.

2. Step 2: Identify correct JSX structure

   <Suspense fallback="Loading..."><MyComponent /></Suspense> correctly uses fallback="Loading..." and properly closes the Suspense tag.

3. Final Answer:

   <Suspense fallback="Loading..."><MyComponent /></Suspense> -> Option C

4. Quick Check:

   Suspense fallback prop + proper closing = correct syntax [OK]

Hint: Suspense needs fallback prop and closing tag [OK]

Common Mistakes:

• Forgetting to close Suspense tag
• Passing fallback inside child component
• Using fallback as string with JSX tags

3. Given this Next.js component using streaming with Suspense:

import { Suspense } from 'react';

function SlowComponent() {
  return 
Data loaded
;
}

export default function Page() {
  return (
    

      Loading...
}>
        
      
    
  );
}

What will the user see first when this page loads?

medium

A. An error because Suspense cannot be used here

B. The text 'Loading...' immediately, then 'Data loaded' after SlowComponent finishes

C. A blank page until SlowComponent loads

D. Only 'Data loaded' without any loading text

Solution

1. Step 1: Check if SlowComponent suspends

   SlowComponent is synchronous and returns <div>Data loaded</div> immediately without throwing a promise, so Suspense does not trigger fallback.

2. Step 2: Determine initial render behavior

   The entire page renders instantly with 'Data loaded' inside the div. No fallback appears because there is no suspension.

3. Final Answer:

   Only 'Data loaded' without any loading text -> Option D

4. Quick Check:

   No suspend = no fallback, direct content render [OK]

Hint: Suspense fallback only if children suspend (throw promise) [OK]

Common Mistakes:

• Assuming Suspense always shows fallback
• Thinking synchronous components trigger loading
• Expecting streaming without suspend mechanism

4. Identify the error in this Next.js streaming code snippet:

import { Suspense } from 'react';

export default function Page() {
  return (
    <div>
      <Suspense fallback="Loading...">
        <SlowComponent />
      </Suspense>
    </div>
  );
}

function SlowComponent() {
  throw new Promise(resolve => setTimeout(resolve, 1000));
  return <div>Loaded</div>;
}

medium

A. The return statement after throw is unreachable

B. SlowComponent cannot throw a Promise

C. The fallback prop should be a React node, not a string

D. Suspense must be imported from 'next/suspense' not 'react'

Solution

1. Step 1: Spot unreachable code

   The return <div>Loaded</div> after throw is unreachable because the throw executes first.

2. Step 2: Validate other parts

   Import from 'react' is correct; throwing a Promise suspends correctly (though recreating it causes infinite loop here); fallback string is valid ReactNode.

3. Final Answer:

   The return statement after throw is unreachable -> Option A

4. Quick Check:

   throw before return = unreachable [OK]

Hint: Code after throw is unreachable [OK]

Common Mistakes:

• Thinking fallback string causes issues
• Believing components cannot throw Promises
• Wrong import source for Suspense

5. You want to stream two slow components in Next.js with Suspense, showing their fallbacks independently. Which approach correctly achieves this?

hard

A. <Suspense fallback="Loading..."><ComponentA /></Suspense><ComponentB fallback="Loading B..." />

B. <Suspense fallback="Loading A..."><ComponentA /></Suspense><Suspense fallback="Loading B..."><ComponentB /></Suspense>

C. <ComponentA /><ComponentB /> without Suspense

D. <Suspense fallback="Loading A and B..."><ComponentA /><ComponentB /></Suspense>

Solution

1. Step 1: Understand independent Suspense boundaries

   Wrapping each slow component in its own Suspense allows each to show its own fallback independently.

2. Step 2: Analyze options

   <Suspense fallback="Loading A..."><ComponentA /></Suspense><Suspense fallback="Loading B..."><ComponentB /></Suspense> wraps each component separately with distinct fallbacks, enabling independent streaming. <Suspense fallback="Loading A and B..."><ComponentA /><ComponentB /></Suspense> shares one fallback for both, so they load together. <ComponentA /><ComponentB /> without Suspense has no fallback. <Suspense fallback="Loading..."><ComponentA /></Suspense><ComponentB fallback="Loading B..." /> incorrectly uses fallback on a component.

3. Final Answer:

   <Suspense fallback="Loading A..."><ComponentA /></Suspense><Suspense fallback="Loading B..."><ComponentB /></Suspense> -> Option B

4. Quick Check:

   Separate Suspense per component = independent fallbacks [OK]

Hint: Wrap each slow component in its own Suspense [OK]

Common Mistakes:

• Using one Suspense for multiple components expecting separate fallbacks
• Not wrapping slow components in Suspense
• Passing fallback prop to child components