Przejdź do treści

Jak przyspieszyć Next.js za pomocą Streamingu i Suspense?

Maciej Sala

Founder StriveLab

10 min czytaniaAktualizacja

Szybka odpowiedź: jak przyspieszyć Next.js za pomocą streamingu i Suspense?

  • Wolne fragmenty owiń w małe granice <Suspense>, a Next.js wyśle najpierw powłokę i dośle resztę.
  • loading.tsx tworzy taką granicę dla page.tsx i potomków, ale nie dla layout.tsx z tego samego segmentu.
  • Niezależne zapytania uruchamiaj równolegle, żeby nie tworzyć kaskady.
  • Streaming nie przyspiesza samego zapytania, a fallback musi mieć wymiary treści, żeby nie psuć CLS.
  • Przy własnym hostingu sprawdź, czy reverse proxy albo CDN nie buforuje odpowiedzi.

Na czym polega streaming w Next.js?

W klasycznym renderowaniu serwerowym bez mechanizmu streamowania aplikacja musi zebrać wszystkie dane potrzebne do zbudowania całej strony, zanim użytkownik cokolwiek zobaczy. Mimo że same zapytania mogą biec równolegle, pojedyncze wolne oczekiwanie umieszczone wysoko w drzewie komponentów skutecznie blokuje wyrenderowanie wszystkiego poniżej.

Streaming całkowicie zmienia ten model, pozwalając wysłać wstępną powłokę strony wraz z fallbackami, zanim zakończą się wolniejsze operacje, a następnie sukcesywnie uzupełniać treść w miarę gotowości poszczególnych granic. Warto jednak pamiętać, że natychmiastowe ładowanie nie jest dane raz na zawsze, ponieważ czas dotarcia pierwszego fragmentu zależy między innymi od zadań wykonywanych przed granicą, generowania metadanych dla botów oraz pośredniego buforowania po drodze.

Next.js App Router obsługuje streaming natywnie, wykorzystując React Suspense i architekturę Server Components.

Jak działa Suspense w Server Components?

<Suspense> to granica, która mówi Reactowi: „wyświetl fallback (np. skeleton), a gdy dane będą gotowe, wtedy podmień na właściwą treść". Zwykły fetch w useEffect lub handlerze zdarzenia nie uruchamia automatycznie tego fallbacku. Poniższy przykład korzysta z asynchronicznego Server Component.

Przykłady pokazują układ granic: komponenty prezentacyjne, takie jak StatCard, WelcomeBanner i pozostałe sekcje oraz ich importy, są skrótami do implementacji projektu. Adresy api.example.com zastąp własnym API.

Code
// app/dashboard/page.tsx
import { Suspense } from 'react'
import { DashboardStats } from '@/components/DashboardStats'
import { StatsSkeleton } from '@/components/skeletons/StatsSkeleton'
// Importy pozostałych komponentów projektu pominięto.
 
export default function DashboardPage() {
  return (
    <main>
      <h1>Dashboard</h1>
 
      {/* Sekcja statyczna — może znaleźć się w pierwszej powłoce */}
      <WelcomeBanner />
 
      {/* Sekcja dynamiczna — streamowana */}
      <Suspense fallback={<StatsSkeleton />}>
        <DashboardStats />
      </Suspense>
 
      <Suspense fallback={<ChartSkeleton />}>
        <RevenueChart />
      </Suspense>
 
      <Suspense fallback={<TableSkeleton />}>
        <RecentOrders />
      </Suspense>
    </main>
  )
}
Code
// components/DashboardStats.tsx — Server Component z wolnym fetchem
// Import StatCard z projektu pominięto.
export async function DashboardStats() {
  // Załóżmy, że API odpowiada po 2 s — kod nie dodaje sztucznego opóźnienia.
  // Oczekiwanie nie blokuje sekcji poza tą granicą Suspense.
  const response = await fetch('https://api.example.com/stats', {
    cache: 'no-store',
  })
 
  if (!response.ok) {
    throw new Error(`Nie udało się pobrać statystyk: ${response.status}`)
  }
 
  const data = await response.json()
 
  return (
    <div className="grid grid-cols-4 gap-4">
      <StatCard label="Przychód" value={`${data.revenue} PLN`} />
      <StatCard label="Zamówienia" value={data.orders} />
      <StatCard label="Klienci" value={data.customers} />
      <StatCard label="Konwersja" value={`${data.conversion}%`} />
    </div>
  )
}

