# React 19 Suspense en Concurrent Rendering: Streaming SSR en Sollicitatievragen 2026

> Uitgebreide handleiding over React 19 Suspense, Concurrent Rendering en Streaming SSR. Inclusief praktische codevoorbeelden en veelgestelde sollicitatievragen voor 2026.

- Published: 2026-08-21
- Updated: 2026-08-21
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

React 19 markeert een keerpunt in de ontwikkeling van moderne webapplicaties. Met de stabilisatie van Suspense voor data fetching en verbeteringen aan Concurrent Rendering kunnen ontwikkelaars nu reactieve gebruikersinterfaces bouwen die sneller laden en vloeiender reageren. Streaming SSR maakt het mogelijk om HTML-fragmenten progressief naar de browser te sturen voordat alle data beschikbaar is. Dit artikel behandelt de kernconcepten, praktische implementaties en de meest gestelde sollicitatievragen over deze onderwerpen in 2026.

> **Suspense is meer dan alleen een ladindicator**
>
> Terwijl veel ontwikkelaars Suspense alleen kennen als wrapper voor fallback-UIs, ligt de echte kracht in de coördinatie van asynchrone operaties. React kan hiermee prioriteren welke delen van de UI als eerste gerenderd moeten worden, wat een optimale gebruikerservaring garandeert zelfs bij trage netwerkverbindingen. In combinatie met Server Components wordt Suspense het centrale bouwblok van moderne React-architecturen.

## Grondbeginselen van React Suspense in Versie 19

Suspense stelt React-componenten in staat om te "wachten" op asynchrone operaties zonder complexe state management-logica te implementeren. Het concept is gebaseerd op het principe dat componenten tijdens het laden een Promise kunnen "gooien", die React opvangt en een fallback toont.

Het basisgebruik van Suspense is gestabiliseerd sinds React 18, maar React 19 brengt belangrijke verbeteringen. De integratie met Server Components is nu naadloos, en de nieuwe `use`-hook maakt directe Promise-afhandeling binnen componenten mogelijk.

```tsx
import { Suspense, use } from 'react';

interface User {
  id: string;
  name: string;
  email: string;
}

function UserProfile({ userPromise }: { userPromise: Promise<User> }) {
  const user = use(userPromise);
  
  return (
    <div className="p-4 border rounded-lg">
      <h2 className="text-xl font-bold">{user.name}</h2>
      <p className="text-gray-600">{user.email}</p>
    </div>
  );
}

function UserProfileSkeleton() {
  return (
    <div className="p-4 border rounded-lg animate-pulse">
      <div className="h-6 bg-gray-200 rounded w-32 mb-2" />
      <div className="h-4 bg-gray-200 rounded w-48" />
    </div>
  );
}

export default function ProfilePage() {
  const userPromise = fetchUser('123');
  
  return (
    <Suspense fallback={<UserProfileSkeleton />}>
      <UserProfile userPromise={userPromise} />
    </Suspense>
  );
}
```

Het fundamentele verschil met traditionele state-gebaseerde data fetching ligt in de declarativiteit. De component beschrijft alleen wat het nodig heeft, niet hoe de data geladen moet worden. React neemt de coördinatie van het laadproces over.

## Concurrent Rendering en de Impact

Concurrent Rendering is geen enkele feature, maar een fundamentele verschuiving in hoe React rendering-werk prioriteert en onderbreekt. Traditioneel blokkeerde een rendering-operatie de Main Thread totdat deze voltooid was. Met Concurrent Rendering kan React rendering-werk pauzeren om urgentere updates zoals gebruikersinteracties te verwerken.

De praktische effecten zijn vooral zichtbaar bij complexe UIs. Als een gebruiker typt tijdens een intensieve rendering-operatie, kan React de toetsenbordinvoer prioriteren en de oorspronkelijke rendering later hervatten.

```tsx
import { useState, useTransition, useDeferredValue } from 'react';

function SearchResults({ query }: { query: string }) {
  // Expensive computation or data fetching
  const results = searchDatabase(query);
  
  return (
    <ul className="space-y-2">
      {results.map(result => (
        <li key={result.id} className="p-2 hover:bg-gray-100">
          {result.title}
        </li>
      ))}
    </ul>
  );
}

export function SearchPage() {
  const [query, setQuery] = useState('');
  const [isPending, startTransition] = useTransition();
  const deferredQuery = useDeferredValue(query);
  
  const handleSearch = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    setQuery(value); // Immediate update for input
    
    startTransition(() => {
      // Deferred update for expensive rendering
    });
  };
  
  return (
    <div className="p-4">
      <input
        type="text"
        value={query}
        onChange={handleSearch}
        placeholder="Zoeken..."
        className="w-full p-2 border rounded"
      />
      
      <div className={isPending ? 'opacity-50' : ''}>
        <Suspense fallback={<div>Resultaten laden...</div>}>
          <SearchResults query={deferredQuery} />
        </Suspense>
      </div>
    </div>
  );
}
```

