Przejdź do treści

Migracja z WordPressa do Astro lub Next.js i Headless CMS

Maciej Sala

Founder StriveLab

10 min czytaniaAktualizacja

Szybka odpowiedź: jak przenieść WordPressa do Astro lub Next.js bez utraty panelu dla redakcji?

  • Nowy frontend w Astro albo Next.js połącz z headless CMS-em, żeby redakcja miała lekki panel.
  • Storyblok daje edycję wizualną z podglądem, Sanity elastyczne schematy, a Payload samodzielny hosting i integrację z Next.js.
  • Importuj ze stałym identyfikatorem i jawną polityką zapisu: createIfNotExists zachowa istniejące dokumenty, a createOrReplace je zastąpi.
  • Świeżość zapewniają webhooki, czyli revalidateTag w Next.js albo deploy hook w Astro.
  • Media i mapowanie URL-i przygotuj przed przełączeniem ruchu; przekierowania dodaj dla zmienionych adresów.

Migracja z WordPressa do Headless CMS: czy redakcja traci panel?

Headless nie oznacza Markdowna w Gicie, ponieważ nowoczesny frontend w Astro albo Next.js może współpracować z wizualnym panelem do zarządzania treścią, a redaktor nadal edytuje wpisy, strony i media w aplikacji CMS.

W praktyce zmienia się odpowiedzialność systemu: frontend odpowiada za szybkość i prezentację, a Headless CMS za treść, role użytkowników, media i workflow redakcyjny. Dzięki temu zespół techniczny odzyskuje kontrolę nad kodem, a redakcja nie musi pracować w przeładowanym panelu WordPressa.

Dlaczego WordPress z page builderem utrudnia migrację

Treść i layout w jednej bazie WordPressa

