Blog | loke.dev

React Server Components (RSC) represent one of the most significant shifts in React's architecture since the introduction of Hooks. This new paradigm fundamentally changes how we think about building React applications by allowing components to render on the server, with zero JavaScript sent to the client for server-only components.

In this comprehensive guide, I'll explain what React Server Components are, how they work, and how you can leverage them in your applications today.

What Are React Server Components?

React Server Components are a new architectural pattern that allows React components to be rendered entirely on the server. Unlike traditional server-side rendering (SSR), which renders components to HTML on the server but still sends the component JavaScript to the client for hydration, Server Components can stay on the server completely.

This creates a clear separation between:

Server Components: Render on the server and have access to server-side resources
Client Components: Render on the client and can be interactive

The key innovation is that these component types can be composed together in the same component tree, creating a seamless developer experience while optimizing for performance.

The Benefits of React Server Components

1. Reduced JavaScript Bundle Size

With Server Components, only the necessary JavaScript for interactivity is sent to the client. Components that don't need interactivity stay on the server, resulting in smaller bundles and faster page loads.

2. Direct Access to Backend Resources

Server Components can directly access databases, file systems, and other server-only resources without creating API endpoints:

// This component runs only on the server
async function UserProfile({ userId }) {
  // Direct database access without an API
  const user = await db.users.findUnique({ where: { id: userId } })
 
  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.bio}</p>
      <ClientSideInteractiveComponent userId={user.id} />
    </div>
  )
}

3. Automatic Code Splitting

The React Server Components architecture automatically handles code splitting at the component level, sending only the JavaScript needed for the current view.

4. Improved Loading States

Server Components enable streaming rendering, allowing the UI to progressively load as data becomes available, creating a more responsive user experience.

5. Better Developer Experience

The unified component model allows developers to think in terms of components without worrying about the client/server boundary for every piece of UI.

How React Server Components Work

To understand RSC, let's look at the core technical concepts:

The Component Rendering Process

When a request comes in, the server renders the component tree
Server Components are executed and their output is serialized
Client Components are identified and their code is bundled
The server sends a special RSC payload containing:
- The rendered output of Server Components
- References to Client Components that need to be hydrated
- Data needed by those Client Components
The client receives this payload and reconstructs the UI, hydrating only the Client Components

The RSC Payload

The RSC payload is not HTML, but a special format that contains the rendered output of Server Components along with references to Client Components. This allows the client to reconstruct the component tree without needing the Server Component code.

Using Server Components in Next.js

Next.js 13+ has integrated React Server Components as the default rendering strategy in the App Router. Here's how to use them:

Server Components (Default)

In Next.js App Router, all components are Server Components by default:

// app/users/[id]/page.js
// This is a Server Component by default
export default async function UserPage({ params }) {
  const user = await fetchUser(params.id)
 
  return (
    <div className="user-profile">
      <h1>{user.name}</h1>
      <UserDetails user={user} />
      <UserActivity userId={user.id} />
    </div>
  )
}

Server Components can:

Fetch data directly
Access backend resources
Use async/await
Cannot use hooks like useState or useEffect
Cannot use browser-only APIs

Client Components

To make a component render on the client, add the "use client" directive at the top of the file:

// components/UserActivityChart.jsx
'use client'
 
import { useEffect, useState } from 'react'
import { Chart } from 'chart.js'
 
export default function UserActivityChart({ data }) {
  const [activeTab, setActiveTab] = useState('weekly')
 
  useEffect(() => {
    // Initialize chart with data
    const chart = new Chart(/* ... */)
 
    return () => chart.destroy()
  }, [data, activeTab])
 
  return (
    <div>
      <div className="tabs">
        <button
          onClick={() => setActiveTab('weekly')}
          className={activeTab === 'weekly' ? 'active' : ''}
        >
          Weekly
        </button>
        <button
          onClick={() => setActiveTab('monthly')}
          className={activeTab === 'monthly' ? 'active' : ''}
        >
          Monthly
        </button>
      </div>
      <canvas id="activity-chart" />
    </div>
  )
}

Client Components can:

Use React hooks (useState, useEffect, etc.)
Add event listeners and interactivity
Access browser-only APIs
Cannot use async/await directly in the component body
Cannot directly access backend resources

Composing Server and Client Components

The real power of RSC comes from how you can compose them together:

// Server Component
export default async function Dashboard({ userId }) {
  // Data fetching on the server
  const user = await fetchUser(userId)
  const stats = await fetchUserStats(userId)
 
  return (
    <div className="dashboard">
      <h1>Welcome back, {user.name}</h1>
 
      {/* Server Component */}
      <UserInfoCard user={user} />
 
      {/* Client Component */}
      <InteractiveChart data={stats.chartData} />
 
      {/* Server Component with a Client Component child */}
      <ActivityFeed>
        <FilterControls /> {/* Client Component */}
      </ActivityFeed>
    </div>
  )
}