Kolejność wyświetlania przy Suspense

Niezależne granice Suspense ujawniają się w kolejności, w jakiej spływają ich dane, a nie według ułożenia w drzewie JSX. W sytuacji, kiedy RevenueChart otrzyma dane w 500 ms, a DashboardStats w 2 s, wykres pojawi się jako pierwszy – mimo że w kodzie znajduje się niżej. Każdy blok <Suspense> działa tu jak osobna „wyspa” streamowania.

Nie oznacza to jednak, że struktura JSX nie ma znaczenia. Zagnieżdżona granica nie zostanie pokazana, dopóki nie wyrenderuje się jej granica nadrzędna, a żądanie uruchomione dopiero po zakończeniu pracy innego komponentu wywoła klasyczny waterfall. Granice Suspense decydują więc o tym, kiedy ujawnia się UI, ale to struktura komponentów i miejsce inicjowania zapytań (promise’ów) kontrolują, kiedy te dane w ogóle zaczynają się pobierać.

loading.tsx: Suspense na poziomie routingu

Next.js App Router ma wbudowany mechanizm, który automatycznie owija page.tsx w <Suspense>. Wystarczy dodać plik loading.tsx w tym samym katalogu.

Code
app/
├── dashboard/
│   ├── layout.tsx      ← pozostaje widoczny podczas nawigacji
│   ├── loading.tsx     ← skeleton podczas ładowania page.tsx
│   └── page.tsx        ← streamowany
Code
// app/dashboard/loading.tsx
export default function DashboardLoading() {
  return (
    <div className="animate-pulse space-y-4">
      <div className="h-8 w-48 rounded bg-gray-200" />
      <div className="grid grid-cols-4 gap-4">
        {Array.from({ length: 4 }).map((_, i) => (
          <div key={i} className="h-24 rounded bg-gray-200" />
        ))}
      </div>
      <div className="h-64 rounded bg-gray-200" />
    </div>
  )
}

loading.tsx tworzy granicę Suspense dla page.tsx i potomnych segmentów danego poziomu routingu, podczas gdy współdzielony layout pozostaje widoczny i interaktywny. Ręczne <Suspense> pozwala wydzielić konkretne sekcje niezależnie. W praktyce możesz łączyć oba podejścia. Ta granica nie obejmuje jednak layout.tsx z tego samego katalogu: wolne pobieranie w nim wymaga własnego Suspense albo przeniesienia niżej. Bez Cache Components może blokować nawigację, a przy włączonych Cache Components dostęp do danych runtime poza granicą może powodować błąd podczas budowania.

Projektowanie dobrych skeletonów w Next.js

to narzędzie UX, które redukuje postrzegany czas ładowania, a dobrze zaprojektowany skeleton:

  • Odwzorowuje kształt docelowej treści, czyli użytkownik mentalnie widzi stronę zanim się załaduje.

  • Unika migotania: dla bardzo szybkich danych rozważ opóźnione pokazanie fallbacku; próg dobierz na podstawie pomiarów, nie sztywnej reguły 200 ms.

  • Jest lekki i nie zawiera ciężkich animacji, które obciążają GPU.

Code
// components/skeletons/StatsSkeleton.tsx
export function StatsSkeleton() {
  return (
    <div aria-hidden="true" className="grid grid-cols-4 gap-4">
      {Array.from({ length: 4 }).map((_, i) => (
        <div
          key={i}
          className="animate-pulse rounded-lg border border-gray-100 bg-white p-4 motion-reduce:animate-none"
        >
          <div className="mb-2 h-4 w-20 rounded bg-gray-200" />
          <div className="h-8 w-28 rounded bg-gray-200" />
        </div>
      ))}
    </div>
  )
}

Fallback powinien być w pełni dostępny dla każdego użytkownika, dlatego dekoracyjne kształty należy ukryć przed czytnikami za pomocą atrybutu aria-hidden, a stan ładowania komunikować na kontenerze sekcji przy użyciu aria-busy="true" lub dedykowanego elementu z role="status". Warto również wyłączyć animacje dla użytkowników preferujących ograniczony ruch, używając zapytania prefers-reduced-motion. Po pomyślnym załadowaniu właściwej treści należy niezwłocznie usunąć atrybut aria-busy, pamiętając, aby nie ogłaszać każdej karty osobno, co mogłoby przytłoczyć odbiorcę korzystającego z technologii asystujących.

Unikanie flash of loading state

