Streaming long operations in NextJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is streaming in the context of Next.js long operations?

Streaming means sending parts of the response to the user as soon as they are ready, instead of waiting for the whole operation to finish. This helps users see progress faster.

intermediate

Which Next.js feature helps implement streaming for server components?

Next.js uses React Server Components with streaming support to send HTML chunks progressively to the browser during long operations.

beginner

Why is streaming better than waiting for the full response in long operations?

Streaming improves user experience by showing partial content early, reducing perceived wait time and keeping the interface responsive.

intermediate

How can you handle loading states when using streaming in Next.js?

You can use React Suspense boundaries to show fallback UI while waiting for streamed content to arrive.

advanced

What role do server actions play in streaming long operations in Next.js 14+?

Server actions can trigger long operations on the server and stream results back to the client incrementally, improving responsiveness.

What does streaming in Next.js help improve?

A Static site generation speed

B Only backend server speed

C User experience by showing content progressively

D Database query optimization

Streaming sends parts of the response early, so users see content faster and experience less waiting.

Which React feature is commonly used with streaming in Next.js?

A React Suspense

B React Context

C React Router

D React Hooks

React Suspense allows showing fallback UI while waiting for streamed content.

In Next.js streaming, what is sent to the browser progressively?

A CSS files

B HTML chunks

C JavaScript bundles

D Images

Streaming sends HTML chunks progressively so the page renders bit by bit.

What Next.js version introduced server actions that help with streaming?

A 14+

B 12

C 10

D 13

Next.js 14+ includes server actions that can trigger streaming long operations.

What is a key benefit of streaming long operations?

A Better SEO only

B Faster database writes

C Smaller bundle size

D Reduced perceived wait time

Streaming reduces the time users feel they wait by showing partial results early.

Explain how streaming works in Next.js for long operations and why it improves user experience.

Think about how users see content bit by bit instead of waiting for everything.

Describe how server actions in Next.js 14+ can be used with streaming to handle long-running tasks.

Focus on how server actions and streaming work together to send data early.

Practice

1. What is the main benefit of using streaming in Next.js for long operations?

easy

A. Users see data progressively, reducing perceived wait time.

B. It automatically caches all data on the server.

C. It compresses data to reduce bandwidth usage.

D. It prevents any errors during data fetching.

Solution

1. Step 1: Understand streaming purpose

   Streaming sends data in chunks so users can see progress during long operations.

2. Step 2: Identify user experience impact

   This reduces the perceived wait time by showing partial results early.

3. Final Answer:

   Users see data progressively, reducing perceived wait time. -> Option A

4. Quick Check:

   Streaming improves user experience = A [OK]

Hint: Streaming shows partial data early to users [OK]

Common Mistakes:

• Thinking streaming caches data automatically
• Confusing streaming with data compression
• Assuming streaming prevents all errors

2. Which syntax correctly creates a streaming response in a Next.js API route?

easy

A. const stream = new ReadableStream({ start(controller) { controller.enqueue('data'); controller.close(); } }); return new Response(stream);

B. const stream = new StreamReader(); stream.push('data'); return stream;

C. const stream = new WritableStream(); stream.write('data'); return stream;

D. const stream = new ReadableStream(); stream.send('data'); return stream;

Solution

1. Step 1: Recall correct ReadableStream usage

   ReadableStream requires a start method with a controller to enqueue data and close the stream.

2. Step 2: Match syntax with Next.js streaming pattern

   const stream = new ReadableStream({ start(controller) { controller.enqueue('data'); controller.close(); } }); return new Response(stream); uses controller.enqueue and controller.close correctly and returns a Response wrapping the stream.

3. Final Answer:

   const stream = new ReadableStream({ start(controller) { controller.enqueue('data'); controller.close(); } }); return new Response(stream); -> Option A

4. Quick Check:

   ReadableStream with controller.enqueue = B [OK]

Hint: Use ReadableStream with start(controller) and enqueue [OK]

Common Mistakes:

• Using WritableStream instead of ReadableStream
• Calling non-existent methods like send() or push()
• Not closing the stream after enqueue

3. Given this Next.js API route code, what will the client receive?

export async function GET() {
  const stream = new ReadableStream({
    async start(controller) {
      controller.enqueue(new TextEncoder().encode('Hello '));
      await new Promise(r => setTimeout(r, 1000));
      controller.enqueue(new TextEncoder().encode('World!'));
      controller.close();
    }
  });
  return new Response(stream);
}

medium

A. Only "Hello " is received; stream never closes.

B. "Hello World!" received in two chunks with 1 second delay between.

C. "Hello World!" received all at once after 1 second delay.

D. Syntax error due to missing await in controller.enqueue.

Solution

1. Step 1: Analyze streaming behavior

   The stream first sends "Hello " immediately, then waits 1 second before sending "World!".

2. Step 2: Understand client reception

   The client receives data in two chunks with a delay, then the stream closes properly.

3. Final Answer:

   "Hello World!" received in two chunks with 1 second delay between. -> Option B

4. Quick Check:

   Streaming sends chunks with delay = C [OK]

Hint: Streaming sends chunks as they enqueue, not all at once [OK]

Common Mistakes:

• Assuming all data arrives after delay
• Thinking stream never closes
• Confusing async enqueue with syntax error

4. What is wrong with this Next.js streaming code snippet?

export async function GET() {
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue('Data chunk');
      // Missing controller.close()
    }
  });
  return new Response(stream);
}

medium

A. ReadableStream cannot be used in Next.js API routes.

B. controller.enqueue must be async function.

C. The stream never closes, causing the client to wait indefinitely.

D. Response must be wrapped in JSON.stringify.

Solution

1. Step 1: Check stream lifecycle

   The code enqueues data but does not call controller.close(), so the stream stays open.

2. Step 2: Understand client impact

   The client waits forever for the stream to end, causing a hang or timeout.

3. Final Answer:

   The stream never closes, causing the client to wait indefinitely. -> Option C

4. Quick Check:

   Missing controller.close() = stream hangs [OK]

Hint: Always call controller.close() after enqueueing all data [OK]

Common Mistakes:

• Forgetting to close the stream
• Thinking enqueue must be async
• Misunderstanding Response usage

5. You want to stream a large list of items from a Next.js API route, sending each item as JSON chunk. Which approach correctly streams the data without blocking the client?

hard

A. Send each item with separate fetch requests instead of streaming.

B. Convert entire list to JSON string, enqueue once, then close the stream.

C. Use WritableStream to write each JSON chunk and return it directly.

D. Use ReadableStream with async start(controller), loop over items, enqueue JSON strings, and close after all.

Solution

1. Step 1: Understand streaming large data

   Streaming each item as JSON chunk progressively sends data without waiting for all items.

2. Step 2: Identify correct streaming pattern

   Using ReadableStream with async start allows looping over items, enqueueing each chunk, then closing the stream.

3. Step 3: Evaluate other options

   A requires multiple requests (inefficient); B sends all data at once (no streaming benefit); C uses wrong WritableStream type.

4. Final Answer:

   Use ReadableStream with async start(controller), loop over items, enqueue JSON strings, and close after all. -> Option D

5. Quick Check:

   Stream chunks in loop with ReadableStream = D [OK]

Hint: Stream each item chunk inside async start, then close stream [OK]

Common Mistakes:

• Sending all data at once, losing streaming benefit
• Using WritableStream instead of ReadableStream
• Making multiple fetch calls instead of streaming