De combinatie van `useTransition` en `useDeferredValue` maakt fijnmazige controle over rendering-prioriteiten mogelijk. `useTransition` markeert state-updates als niet-urgent, terwijl `useDeferredValue` een vertraagde waarde levert die kan achterlopen bij hoge belasting.

## Streaming SSR met React Server Components

Streaming SSR revolutioneert de server-side rendering-tijd. In plaats van te wachten op alle data om vervolgens een volledige HTML-pagina te versturen, begint React onmiddellijk met het streamen van HTML-fragmenten. Zodra een Suspense-boundary wordt opgelost, stuurt de server de corresponderende HTML.

In Next.js 16 met App Router is Streaming SSR standaard ingeschakeld. Elke Server Component binnen een Suspense-boundary wordt automatisch gestreamd.

```tsx
// app/dashboard/page.tsx
import { Suspense } from 'react';

async function RevenueChart() {
  const data = await fetchRevenueData(); // 2 seconden
  
  return (
    <div className="bg-white p-6 rounded-lg shadow">
      <h3 className="font-semibold mb-4">Omzet</h3>
      <Chart data={data} />
    </div>
  );
}

async function RecentOrders() {
  const orders = await fetchRecentOrders(); // 500ms
  
  return (
    <div className="bg-white p-6 rounded-lg shadow">
      <h3 className="font-semibold mb-4">Recente Bestellingen</h3>
      <OrderList orders={orders} />
    </div>
  );
}

export default function DashboardPage() {
  return (
    <div className="grid grid-cols-2 gap-6 p-6">
      <Suspense fallback={<ChartSkeleton />}>
        <RevenueChart />
      </Suspense>
      
      <Suspense fallback={<OrdersSkeleton />}>
        <RecentOrders />
      </Suspense>
    </div>
  );
}
```

De browser ontvangt eerst de layout-HTML met beide skeletons. Zodra `RecentOrders` gereed is (na 500ms), streamt de server de HTML en een script dat de skeleton vervangt. `RevenueChart` volgt na 2 seconden. De Time To First Byte (TTFB) verbetert drastisch omdat de server onmiddellijk begint met verzenden.

## Foutafhandeling met Error Boundaries

Suspense en Error Boundaries werken samen om zowel laad- als fouttoestanden declaratief af te handelen. In React 19 kunnen Error Boundaries ook asynchrone fouten opvangen die tijdens server-side rendering optreden.

```tsx
'use client';

import { Component, ReactNode } from 'react';

interface Props {
  children: ReactNode;
  fallback: ReactNode;
}

interface State {
  hasError: boolean;
  error: Error | null;
}

export class AsyncErrorBoundary extends Component<Props, State> {
  constructor(props: Props) {
    super(props);
    this.state = { hasError: false, error: null };
  }

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

  render() {
    if (this.state.hasError) {
      return this.props.fallback;
    }
    return this.props.children;
  }
}

// Gebruik met Suspense
function DataSection() {
  return (
    <AsyncErrorBoundary
      fallback={
        <div className="p-4 bg-red-50 border border-red-200 rounded">
          <p className="text-red-700">Fout bij het laden van data</p>
          <button
            onClick={() => window.location.reload()}
            className="mt-2 text-red-600 underline"
          >
            Opnieuw proberen
          </button>
        </div>
      }
    >
      <Suspense fallback={<DataSkeleton />}>
        <AsyncDataComponent />
      </Suspense>
    </AsyncErrorBoundary>
  );
}
```

De hiërarchie is belangrijk: Error Boundaries moeten Suspense-boundaries omvatten zodat fouten tijdens data fetching correct worden opgevangen. Anders kan een fout de hele pagina laten crashen.

## Optimalisatiepatronen voor Productie

In productieomgevingen vereisen Suspense en Streaming SSR zorgvuldige optimalisatie. Te veel Suspense-boundaries kunnen leiden tot een "popcorn-effect" waarbij content ongecoördineerd verschijnt. Te weinig betekent langere wachttijden.