Jeśli dane ładują się szybko, skeleton migocze na ułamek sekundy i to jest gorsze niż brak skeletonu. W tej sytuacji CSS może pomóc:

Code
/* Wizualne opóźnienie skeletonu; element nadal rezerwuje miejsce w układzie */
.skeleton-delayed {
  animation: fadeIn 0.3s ease-in;
  animation-delay: 200ms;
  animation-fill-mode: backwards;
}
 
@keyframes fadeIn {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}

Skeleton dopasowany do rodzaju sekcji

Nie buduj jednego uniwersalnego placeholdera dla całej aplikacji, bo takie rozwiązanie się po prostu nie sprawdzi. Przykładowo, karta produktu potrzebuje miejsca na zdjęcie, cenę i CTA, tabela powinna zachować liczbę kolumn, a artykuł może pokazać jedynie szerokości akapitów. Dzięki temu po doładowaniu danych układ nie przeskakuje, a użytkownik od razu rozumie strukturę widoku.

W ramach prostego testu porównaj wymiary skeletonu z finalnym komponentem i sprawdź CLS w Lighthouse albo danych rzeczywistych. Jeżeli fallback zmienia wysokość sekcji lub spycha najważniejszą treść, ładowanie wizualnie szkodzi nawet wtedy, gdy streaming działa technicznie poprawnie.

Streaming i Suspense a Core Web Vitals

Streaming może wpływać na metryki , których dane rzeczywiste Google wykorzystuje jako jeden z sygnałów jakości strony:

LCP przy streamingu w Next.js

Streaming może poprawić LCP tylko wtedy, gdy kandydat LCP znajduje się w szybko dostarczonej powłoce albo rozwiązuje się wcześniej niż bez streamingu. Jeśli największym elementem jest obraz lub hero ukryte za wolną granicą, LCP nadal będzie późny, a zastąpienie dużego skeletonu właściwą treścią może wyznaczyć nowego kandydata LCP. Mierz wynik w danych rzeczywistych, a nie na podstawie samego użycia Suspense.

INP przy streamingu i Suspense

React łączy streaming z selektywną hydratacją, więc może wcześniej priorytetyzować interaktywne fragmenty. Nie gwarantuje to poprawy INP: ciężki kod klienta, długie zadania na głównym wątku i kosztowne handlery nadal decydują o opóźnieniu interakcji. Server Components bez JavaScriptu klienta nie wymagają hydratacji; hydratowane są interaktywne Client Components.

CLS i stabilność skeletonów

Streaming może pogorszyć CLS, jeśli skeletony mają inne wymiary niż docelowa treść. Rozwiązanie: projektuj skeletony z identyczną wysokością i układem jak finalne komponenty.

Code
// Zły skeleton — inny rozmiar niż docelowy komponent
function BadSkeleton() {
  return <div className="h-20 w-full" /> // Za mały — spowoduje layout shift
}
 
// Dobry skeleton — identyczne wymiary
function GoodSkeleton() {
  return <div className="h-48 w-full" /> // Taki sam rozmiar jak RevenueChart
}

Streaming a SEO: co widzi Googlebot?

Streaming w App Routerze nadal jest renderowaniem serwerowym, ale nie warto opierać SEO na założeniu, że każdy robot poczeka na każdą spóźnioną granicę. Treść kluczową dla znaczenia strony trzymaj w statycznej powłoce albo szybko rozwiązującej się granicy. Cięższe sekcje pomocnicze streamuj później.

Najbezpieczniejsze założenie jest takie:

  1. Tytuł, lead, H1, opis i główna treść powinny być dostępne bez długiego czekania na request-time data.
  2. Skeleton nie jest treścią SEO i traktuj go wyłącznie jako element UX.
  3. Jeśli ważna sekcja streamuje się długo albo zależy od personalizacji, nie zakładaj, że każdy crawler zobaczy ją tak samo szybko jak użytkownik.
  4. Weryfikuj efekt w praktyce przez Google Search Console i renderowany HTML.

W Next.js 16 dynamiczne generateMetadata może być streamowane niezależnie od UI i wstrzykiwane po rozwiązaniu obietnicy. Dla botów wymagających metadanych w <head>, takich jak Twitterbot, Slackbot czy Bingbot, Next.js domyślnie wyłącza ten mechanizm i czeka na metadane przed rozpoczęciem streamingu. Zachowanie można zmienić opcją htmlLimitedBots, ale nie rób tego bez testów crawlerów i podglądów udostępniania.