To najgłębszy problem architektury WordPressa z page builderem. W bazie danych treść (tekst) jest wymieszana z prezentacją (style, układ, shortcode'y Elementora czy Divi). Jeden wpis w bazie to nie „tytuł i akapity", tylko tytuł, akapity, definicje kolumn, kolory tła, marginesy i shortcode'y buildera zapisane razem w jednym polu.

Wszystko ma swoje konsekwencje i gdy chcesz zmienić szablon albo zmigrować dane, baza okazuje się chaosem, z którego trzeba wydłubywać czystą treść. Mozolny i nieprzyjemny proces. Headless CMS wymusza rozdzielenie tych warstw, czyli treść to treść, a jej wygląd definiuje frontend. Dzięki takiemu podejściu, gdy na przykład za trzy lata będziesz zmieniać cały layout, zrobisz to bez dotykania ani jednego wpisu.

Wolny panel WordPressa i gorszy UX edytora

Jako wieloletni posiadacz stron w WordPressie mogę powiedzieć z doświadczenia: panel administratora z czasem zwalnia. Jest to bardzo frustrujące, ponieważ z czasem chcemy pracować szybciej. WordPress ma to do siebie, że im więcej wtyczek, tym dłużej się ładuje, mamy więcej komunikatów o aktualizacjach i blokad przy edycji.

Nowoczesne panele (Sanity Studio, panel Payloada, edytor Storybloka) są budowane jak aplikacje frontendowe, więc ładują się natychmiast i skupiają tylko na edycji treści.

Bezpieczeństwo WordPressa: panel, wtyczki i dostęp do serwera

W monolitycznym WordPressie dając redaktorowi dostęp do panelu, dajesz mu także możliwość zainstalowania losowej wtyczki, która zepsuje albo skompromituje stronę. W architekturze headless panel CMS i frontend to dwa oddzielne światy. Redaktor pracuje w panelu treści, który fizycznie nie ma jak zmodyfikować kodu strony ani serwera, na którym stoi frontend.

Jaki Headless CMS po WordPressie: Storyblok, Sanity czy Payload?

Wybierając najlepszy CMS, trzeba kierować się przede wszystkim dobrze przemyślanymi, własnymi potrzebami. Są trzy sprawdzone kierunki:

Storyblok: wizualna edycja treści po migracji z WordPressa

Storyblok ma wbudowaną edycję wizualną z podglądem na żywo (Visual Editor): redaktor widzi realną stronę, klika w element i edytuje go w bocznym pasku. Wymaga to integracji podglądu, bloków i komunikacji z edytorem po stronie frontendu. Redaktor pracuje na komponentach przygotowanych przez zespół — nie jest to automatycznie pełna swoboda projektowania znana z Elementora. Jeśli klient panicznie boi się, że „straci klikanie", Storyblok będzie dla niego.

Sanity: elastyczne modelowanie treści w Headless CMS

Sanity daje pełną swobodę w projektowaniu schematów treści (Content Modeling), dlatego zamiast dopasowywać się do sztywnych typów pól, definiujesz dokładnie taką strukturę, jakiej potrzebuje Twój projekt. Masz wpływ na pola tekstowe, relacje między dokumentami czy powtarzalne bloki. Ostatecznie, redaktor dostaje czysty, intuicyjny panel (Sanity Studio) i bibliotekę mediów z automatyczną optymalizacją i punktem centrowania kadru (focal point). To dobry wybór, gdy zależy Ci na porządku w danych i długoterminowej elastyczności.

Payload CMS: samodzielne hostowanie i integracja z Next.js

pozwala zachować kontrolę nad hostingiem i bazą danych. Payload 3 integruje się z Next.js: wymaga konfiguracji CMS-a, adaptera bazy, tras panelu/API oraz pluginu withPayload, a nie tylko instalacji w folderze /app. CMS i frontend mogą działać w jednym repozytorium i wdrożeniu. Konfiguracja jest w TypeScripcie, a licencja MIT dotyczy oprogramowania; kontrola i prawa do danych zależą także od umów i wybranych usług. Możesz wdrożyć aplikację np. na Vercelu lub w kontenerze na ; inne środowiska, w tym , wymagają zgodnych adapterów i usług. Dla zespołów pracujących już z Next.js to często naturalny wybór. Uwzględnij utrzymanie, trwały magazyn plików i kopie bazy.

Architektura Headless CMS z Astro i Next.js po migracji

Warto to również przedstawić stronie biznesowej, ponieważ jest to argument, który przekonuje decydentów.

Dawniej (monolit): W tradycyjnym modelu monolitycznym baza danych WordPressa, wraz z PHP i wtyczkami, generowała HTML, który następnie zostawał przesyłany do przeglądarki. Oznaczało to, że wszystkie elementy znajdowały się w jednym miejscu. Tworzyło to pojedynczy punkt awarii, a wydajność była bezpośrednio zależna od obciążenia serwera przy każdym żądaniu.

Teraz (architektura decoupled): W architekturze rozdzielonej panel CMS (taki jak Sanity, Payload czy Storyblok) komunikuje się poprzez API z generatorem stron (Astro lub Next.js). Przy generowaniu statycznym powstają pliki serwowane z , a treść pobierasz podczas builda. Przy SSR HTML powstaje na żądanie, a jego świeżość i dostępność zależą od backendu oraz cache. Sam headless nie przesądza o trybie renderowania ani o wynikach wydajności.

Najważniejszą korzyścią biznesową jest niezależność. Jeśli za np. trzy lata zechcesz zmienić Astro na coś innego, treść w CMS-ie zostaje nienaruszona, a przepisujesz tylko warstwę prezentacji. W monolicie WordPressa taka zmiana oznaczała przepisanie wszystkiego naraz.

Migracja z WordPressa do Headless CMS krok po kroku

Krok 1: eksport i czyszczenie treści z WordPressa

Treść wyciągasz z WordPressa przez (/wp-json/wp/v2/posts) albo , a następnie mapujesz elementy builderów na strukturę docelową. Nie usuwaj shortcode’ów ani bloków bez sprawdzenia, czy nie zawierają obrazów, linków lub innej istotnej treści. To ten sam etap, który opisałem szerzej w artykule o migracji frontendu; tutaj efektem ma być treść zgodna ze schematem CMS-a. /posts nie obejmuje stron i wszystkich CPT; pola dodatkowe, szkice i prywatne dokumenty mogą wymagać konfiguracji API i uwierzytelnienia. WPGraphQL jest osobną wtyczką.

Krok 2: Content Modeling i schematy w nowym CMS-ie

Na tym etapie należy zdefiniować schematy w nowym systemie CMS, odwzorowując dotychczasowe typy treści z WordPressa, takie jak wpisy blogowe, realizacje czy profile pracowników. Jest to najważniejszy moment, aby trwale uporządkować strukturę danych.

W Sanity schemat to obiekt w kodzie:

Code
// schemas/post.ts
import { defineType, defineField } from 'sanity'
 
export const post = defineType({
  name: 'post',
  title: 'Wpis blogowy',
  type: 'document',
  fields: [
    defineField({ name: 'title', title: 'Tytuł', type: 'string' }),
    defineField({
      name: 'slug',
      title: 'Slug',
      type: 'slug',
      options: { source: 'title' },
    }),
    defineField({ name: 'coverImage', title: 'Zdjęcie', type: 'image' }),
    defineField({
      name: 'body',
      title: 'Treść',
      type: 'array',
      of: [{ type: 'block' }], // obrazy, galerie i inne bloki wymagają rozszerzenia
    }),
  ],
})

To dopiero minimalny punkt wyjścia, w którym zdjęcie wyróżniające nie zastąpi multimediów osadzonych bezpośrednio w treści. Rozbuduj ten schemat o potrzebne typy bloków, metadane SEO, daty publikacji, autorów oraz relacje między wpisami. Pamiętaj też, że tytuły pobierane z pola title.rendered wymagają odpowiedniego oczyszczenia z tagów oraz zdekodowania encji HTML.

W Payloadzie analogiczny typ to kolekcja:

Code
// collections/Posts.ts
import type { CollectionConfig } from 'payload'
 
export const Posts: CollectionConfig = {
  slug: 'posts',
  admin: { useAsTitle: 'title' },
  fields: [
    { name: 'title', type: 'text', required: true },
    { name: 'slug', type: 'text', required: true, unique: true },
    { name: 'coverImage', type: 'upload', relationTo: 'media' },
    { name: 'content', type: 'richText' },
  ],
}

Krok 3: skrypt migracyjny do automatycznego importu

Ręczne przepisywanie setek wpisów jest pozbawione sensu, więc tworzy się skrypt, który pobiera dane z WordPressa i przesyła je do API nowego systemu CMS za pośrednictwem jego SDK. Poniżej przykład dla Sanity, obejmujący pobranie wpisów, przesłanie zdjęcia głównego i zapis dokumentu:

Code
// migrate.mjs
import { createClient } from '@sanity/client'
import 'dotenv/config'
 
const WP = 'https://stara-strona.pl/wp-json/wp/v2'
const dataset = process.env.SANITY_MIGRATION_DATASET
if (!dataset || dataset === 'production') {
  throw new Error('Wskaż osobny dataset migracyjny.')
}
if (!process.env.SANITY_PROJECT_ID || !process.env.SANITY_WRITE_TOKEN) {
  throw new Error('Brak konfiguracji projektu lub tokenu migracji.')
}
 
const sanity = createClient({
  projectId: process.env.SANITY_PROJECT_ID,
  dataset,
  apiVersion: '2026-01-01',
  token: process.env.SANITY_WRITE_TOKEN,
  useCdn: false,
})
 
async function fetchChecked(url) {
  const response = await fetch(url, { signal: AbortSignal.timeout(30000) })
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${url}`)
  return response
}
 
async function uploadImage(url) {
  if (!url) return undefined
  const res = await fetchChecked(url)
  if (!res.headers.get('content-type')?.startsWith('image/')) {
    throw new Error(`Oczekiwano obrazu: ${url}`)
  }
  const buffer = Buffer.from(await res.arrayBuffer())
  const asset = await sanity.assets.upload('image', buffer)
  return { _type: 'image', asset: { _type: 'reference', _ref: asset._id } }
}
 
async function migrate() {
  let totalPages = 1
  for (let page = 1; page <= totalPages; page++) {
    const res = await fetchChecked(
      `${WP}/posts?status=publish&per_page=100&page=${page}&orderby=id&order=asc&_embed`,
    )
    const pages = res.headers.get('x-wp-totalpages')
    if (pages === null || !/^\d+$/.test(pages)) {
      throw new Error('Brak poprawnego X-WP-TotalPages — nie potwierdzono kompletności eksportu.')
    }
    totalPages = Number(pages)
    const posts = await res.json()
    if (!Array.isArray(posts)) throw new Error('Oczekiwano tablicy wpisów.')
 
    for (const post of posts) {
      if (!Number.isInteger(post.id) || typeof post.title?.rendered !== 'string'
          || typeof post.slug !== 'string') throw new Error('Niepoprawny wpis WP.')
      const id = `wp-main-post-${post.id}`
      if (await sanity.getDocument(id)) {
        console.log(`Pominięto istniejący dokument: ${id}`)
        continue
      }
      const coverUrl = post._embedded?.['wp:featuredmedia']?.[0]?.source_url
      const coverImage = await uploadImage(coverUrl)
      await sanity.createIfNotExists({
        _id: id,
        _type: 'post',
        // Wersja robocza: przed finalnym importem skonwertuj HTML/encje na tekst.
        title: post.title.rendered,
        slug: { _type: 'slug', current: post.slug },
        ...(coverImage ? { coverImage } : {}),
        // body oraz pozostałe pola wymagają osobnego mapowania.
      })
      console.log(`Zaimportowano metadane: ${post.slug}`)
    }
  }
}
 
migrate().catch((error) => {
  console.error(error)
  process.exitCode = 1
})

Stałe _id w połączeniu z createIfNotExists zapobiega duplikacji i przypadkowemu nadpisaniu danych, jednak nie aktualizuje dokumentów przy kolejnych uruchomieniach. Prefiks wp-main identyfikuje źródło — dostosuj go przy łączeniu wielu instalacji WP. Kolejne synchronizacje oprzyj na jawnej aktualizacji wybranych pól, zabezpieczając zmiany wprowadzone przez redaktorów. Po createOrReplace sięgaj tylko wtedy, gdy akceptujesz pełne zastąpienie rekordu; brakujące pola (np. body) zostaną w takim przypadku wykasowane.

Import plików i dokumentów nie jest atomowy, dlatego błąd w trakcie procesu może pozostawić nieużywane zasoby w bibliotece mediów. Przed ostatecznym eksportem ustal okres zamrożenia treści lub przygotuj synchronizację edycji i usunięć. Na koniec sprawdź spójność liczby oraz ID dokumentów, poprawność osadzonych mediów, linków, atrybutów alt, podpisów i pól obowiązkowych. Token zapisu trzymaj po stronie serwerowej i ogranicz jego uprawnienia wyłącznie do potrzeb migracji.

Krok 4: webhooki, ISR i rebuild w Astro lub Next.js

Zastanawiasz się, skąd frontend wie, że pojawiła się nowa treść? Odpowiedzią są . Redaktor klika „Publikuj" w panelu, CMS wysyła żądanie do frontendu, a system unieważnia cache lub uruchamia build. Czas widoczności zmian zależy od trybu renderowania, kolejki wdrożeń, skali i cache.

W Next.js robisz to przez , czyli endpoint, który CMS wywołuje po publikacji:

Code
// app/api/revalidate/route.ts
import { revalidateTag } from 'next/cache'
 
export async function POST(req: Request) {
  const expected = process.env.REVALIDATE_SECRET
  if (!expected) {
    return Response.json({ ok: false }, { status: 503 })
  }
  const secret = req.headers.get('x-webhook-secret')
  if (!secret || secret !== expected) {
    return Response.json({ ok: false }, { status: 401 })
  }
  revalidateTag('posts', { expire: 0 }) // wygasza cache; kolejne żądanie pobierze dane
  return Response.json({ revalidated: true })
}

Tag posts musi być wcześniej przypisany do cache pobieranych danych, np. przez next: { tags: ['posts'] } w cache’owanym fetch albo cacheTag('posts') w funkcji z use cache. Samo wywołanie webhooka nie wykonuje zapytań ani nie przebudowuje wszystkich stron. Wariant { expire: 0 } wymusza pobranie świeżych danych przy kolejnym odczycie; profil 'max' pozwala najpierw zwrócić starą wersję i odświeżyć ją w tle. Sekret przesyłaj przez HTTPS; jeśli CMS oferuje podpisy webhooków, weryfikuj je zgodnie z jego dokumentacją.

Jeśli Astro jest hostowane na Cloudflare Pages lub Netlify, zazwyczaj wystarczy skonfigurować webhook typu „deploy hook”. CMS, wysyłając żądanie na wskazany URL, uruchamia build i wdrożenie statycznej strony. Zabezpiecz URL hooka i monitoruj powodzenie wdrożenia. Dla treści wymagającej pobierania przy żądaniu, Astro oferuje też renderowanie na żądanie () z adapterem serwerowym i pobieraniem danych w czasie requestu; cache aplikacji, CMS-a lub CDN nadal może wpływać na świeżość.

Lista kontrolna migracji z WordPressa do Astro, Next.js i Headless CMS

Przed startem migracji sprawdź nie tylko CMS i frontend, ale też import danych, media, webhooki oraz przekierowania. To one decydują, czy przejście z WordPressa na Astro lub Next.js będzie technicznie czyste i bezpieczne dla SEO.

  • Zinwentaryzowane typy treści z WordPressa (wpisy, realizacje, strony, CPT).

  • Wybrany CMS dopasowany do zespołu (Storyblok to wizualny komfort, Sanity oznacza elastyczność, Payload to samodzielne hostowanie i integracja z Next.js).

  • Zaprojektowane schematy / kolekcje w nowym CMS-ie.
  • Treść wyeksportowana z WP i elementy buildera przemapowane bez utraty zawartości.

  • Importer przetestowany na próbce oraz na ponownym uruchomieniu; sprawdzona kompletność i ochrona zmian redakcji.

  • Przeniesione i zoptymalizowane media.
  • Skonfigurowane webhooki / rewalidacja po publikacji.
  • Zachowane URL-e lub przekierowania 301/308 zmienionych adresów do właściwych odpowiedników; bez łańcuchów i zbiorczego kierowania na stronę główną.

  • Live Preview skonfigurowany i pokazany redakcji przed startem.

  • Przeniesione metadane SEO, adresy kanoniczne, dane strukturalne i linki wewnętrzne; sprawdzona mapa witryny i indeksowalność produkcji.
  • Kopia danych, końcowa synchronizacja zmian redakcyjnych, plan wycofania wdrożenia i monitoring po przełączeniu.

Przekierowania stanowią solidną polisę bezpieczeństwa podczas migracji, pomagając utrzymać pozycje. Jeśli struktura adresów pozostaje bez zmian, nie dodawaj przekierowań na siłę — zachowaj dotychczasowe URL-e. Po starcie nowego systemu po prostu monitoruj Search Console, aby na bieżąco wspierać indeksację i widoczność serwisu.

Wybór między Astro a Next.js ułatwi matryca decyzyjna WordPress, Astro czy Next.js, a porównanie Sanity, Storyblok i Strapi znajdziesz we wpisie Headless CMS dla Astro.

Ultraszybkie projekty, łączące lekkość ze skalowalnością.
Astro

Często zadawane pytania

Czy migracja na Headless CMS oznacza utratę panelu redakcyjnego?

Nie. To fałszywa alternatywa, ponieważ nikt nie zmusza redakcji do commitowania plików Markdown w Gicie. Nowoczesny frontend w Astro lub Next.js współpracuje z wizualnymi panelami jak Sanity Studio, panel Payloada czy edytor Storybloka. Redakcja dostaje edytor często wygodniejszy niż przeładowany wtyczkami panel WordPressa, a deweloper zachowuje kontrolę nad kodem i wydajnością.

Który Headless CMS wybrać — Sanity, Payload czy Storyblok?

Storyblok będzie najlepszy, gdy klient boi się utraty edycji wizualnej (ma podgląd na żywo najbliższy doświadczeniu z Elementora). Sanity daje największą elastyczność w projektowaniu schematów (Content Modeling) i porządek w danych. Payload pozwala kontrolować hosting i integruje się z Next.js, ale wymaga konfiguracji bazy, tras i aplikacji; często pasuje do zespołów mocno inżynierskich. Wybierasz ten, który odpowiada Twoim potrzebom.

Jak przenieść treść z WordPressa do Headless CMS?

Treść wyciągasz z WordPressa przez REST API (/wp-json/wp/v2/posts) albo WPGraphQL, mapujesz elementy page builderów na docelowe bloki, a następnie skryptem migracyjnym wysyłasz do API nowego CMS-a przez jego SDK. Skrypt warto zrobić idempotentnym (stały identyfikator dokumentu oraz operacja typu createIfNotExists), żeby ponowienie nie tworzyło duplikatów ani nie nadpisywało istniejących dokumentów. Aktualizacje wymagają osobnej polityki synchronizacji; createOrReplace zastępuje cały dokument.

Skąd statyczny frontend wie, że pojawiła się nowa treść?

Poprzez webhooki, kiedy po publikacji CMS wysyła żądanie do frontendu. W Next.js robisz to przez on-demand revalidation (revalidateTag), a w Astro na Cloudflare Pages czy Netlify najczęściej przez deploy hook, który uruchamia build i wdrożenie. Czas publikacji zależy od kolejki, skali i cache. Dla treści wymagającej pobierania przy żądaniu, Astro oferuje też renderowanie na żądanie (SSR).

Czy po migracji z WordPressa zostaje podgląd na żywo przed publikacją?

Tak, ale zależy to od wybranego CMS-a i konfiguracji frontendu. Storyblok oferuje Visual Editor, który wymaga integracji z frontendem; Sanity i Payload również umożliwiają podgląd po odpowiednim wdrożeniu w połączeniu z Astro lub Next.js, dzięki czemu redaktor widzi zmiany na realnym layoucie przed publikacją.

Co zastępuje Yoast SEO w Headless CMS?

Najczęściej lekkie pola SEO i dedykowane pluginy w panelu CMS, na przykład plugin SEO w Payloadzie. Same pola nie odtwarzają całego Yoasta: trzeba osobno wdrożyć generowanie metadanych, adresów kanonicznych, map witryny i wymaganych danych strukturalnych. Podpowiedzi redakcyjne zależą od wybranego narzędzia.

Co dzieje się z obrazkami po migracji z WordPressa?

Media trzeba przenieść do biblioteki nowego CMS-a albo magazynu plików, na przykład S3 lub R2. Sanity oferuje własny CDN obrazów z transformacjami, a w Payloadzie pliki możesz trzymać u siebie i wystawić przez CDN. Redaktor nadal wrzuca zdjęcia w panelu, ale optymalizacja i formaty są kontrolowane przez nową architekturę.

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 WordPress

Czytaj dalej

Zobacz więcej wpisów
Headless CMS dla Astro: porównanie Sanity, Storyblok i Strapi

Markdown w plikach projektu działa sprawnie, dopóki treść piszą osoby, które swobodnie pracują w Git. W sytuacji, kiedy klient chce sam zmienić cennik, a redaktor poprawia nagłówek w piątek po południu, repozytorium przestaje być wygodnym CMS-em. Wtedy najlepszy będzie headless CMS, czyli panel dla redakcji i API dla Astro.

Maciej Sala

Maciej Sala

Founder StriveLab

Czy warto zamienić WordPressa na Astro w projekcie?

WordPress i Astro nie stanowią bezpośrednich alternatyw. Pierwszy z nich to kompleksowy system CMS ze wbudowanym panelem administracyjnym, relacyjną bazą danych oraz rozbudowanym ekosystemem wtyczek, podczas gdy Astro pozostaje nowoczesnym frameworkiem do budowy frontendu. Ostateczny wybór dotyczy zatem całej architektury rozwiązania, czyli sposobu renderowania stron, modelu edycji treści, strategii integracji oraz podziału odpowiedzialności za późniejsze utrzymanie systemu.

Maciej Sala

Maciej Sala

Founder StriveLab

Astro z Payload CMS: integracja krok po kroku

Wyobraź sobie stronę internetową, której koszt utrzymania nie rośnie wraz z liczbą odwiedzin. Otrzymasz taki efekt, łącząc lekki frontend w Astro z własnym CMS-em w postaci Payload, odizolowanym od ruchu użytkowników. To architektura, która daje wysoką wydajność i pełną kontrolę nad danymi, jednocześnie trzymając koszty pod kontrolą.

Maciej Sala

Maciej Sala

Founder StriveLab

LH.pl – Cloud Server 1C4G