Implementing Loading UI and Streaming in Next.js 14

Anton Ioffe - November 13th 2023 - 10 minutes read

Modern web development continuously evolves to meet user expectations for lightning-fast experiences—and Next.js is at the forefront of this revolution. In the hands of a skilled developer, Next.js 14 unlocks a new realm of possibilities for improving the perceived performance of web applications. Through this advanced walkthrough, we'll explore the sophisticated art of implementing dynamic Loading UIs, the transformative power of streaming and efficient data fetching, the architectural elegance of Server Components, and the resilience of sophisticated loading state management. We'll even demystify the act of refactoring your current projects to harness the full potential of the latest features, like the 'app' directory and Turbopack. Prepare to elevate your understanding of these technologies and discover strategies that blend performance with user experience to create web applications that are not just faster, but smarter.

Strategies for Implementing Dynamic Loading UIs in Next.js 14

In the realm of modern web development, crafting a dynamic Loading UI is essential to sustain user engagement during inevitable data fetching operations. While React.lazy is a staple for lazy-loading client-side components, it does not support server components. Instead, for server-side rendering in Next.js 14, we utilize next/dynamic which provides an API adapted for this environment. This allows developers to defer the inclusion of components until they are actually needed, optimizing performance while offering a seamless user experience. Below is a typical pattern for implementing a dynamic import with next/dynamic:

import dynamic from 'next/dynamic';
const DynamicComponent = dynamic(() => import('./Component'), { suspense: true });

function MyComponent() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <DynamicComponent />

Integrating a skeleton screen as a placeholder effectively bridges the gap between the initiation of data fetching and content presentation. Such placeholders are visually akin to the anticipated content, minimizing perception of delay and aligning with the application's design lexicon:

const SkeletonArticle = () => (
  <div className='skeleton-wrapper'>
    <div className='skeleton-title'></div>
    <div className='skeleton-text'></div>
    // Repeat as needed to mimic the content layout

Alternatively, a spinner or progress bar can serve as immediate visual acknowledgment that data retrieval is underway. These should be assimilated tastefully within the application's stylistic frame:

<Suspense fallback={<CustomSpinner />}>
  <DynamicComponent />

However, judicious use of such visual aids is paramount. Excessive indicators could inadvertently encumber the user interface and encroach upon the user experience. A less obtrusive yet equally informative approach is generally preferred.

A conundrum worth considering hinges on user network variance: Should a singular global loading interface be employed, or do staggered loading states at the component level better serve a diverse internet landscape? This decision will be informed by the intended demographic and their respective online conditions, and it should shape the way Loading UI components are orchestrated within a Next.js 14 application.

Maximizing Efficiency with Next.js 14 Streaming and Data Fetching

Next.js 14 enhances the streaming capabilities and data fetching performance by introducing incremental streaming of server-rendered HTML. This allows for content to be delivered to the client in chunks, improving TTFB and providing an immediate FCP. The benefits are particularly apparent on slower networks or less powerful devices, where efficient chunk delivery can substantially improve the user experience.

Consider the following updated example, which leverages Next.js 14's streaming server-side rendering in a server component with React 18's Suspense:

// app/user-profile/page.server.js
import React, { Suspense } from 'react';
import UserProfileData from '../components/user-profile-data.server';
import { fetchUserProfileData } from '../../lib/api';

export default function UserProfilePage() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <UserProfileData userData={fetchUserProfileData()} />

In this code, the Suspense component from React 18 wraps the server-rendered UserProfileData. It uses a promise to fetch user profile data that gets streamed to the component, displaying a loading placeholder until the data arrives. This method offers a declarative approach for handling asynchronous operations and managing loading states within server-rendered components.

Further improving on server component usage, Next.js 14 ensures that server components efficiently ship minimal JavaScript to the client, enabling faster page interactivity:

// components/user-profile-data.server.js
export default function UserProfileData({ userData }) {
  return (

This server component is sent to the client with no JavaScript overhead. Should client-side interactivity be required, it can be progressively enhanced on the client using client-side components.

For handling client-side state and events, specific client components can be utilized:

// components/user-profile-interactive.client.js
import { useState } from 'react';

export default function UserProfileInteractive() {
  const [userDetails, setUserDetails] = useState(null);

  async function handleUserUpdate() {
    const updatedUserData = await fetch('/api/update-user-profile', {
      method: 'POST',
    }).then(res => res.json());


  // Omitted: interactive component rendering with event handlers

This snippet shows a client-side component where interactive features are handled post-initial load. By communicating with API endpoints, it helps maintain the application's interactive nature while benefiting from the server-side rendering performance.

Next.js 14's strategy for efficiently updating static content is to intelligently revalidate and refresh the content in the background through incremental static regeneration (ISR). ISR minimizes user experience disruption and conserves server resources. In tandem with streaming SSR, ISR enhances content freshness without the need for full page reloads, striking a balance between server efficiency and user experience.

Balancing Modularity and Performance with Next.js 14 Server Components

In the latest iteration of Next.js, Server Components provide an essential enhancement to web application performance. Leveraging Server Components allows parts of the interface to execute on the server, render to static HTML, and send minimal JavaScript necessary for interactivity to the client. This approach significantly benefits performance metrics, as the server outputs HTML directly to the browser, leading to a speedy initial render. With JavaScript payload reduced, metrics such as Time to Interactive (TTI) improve, which is crucial for a smooth user experience on varying network conditions and device capabilities.

Yet, embracing Server Components involves weighing certain trade-offs against their performance benefits. These components lack access to browser APIs and cannot use client-centric React hooks directly within their implementation. Therefore, adopting Server Components necessitates a review and potential refactoring of existing components to align with server-centric logic, which might introduce additional developmental overhead.

To illustrate, we might refactor a static navigation bar without client-side interactivity to be a Server Component, as shown in this example:

// Navigation.server.js
import React from 'react';

export default function Navigation() {
  return (
        <li><a href="/home">Home</a></li>
        <li><a href="/about">About</a></li>
        <li><a href="/contact">Contact</a></li>

The navigation bar is sent to the client as lean HTML with the promise of supplementary interactivity via hydration, should you decide to enrich it later with interactive Client Components.

Nevertheless, as Server Components change the landscape of state management, developers must mitigate complexity by judiciously employing patterns such as prop cascading or React Server Context. This is crucial to avoid convoluted propagation of state which can also make debugging a more challenging task, considering both server and client execution contexts.

When considering the adoption of Server Components, developers face a strategic decision: devising an application architecture that maintains a sustainable balance between performance optimization and code maintainability. It's not always advantageous to opt for Server Components, particularly for parts of the application that necessitate swift client-side updates. Discerning the right solution requires careful deliberation over the modularity granularity and the immediacy of client interactions.

The key question for developers is this: At what point does the reduction in initial load time provided by a Server Component justify the possible deferred interactivity of a Client Component? Striking this equilibrium involves a nuanced understanding of the complex trade-offs between delivering high-performance applications and fulfilling the dynamic user interaction expectations characteristic of today's web landscape.

Effective Management of Loading States and Error Handling in Next.js 14

Managing loading states effectively in Next.js 14 requires the use of built-in features and custom logic to create a resilient user experience. Utilizing the Suspense component is a forward-thinking approach. Consider wrapping components that are responsible for fetching data within Suspense and providing a graceful UI as fallback. Here's a high-quality, real-world example of how Suspense can be implemented:

import { Suspense } from 'react';
import { FetchTrendingMovies } from './components/FetchTrendingMovies';
import { LoadingAnimation } from './components/LoadingAnimation';

function App() {
  return (
    <Suspense fallback={<LoadingAnimation />}>
      <FetchTrendingMovies />

In the above snippet, a LoadingAnimation is displayed while FetchTrendingMovies is loading. This ensures the user is aware that the application is processing their request, even under slow network conditions.

Error boundaries in React are essential in handling unexpected JavaScript errors in a component tree. They prevent the entire React component tree from unmounting when an error occurs. In Next.js 14, employ error boundaries around potentially unstable components. A simple error boundary can be created as follows:

class ErrorBoundary extends React.Component {
  constructor(props) {
    this.state = { hasError: false };

  static getDerivedStateFromError(error) {
    return { hasError: true };

  componentDidCatch(error, errorInfo) {
    // You might want to log these errors to an error reporting service

  render() {
    if (this.state.hasError) {
      // Render fallback UI
      return <h1>Something went wrong.</h1>;

    return this.props.children;

When integrating error boundaries with Suspense, wrap the suspenseful component within the error boundary. This combination ensures the application can handle both loading and error states effectively. Take note that error boundaries do not catch errors inside event handlers, asynchronous code (e.g., setTimeout or requestAnimationFrame callbacks), server-side rendering, or errors thrown in the error boundary itself (rather than its children).

  <Suspense fallback={<LoadingAnimation />}>
    <FetchTrendingMovies />

Another key practice is to cater to varying loading times by implementing progressive loading states. Start with the bare minimum interface essential for the application and enhance the UI step-by-step as each chunk of data is loaded. This approach can keep the user engaged and decrease their perception of waiting.

A common coding mistake is to implement a global loading state, which freezes the entire application UI. This can be alienating when parts of the page can be interacted with or are already available to the user. Instead, target the specific UI sections that need to signal the loading state:

function UserProfile({ userId }) {
  const user = fetchUser(userId);
  const posts = fetchPosts(userId);

  return (
      <Suspense fallback={<LoadingAnimation />}>
        <UserProfileComponent user={user} />
        <Suspense fallback={<LoadingAnimation />}>
          <UserPostsComponent posts={posts} />

The structure above signals loading states only in the particular UI components affected by data fetching operations, enhancing the overall user experience. Consider these strategies and implementations to manage loading states and error scenarios in your Next.js 14 applications. How can your current application benefit from these techniques, and how might they influence your approach to handling asynchronous operations?

Refactoring for Next.js 14: Migrating to App Directory and Embracing Turbopack

Refactoring your existing Next.js application to align with the latest Next.js 14 features demands a thoughtful approach, especially when adopting the new app directory structure and faster build processes afforded by Turbopack. The app directory marks a paradigm shift in routing and efficiency for development. Transitioning involves the creation of specific files like layout.js and loading.js that are central to managing UI and loading states. It's essential to place shared components within the app folder to utilize layout composition and maintain state consistency across your application.

// Before: _app.js with shared components and state
function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />;

// After: app/root-layout.js managing shared components and state across routes
export default function RootLayout({ children }) {
  // RootLayout manages global components such as Navbar and Footer,
  // offering a receptacle (`{children}`) for route-specific content
  return (
      <Navbar />
      <Footer />

Turbopack, currently in its alpha phase in Next.js 14, is not recommended for production yet. However, trying out Turbopack with the command next dev --turbo can showcase faster development builds. Be cautious and evaluate the impact on your development cycle, noting that the production stability of Turbopack will continue to improve.

Adopting a gentle and tiered approach to refactoring components, beginning with less complex ones and scaling up the complexity, is crucial. This ensures components remain modular and rollbacks are manageable, fostering a secure adoption process.

As you incrementally migrate, keep vigilance on the performance and stability aspects of your application. While the allure of Turbopack's rapid development cycles is strong, remember that its full maturity for production is on the horizon. Testing should be at the forefront to fully understand the benefits and weigh them against potential risks when considering a production rollout.

Throughout this transition, it’s vital to maintain a focus on the legibility and maintainability of your codebase. Complex optimizations could overshadow the simplicity of the code; therefore, clarity, thorough documentation, and adherence to established coding standards are paramount. These practices cement a consistent development experience and ease the team's transition to Next.js 14’s novel file organization and routing methodologies.

// Next.js 14 migration annotation example emphasizing process documentation
  Next.js 14 Migration Notes:
  - Transitioned to the 'app' directory for enhanced routing and state management.
  - Tested Turbopack alpha to accelerate the development build process, monitoring its readiness for production use.
  - Refactored components incrementally, ensuring modularity and comprehensibility are preserved.
  - Emphasized code clarity and meticulous documentation as part of quality assurance during the transition.


In this article about implementing Loading UI and Streaming in Next.js 14, the author explores various strategies to enhance the perceived performance of web applications. They discuss implementing dynamic Loading UIs using next/dynamic, maximizing efficiency with Next.js 14 Streaming and Data Fetching, balancing modularity and performance with Server Components, and effective management of loading states and error handling. The article also highlights the importance of refactoring existing applications to leverage the new features of Next.js 14, such as the 'app' directory and Turbopack. The key takeaway is that by employing these strategies and features, developers can create web applications that are not just faster but smarter. The challenging task for readers is to refactor their existing Next.js applications to incorporate the new features and optimize their performance.