Weryfikacja: użyj inspekcji adresu URL w Google Search Console, wykonaj test wersji opublikowanej i sprawdź wyrenderowany HTML. Dodatkowo porównaj „Wyświetl źródło strony” z DOM-em w DevTools. Źródło może zawierać całą odebraną odpowiedź, w tym późniejsze fragmenty HTML i skrypty zastępujące fallbacki; DOM pokazuje wynik ich przetworzenia. Samo źródło nie pokazuje kolejności ani czasu dostarczenia fragmentów — do tego użyj obserwacji strumienia i pomiarów opisanych niżej.

Zaawansowane wzorce Suspense w Next.js

Zagnieżdżony Suspense

Możesz zagnieżdżać granice, tworząc hierarchię ujawniania treści:

Code
import { Suspense } from 'react'
// Importy komponentów produktu i skeletonów z projektu pominięto.
 
export default async function ProductPage({
  params,
}: {
  params: Promise<{ id: string }>
}) {
  const { id } = await params
 
  return (
    <main>
      <Suspense fallback={<ProductSkeleton />}>
        <ProductDetails id={id} />
        {/* Granica wewnętrzna nie ujawni się przed nadrzędną. */}
        <Suspense fallback={<ReviewsSkeleton />}>
          <ProductReviews id={id} />
        </Suspense>
      </Suspense>
    </main>
  )
}

Grupowanie granic Suspense

Jeśli kilka komponentów powinno pojawić się razem, grupuj je w jednej granicy. Jeżeli mają niezależne czasy oczekiwania i mogą pojawiać się osobno, oddzielne granice dadzą szybsze częściowe ujawnienie.

Code
<Suspense fallback={<OrderDetailsSkeleton />}>
  {/* Te komponenty pojawią się razem. */}
  <OrderHeader orderId={id} />
  <OrderItems orderId={id} />
  <OrderTotal orderId={id} />
</Suspense>

Streaming z Promise.all dla równoległych fetchów

Poniżej znajdziesz alternatywną implementację DashboardStats, która wciąż renderuje się pod granicą Suspense. Użyty tu typ generyczny definiuje oczekiwaną strukturę odpowiedzi, ale nie weryfikuje JSON-a w trakcie działania programu – dlatego kontrakt z API należy zabezpieczyć dodatkową walidacją zgodną ze schematem danych.

Code
async function fetchJson<T>(url: string): Promise<T> {
  const response = await fetch(url, { cache: 'no-store' })
  if (!response.ok) throw new Error(`Błąd ${response.status} dla ${url}`)
  return response.json() as Promise<T>
}
 
async function DashboardStats() {
  // Równoległe pobieranie — czas oczekiwania jest zbliżony do najwolniejszej operacji.
  const [revenue, orders, customers] = await Promise.all([
    fetchJson<{ total: number }>('https://api.example.com/revenue'),
    fetchJson<{ count: number }>('https://api.example.com/orders'),
    fetchJson<{ active: number }>('https://api.example.com/customers'),
  ])
 
  return (
    <div className="grid grid-cols-3 gap-4">
      <StatCard label="Przychód" value={revenue.total} />
      <StatCard label="Zamówienia" value={orders.count} />
      <StatCard label="Klienci" value={customers.active} />
    </div>
  )
}

Wywołania fetchJson() rozpoczynają niezależne operacje bez oczekiwania na poprzednią, a Promise.all oczekuje na ich wyniki. Komponent może się ujawnić dopiero po zakończeniu wszystkich operacji; błąd jednej odrzuca wynik Promise.all, lecz nie anuluje pozostałych żądań. Użyj tego wzorca, gdy dane tworzą jedną logiczną sekcję. Jeżeli części mają pojawiać się niezależnie, rozdziel je na osobne komponenty i granice Suspense. Niezależna obsługa awarii wymaga dodatkowo osobnych granic błędów lub jawnej obsługi błędów sekcji — same granice Suspense jej nie zapewniają. Gdy jedno zapytanie wymaga wyniku poprzedniego, sekwencja jest uzasadniona, ponieważ streaming może pokazać wcześniejszy etap, ale nie usunie zależności.

Suspense, cache i dane dynamiczne w Next.js 16