```tsx
// Geoptimaliseerde structuur met strategische boundaries
export default function ProductPage({ productId }: { productId: string }) {
  return (
    <div className="container mx-auto">
      {/* Kritieke content - wordt direct gestreamd */}
      <Suspense fallback={<ProductHeaderSkeleton />}>
        <ProductHeader productId={productId} />
      </Suspense>
      
      {/* Secundaire content - gegroepeerd in één boundary */}
      <Suspense fallback={<ProductDetailsSkeleton />}>
        <ProductDescription productId={productId} />
        <ProductSpecifications productId={productId} />
        <ProductPricing productId={productId} />
      </Suspense>
      
      {/* Tertiaire content - kan vertraagd laden */}
      <Suspense fallback={<ReviewsSkeleton />}>
        <ProductReviews productId={productId} />
      </Suspense>
    </div>
  );
}
```

Prefetching speelt een kritieke rol bij performance. Met React Server Components kunnen data al geladen worden voordat de gebruiker navigeert.

```tsx
import { prefetch } from 'react-router';
import Link from 'next/link';

function ProductCard({ product }: { product: Product }) {
  const handleMouseEnter = () => {
    // Prefetch bij hover
    prefetch(`/products/${product.id}`);
  };

  return (
    <Link
      href={`/products/${product.id}`}
      onMouseEnter={handleMouseEnter}
      className="block p-4 border rounded hover:shadow-lg transition"
    >
      <img src={product.image} alt={product.name} />
      <h3>{product.name}</h3>
      <p>{product.price}</p>
    </Link>
  );
}
```

## Veelgestelde Sollicitatievragen over Suspense en Concurrent Rendering

Technische sollicitatiegesprekken in 2026 testen regelmatig het begrip van deze concepten. Hier zijn de belangrijkste vragen met antwoorden.

**Vraag: Wat is het verschil tussen useTransition en useDeferredValue?**

`useTransition` wordt gebruikt om state-updates als niet-urgent te markeren. Het retourneert een `isPending`-flag en een `startTransition`-functie. `useDeferredValue` daarentegen accepteert een waarde en retourneert een vertraagde versie die kan achterlopen bij hoge rendering-belasting. `useTransition` is voor eigen state-updates, `useDeferredValue` voor props of externe waarden.

**Vraag: Hoe werkt Streaming SSR technisch?**

Streaming SSR gebruikt HTTP Transfer-Encoding: chunked. De server stuurt eerst het HTML-skelet met Suspense-fallbacks. Wanneer een component gereed is, stuurt de server een HTML-fragment samen met een inline `<script>`-tag die de placeholder in de DOM vervangt. De browser verwerkt deze chunks progressief.

**Vraag: Wanneer moet Suspense vermeden worden?**

Suspense is niet ideaal voor zeer kleine hoeveelheden data die synchroon in de cache beschikbaar zouden moeten zijn. Voor kritieke above-the-fold content moet de initiële HTML-response compleet zijn. Ook voor formulieren met optimistische updates zijn andere patterns zoals `useOptimistic` beter geschikt.

**Vraag: Hoe gedraagt Suspense zich met Error Boundaries?**

Error Boundaries vangen fouten op die tijdens rendering optreden, inclusief fouten in Promises die door Suspense-compatibele bronnen worden gegooid. De boundary moet het Suspense-element omvatten om zowel render-fouten als fetch-fouten op te vangen.

**Vraag: Wat is het Selective Hydration-mechanisme?**

Selective Hydration stelt React in staat om delen van de pagina onafhankelijk van elkaar te hydraten. Als een gebruiker interacteert met een nog niet gehydrateerd gebied, prioriteert React de hydratie daarvan. Dit combineert met Suspense Boundaries: elke boundary kan onafhankelijk worden gehydrateerd.

## Conclusie

React 19 met Suspense en Concurrent Rendering biedt krachtige tools voor moderne webapplicaties. Streaming SSR verkort de tijd tot de eerste zichtbare weergave aanzienlijk, terwijl Concurrent Rendering de responsiviteit van de applicatie verbetert. Het begrijpen van deze concepten is essentieel voor zowel dagelijks ontwikkelwerk als technische sollicitatiegesprekken. De combinatie van declaratieve data fetching, strategische Suspense-boundaries en geoptimaliseerde streaming maakt gebruikerservaringen mogelijk die een paar jaar geleden nog ondenkbaar waren.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/nl/blog/react-next/react-19-suspense-concurrent-rendering-streaming-ssr