Patterns and Best Practices

1. Moving State Down

Keep as much of your UI as Server Components as possible, and only use Client Components when necessary:

// ❌ Making the entire component a Client Component
'use client'
function SearchPage() {
  const [query, setQuery] = useState('')
 
  return (
    <div>
      <h1>Search Results</h1>
      <input value={query} onChange={(e) => setQuery(e.target.value)} />
      <SearchResults query={query} /> {/* This could be a Server Component */}
    </div>
  )
}
 
// ✅ Only making the interactive parts Client Components
// SearchPage.jsx (Server Component)
function SearchPage() {
  return (
    <div>
      <h1>Search Results</h1>
      <SearchBox /> {/* Client Component */}
      <Suspense fallback={<ResultsSkeleton />}>
        <SearchResults /> {/* Server Component */}
      </Suspense>
    </div>
  )
}
 
// SearchBox.jsx
;('use client')
function SearchBox() {
  const [query, setQuery] = useState('')
  const router = useRouter()
 
  const handleSearch = () => {
    router.push(`/search?q=${query}`)
  }
 
  return (
    <div>
      <input value={query} onChange={(e) => setQuery(e.target.value)} />
      <button onClick={handleSearch}>Search</button>
    </div>
  )
}

2. Using the Suspense Boundary

Suspense is a key part of the RSC architecture, allowing for streaming rendering:

import { Suspense } from 'react'
 
function ProfilePage({ username }) {
  return (
    <div>
      <h1>{username}'s Profile</h1>
 
      <Suspense fallback={<ProfileSkeleton />}>
        <ProfileDetails username={username} />
      </Suspense>
 
      <Suspense fallback={<ActivitySkeleton />}>
        <UserActivity username={username} />
      </Suspense>
 
      <Suspense fallback={<RecommendationsSkeleton />}>
        <Recommendations username={username} />
      </Suspense>
    </div>
  )
}

This pattern allows parts of the UI to load as their data becomes available, rather than waiting for all data to load.

3. Sharing State Between Client Components

When you need to share state between Client Components that are separated by Server Components, you can use:

URL State: Store state in the URL using the router
Context Providers: Create a Client Component context provider
Third-party State Management: Libraries like Zustand or Jotai

Example with a context provider:

// UserProvider.jsx
'use client'
 
import { createContext, useContext, useState } from 'react'
// Layout.jsx (Server Component)
import { UserProvider, useUser } from './UserProvider'
 
const UserContext = createContext(null)
 
export function UserProvider({ children }) {
  const [user, setUser] = useState(null)
 
  return (
    <UserContext.Provider value={{ user, setUser }}>
      {children}
    </UserContext.Provider>
  )
}
 
export function useUser() {
  return useContext(UserContext)
}
 
export default function Layout({ children }) {
  return <UserProvider>{children}</UserProvider>
}
 
// ProfileButton.jsx (Client Component)
;('use client')
 
export function ProfileButton() {
  const { user } = useUser()
 
  return <button>{user ? user.name : 'Sign In'}</button>
}

Performance Considerations

1. Data Fetching

With Server Components, data fetching should happen on the server whenever possible:

// ✅ Fetch data in Server Components
async function ProductList() {
  const products = await fetchProducts()
 
  return (
    <div>
      {products.map((product) => (
        <ProductCard key={product.id} product={product} />
      ))}
    </div>
  )
}
 
// ❌ Avoid fetching in Client Components when possible
;('use client')
function ProductList() {
  const [products, setProducts] = useState([])
 
  useEffect(() => {
    fetchProducts().then(setProducts)
  }, [])
 
  return (
    <div>
      {products.map((product) => (
        <ProductCard key={product.id} product={product} />
      ))}
    </div>
  )
}

2. Component Granularity

Be thoughtful about your component boundaries:

// ❌ Making a large component a Client Component
"use client"
function ProductPage({ productId }) {
  const [quantity, setQuantity] = useState(1);
 
  return (
    <div>
      <h1>Product Title</h1>
      <p>Product description...</p>
      <img src="/product.jpg" alt="Product" />
      <div>
        <input
          type="number"
          value={quantity}
          onChange={(e) => setQuantity(Number(e.target.value))}
        />
        <button>Add to Cart</button>
      </div>
    </div>
  );
}
 
// ✅ Only making the interactive part a Client Component
function ProductPage({ productId }) {
  const product = await fetchProduct(productId);
 
  return (
    <div>
      <h1>{product.title}</h1>
      <p>{product.description}</p>
      <img src={product.image} alt={product.title} />
      <AddToCartForm product={product} />
    </div>
  );
}
 