Samo owinięcie komponentu w <Suspense> nie uruchamia jeszcze automatycznie mechanizmu streamingu, ponieważ granica wyświetli element zastępczy dopiero w momencie, gdy jej potomek faktycznie wstrzyma renderowanie, na przykład oczekując na asynchroniczne pobranie danych. Zwykły komponent synchroniczny zostanie natomiast wyrenderowany od razu w standardowy sposób. Brak domyślnego trwałego cache wyniku fetch nie oznacza jednak, że cała trasa jest renderowana na nowo przy każdym żądaniu. W modelu bez Cache Components trasa może zostać prerenderowana podczas next build. Cache danych i prerenderowanie strony to odrębne mechanizmy; w przykładach cache: 'no-store' jawnie określa pobieranie danych w czasie żądania.

Opis częściowo prerenderowanej powłoki z use cache dotyczy włączonych Cache Components (cacheComponents: true w next.config.ts); nie jest to automatyczny skutek dodania Suspense. W tym trybie stabilne dane lub komponenty można objąć dyrektywą use cache, aby mogły znaleźć się w prerenderowanej powłoce.

Jeżeli używasz Cache Components, dostęp do danych runtime, takich jak cookies(), headers() lub searchParams, powinien znaleźć się pod odpowiednią granicą Suspense. Next.js może wtedy prerenderować zawartość ponad granicą, umieścić fallback w statycznej powłoce i wykonać część zależną od żądania później. Granice umieszczaj możliwie blisko wolnej sekcji, ponieważ zbyt wysoka granica zastąpi fallbackiem również treść, która mogłaby pojawić się od razu.

Błędy i kody HTTP podczas streamingu

Suspense zarządza oczekiwaniem, ale musimy zająć się także obsługą błędów. Dodaj error.tsx w segmentach, w których potrzebujesz osobnego widoku awarii, i loguj błędy po stronie serwera. Taka granica nie obejmuje layoutu z tego samego segmentu; jego błędy obsługuje granica nadrzędna, a błędy głównego layoutu — global-error.tsx.

Podczas SSR komponentów, które mogą wykonać się także w przeglądarce, React potrafi wysłać fallback Suspense po błędzie i ponowić renderowanie na kliencie. Nie oznacza to wykonania Server Component w przeglądarce: błąd jego renderowania trafia do odpowiedniej granicy błędów Next.js, a ponowienie pobrania danych serwerowych wymaga kolejnego żądania do serwera.

Po wysłaniu pierwszego fragmentu odpowiedzi nagłówki są już ostatecznie zatwierdzone, przez co serwer traci możliwość modyfikacji kodu HTTP. Późne wywołanie funkcji notFound() lub redirect() potrafi przekazać odpowiednią instrukcję bezpośrednio w strumieniu, jednak transportowy status odpowiedzi często pozostaje na poziomie 200. Jeśli wymagany jest konkretny status HTTP, kontrola musi nastąpić przed rozpoczęciem odpowiedzi. Przy Cache Components powłoka może zostać wysłana jeszcze przed wykonaniem kodu strony zależnego od żądania, więc samo przeniesienie sprawdzenia na początek page.tsx nie wystarczy. W takim przypadku zaprojektuj kontrolę przed wysłaniem powłoki, np. szybkie sprawdzenie adresu w Proxy, albo osobny Route Handler dla klientów API. Niezależnie od kodu HTTP autoryzację danych wykonuj przed ich pobraniem i ujawnieniem; wysłanie publicznej powłoki nie zastępuje tej kontroli.

Hosting i testowanie streamingu

Na hostingu własnym sprawdź cały łańcuch: serwer Next.js, reverse proxy, load balancer i CDN. Nginx oraz część integracji chmurowych może domyślnie buforować odpowiedź, przez co użytkownik dostanie powłokę i wolną sekcję jednocześnie. Next.js zaleca wyłączenie buforowania, np. nagłówkiem X-Accel-Buffering: no, oraz potwierdzenie obsługi strumieniowania HTTP/2 albo odpowiedzi chunked w HTTP/1.1.

Testuj produkcyjny build, a nie tylko next dev. W DevTools sprawdź timing odpowiedzi i moment pojawienia się kolejnych sekcji; z terminala możesz użyć curl --no-buffer URL, aby obserwować fragmenty bez lokalnego buforowania. Dodaj kontrolowane opóźnienie wyłącznie w środowisku testowym i zweryfikuj osobno czas do powłoki, czas do każdej granicy, CLS oraz zachowanie po błędzie i po przerwaniu nawigacji.

Audyt techniczny i optymalizacja SEO.
Audyt techniczny SEO

Często zadawane pytania

Czy streaming działa tylko na Vercel?

Nie. Streaming działa na każdej platformie obsługującej Next.js w trybie serwerowym i umożliwiającej przesyłanie odpowiedzi strumieniowej, np. Vercel, Netlify, AWS czy samodzielnie hostowany Node.js. Reverse proxy, load balancer i CDN nie mogą buforować odpowiedzi. Przy statycznym eksporcie (output: 'export') nie ma streamingu danych w czasie żądania, bo nie działa serwer Next.js.

Czy każdą stronę powinienem streamować?

Nie. Strony w pełni prerenderowane lub korzystające z szybkich danych z cache często nie potrzebują fallbacku. Streaming ma największy sens w miejscach, gdzie poszczególne sekcje strony charakteryzują się zupełnie odmiennym czasem ładowania, pozwalając na natychmiastowe dostarczenie szybkiej powłoki oraz sukcesywne dopełnianie wolniejszych fragmentów w trakcie trwania tego samego żądania.

Czy streaming zwiększa zużycie serwera?

Wszystko zależy od implementacji. Sam streaming nie musi generować dodatkowych zapytań, jednak renderowanie fallbacków, dłużej utrzymywane połączenie oraz większa liczba przesyłanych fragmentów odpowiedzi wiążą się z konkretnym narzutem. Co więcej, źle zaprojektowana hierarchia komponentów potrafi wywołać klasyczny waterfall zapytań. Zamiast więc zakładać zerowy koszt takiego wdrożenia, mierz na bieżąco czas renderowania, liczbę żądań oraz zużycie zasobów.

Czy streaming szkodzi SEO?

Streaming jest renderowaniem serwerowym, ale ważną treść nadal warto umieszczać w statycznej powłoce albo szybko rozwiązującej się granicy. Next.js osobno obsługuje streaming metadanych i wyłącza go dla botów wymagających metadanych w head. Sprawdzaj wyrenderowany HTML i wynik inspekcji adresu, zamiast zakładać identyczne zachowanie każdego crawlera.

Dlaczego streaming może pogorszyć CLS?

Bo jeśli skeleton ma inne wymiary niż docelowa treść, układ przeskakuje po doładowaniu danych. Rozwiązanie: projektuj skeletony o identycznej wysokości i strukturze jak finalny komponent, a wymiary zweryfikuj porównawczo w Lighthouse.

O autorze

Maciej Sala

Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.

Pomagam przekładać takie tematy na konkretne wdrożenia w frontendzie, SEO, analityce i procesie produktowym.

Skontaktuj się ze mną
LH.pl – Hosting Mango

Biblioteka wiedzy na temat Next.js i React

Czytaj dalej

Zobacz więcej wpisów
JavaScript SEO: kiedy Next.js daje przewagę nad React SPA

Next.js to framework React, który ułatwia uniknięcie głównego ograniczenia aplikacji SPA renderowanych wyłącznie w przeglądarce: kluczowa treść może znaleźć się już w początkowym HTML. Google nie musi wtedy czekać na wykonanie JavaScriptu, żeby ją odkryć. Framework dodaje też Metadata API, optymalizację obrazów i podział kodu, ale korzyść dla Core Web Vitals zależy od sposobu implementacji, ilości kodu klienckiego i infrastruktury.

Maciej Sala

Maciej Sala

Founder StriveLab

Server i Client Components w Next.js: gdzie przebiega granica serwer–klient

Komponent działa lokalnie, ale po wdrożeniu na produkcję pojawia się niezgodność hydratacji ang. hydration mismatch , a prosta strona produktu pobiera kilkaset kilobajtów JavaScriptu. Zamiast natychmiast wyłączać SSR czy otaczać kod memoizacją, warto cofnąć się o krok. Problem rzadko leży w braku optymalizacji — częściej w braku decyzji, która część interfejsu realnie wymaga przeglądarki. React Server Components przesunęły granicę między serwerem a klientem. W App Routerze najpierw decydujemy, gdzie wykonać pracę, a dopiero potem dobieramy hooki i biblioteki.

Maciej Sala

Maciej Sala

Founder StriveLab

App Router czy Pages Router w Next.js: co wybrać?

Next.js 13 wprowadził App Router , czyli nowy sposób budowania aplikacji oparty na React Server Components . Ale Pages Router nigdzie nie zniknął. Dwa routery, dwa podejścia, jedna decyzja do podjęcia na starcie projektu.

Maciej Sala

Maciej Sala

Founder StriveLab

LH.pl – Cloud Server 1C4G