// AddToCartForm.jsx
"use client"
function AddToCartForm({ product }) {
  const [quantity, setQuantity] = useState(1);
 
  return (
    <div>
      <input
        type="number"
        value={quantity}
        onChange={(e) => setQuantity(Number(e.target.value))}
      />
      <button>Add to Cart</button>
    </div>
  );
}

Common Challenges and Solutions

1. Handling Forms

Forms often require both server and client components:

// ContactForm.jsx (Client Component)
'use client'
 
import { useState } from 'react'
 
export function ContactForm() {
  const [formData, setFormData] = useState({
    name: '',
    email: '',
    message: '',
  })
 
  const handleChange = (e) => {
    setFormData({
      ...formData,
      [e.target.name]: e.target.value,
    })
  }
 
  const handleSubmit = async (e) => {
    e.preventDefault()
 
    const response = await fetch('/api/contact', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(formData),
    })
 
    if (response.ok) {
      // Handle success
    }
  }
 
  return (
    <form onSubmit={handleSubmit}>
      <input
        name="name"
        value={formData.name}
        onChange={handleChange}
        placeholder="Your name"
      />
      <input
        name="email"
        type="email"
        value={formData.email}
        onChange={handleChange}
        placeholder="Your email"
      />
      <textarea
        name="message"
        value={formData.message}
        onChange={handleChange}
        placeholder="Your message"
      />
      <button type="submit">Send Message</button>
    </form>
  )
}
 
// page.jsx (Server Component)
export default function ContactPage() {
  return (
    <div>
      <h1>Contact Us</h1>
      <p>Fill out the form below to get in touch with our team.</p>
      <ContactForm />
    </div>
  )
}

For server actions (in Next.js 14+), you can use the new action pattern:

// actions.js
'use server'
 
import { useFormState } from 'react-dom'
import { submitContact } from './actions'
 
export async function submitContact(formData) {
  const name = formData.get('name')
  const email = formData.get('email')
  const message = formData.get('message')
 
  // Server-side validation
  if (!name || !email || !message) {
    return { error: 'All fields are required' }
  }
 
  // Save to database
  await db.contact.create({
    data: { name, email, message },
  })
 
  return { success: true }
}
 
// ContactForm.jsx (Client Component)
;('use client')
 
export function ContactForm() {
  const [state, formAction] = useFormState(submitContact, {})
 
  return (
    <form action={formAction}>
      {state.error && <p className="error">{state.error}</p>}
      {state.success && <p className="success">Message sent successfully!</p>}
 
      <input name="name" placeholder="Your name" />
      <input name="email" type="email" placeholder="Your email" />
      <textarea name="message" placeholder="Your message" />
      <button type="submit">Send Message</button>
    </form>
  )
}

2. Authentication

Authentication often requires both server and client components:

// auth.js
'use server'
 
import { useState } from 'react'
// page.jsx (Server Component)
import { redirect } from 'next/navigation'
import { signIn } from 'next-auth/react'
import { getSession } from './auth'
import { LoginForm } from './LoginForm'
 
export async function getSession() {
  // Server-side session check
  const session = await getServerSession()
  return session
}
 
// LoginForm.jsx (Client Component)
;('use client')
 
export function LoginForm() {
  const [credentials, setCredentials] = useState({
    email: '',
    password: '',
  })
 
  const handleSubmit = async (e) => {
    e.preventDefault()
    await signIn('credentials', {
      email: credentials.email,
      password: credentials.password,
      redirect: true,
      callbackUrl: '/dashboard',
    })
  }
 
  return <form onSubmit={handleSubmit}>{/* Form fields */}</form>
}
 
export default async function LoginPage() {
  const session = await getSession()
 
  if (session) {
    redirect('/dashboard')
  }
 
  return (
    <div>
      <h1>Login</h1>
      <LoginForm />
    </div>
  )
}

Conclusion: The Future of React Development

React Server Components represent a significant evolution in how we build React applications. By allowing components to render on the server while maintaining React's component model, RSC offers the best of both worlds: the performance benefits of server rendering with the developer experience of React.

As this pattern matures, we can expect to see:

More frameworks adopting RSC beyond Next.js
New patterns and best practices emerging
Tools and libraries optimized for the RSC architecture
Improved performance metrics across React applications

Whether you're building a new application or planning to migrate an existing one, understanding React Server Components is becoming essential for modern React development.

What has your experience been with React Server Components? Have you encountered any challenges or discovered useful patterns? Share your thoughts in the comments below!

Want to learn more about modern React development? Check out my other articles on React, Next.js, and frontend architecture.

Understanding React Server Components - A Comprehensive Guide