Ich habe in den letzten drei Jahren über ein Dutzend WordPress-Seiten zu Next.js migriert. Einige liefen reibungslos ab. Einige brachten mich dazu, meine Karrierechoices um 2 Uhr morgens an einem Dienstag zu hinterfragen. Der Unterschied zwischen diesen beiden Ergebnissen kam fast immer auf Planung an — speziell darauf, zu verstehen, was WordPress tatsächlich für die Website tat, bevor man es herausriss.

Dieser Leitfaden ist alles, was ich mir vor meiner ersten Migration hätte geben lassen. Wir werden die gesamte Reise abdecken: Bewertung, ob du überhaupt migrieren solltest, Auswahl deines Headless-CMS, Inhaltsverschiebung, Neuerstellung von Templates, SEO-Erhaltung ohne Ranking-Verlust und Bereitstellung auf Vercel mit einem Setup, das unter Traffic-Spitzen nicht zusammenbricht.

Lass uns loslegen.

WordPress to Next.js Migration auf Vercel: Ein 2026 Leitfaden

Inhaltsverzeichnis

Warum 2026 von WordPress zu Next.js migrieren?

Seien wir ehrlich — WordPress betreibt immer noch ungefähr 40% des Webs im Jahr 2026. Es geht nirgendwohin. Aber die Gründe zum Weggehen sind überzeugender geworden:

Performance-Decke. Selbst mit aggressiven Caching-Plugins (WP Rocket, W3 Total Cache) treffen die meisten WordPress-Seiten eine Mauer bei etwa 70-80 auf den Lighthouse-Performance-Scores. Plugin-Überfluss, Render-blockierendes PHP und Datenbankabfragen bei jedem Seitenladevorgang erzeugen einen Overhead, den keine Menge an Optimierung vollständig beseitigen kann.

Sicherheits-Angriffsfläche. WordPress hatte 2025 149 dokumentierte Sicherheitslücken im Kern und beliebten Plugins. Jedes Plugin ist ein Angriffsvektor. Jedes Theme-Update ist ein potenzieller Break. Wenn du WooCommerce betreibst, verdoppelt sich die Angriffsfläche.

Entwicklererfahrung. Wenn dein Team React kennt, wirkt das Entwickeln in PHP-Templates wie Schreiben mit deiner nicht-dominanten Hand. Next.js 15s App Router, Server Components und eingebautes Caching geben dir einen modernen Entwicklungs-Workflow, den WordPress nicht erreichen kann.

Kosten im großen Maßstab. Verwaltetes WordPress-Hosting (WP Engine, Kinsta) kostet $30-$300/Monat für anständige Performance. Vercels Pro-Plan bei $20/Benutzer/Monat mit Edge-Funktionen und automatischer Skalierung kostet oft weniger, während er besser performt.

Abgesehen davon — migriere nicht nur, weil es trendy ist. Wenn deine Website ein einfacher Blog mit 50 Beiträgen ist und dein Client ihn wöchentlich über das WordPress-Admin-Panel aktualisiert, könnte eine Migration mehr Probleme schaffen als lösen. Die besten Kandidaten für Migration sind:

  • Websites mit 500+ Seiten, die bessere Performance brauchen
  • Teams, die komponentenbasierte Entwicklung wollen
  • Websites, wo Plugin-Konflikte Wartungs-Alpträume verursachen
  • E-Commerce-Websites, die WooCommerce-Performance-Limits erreichen
  • Marketing-Websites, die A/B-Testing und Personalisierung am Edge brauchen

Vor-Migrations-Audit: Was WordPress wirklich tut

Hier gehen die meisten Migrationen schief. Menschen denken, sie migrieren einen Blog, aber WordPress handhabt tatsächlich Kontaktformulare, Weiterleitungen, Bildoptimierung, Suche, Kommentare, Authentifizierung, Cron-Jobs und fünfzehn andere Dinge, die in Plugin-Konfigurationen vergraben sind.

Vor dem Schreiben einer einzigen Zeile Next.js-Code dokumentiere alles:

Plugin-Bestandsaufnahme

Exportiere deine Plugin-Liste und kategorisiere jedes eine:

wp plugin list --status=active --format=csv > active-plugins.csv

Beantworte für jedes Plugin: Was macht das, und was ersetzt es im Next.js-Ökosystem?

WordPress-Plugin Funktion Next.js-Ersatz
Yoast SEO Meta-Tags, Sitemaps, Schema next-seo + benutzerdefinierte sitemap.xml-Route
WP Rocket Caching, Minifizierung Vercel Edge Cache + Next.js eingebaut
Contact Form 7 Formularverarbeitung React Hook Form + API-Route oder Formspree
Wordfence Sicherheit Nicht erforderlich (keine Admin-Oberfläche)
WPML Mehrsprachig next-intl oder eingebautes i18n-Routing
WooCommerce E-Commerce Shopify Storefront API oder Saleor
Advanced Custom Fields Benutzerdefinierte Content-Modelle Content-Modellierung deines Headless-CMS
Redirection URL-Weiterleitungen next.config.js-Weiterleitungen oder Vercel-Konfiguration
WP Cron Geplante Aufgaben Vercel Cron Jobs oder separater Service
Imagify Bildoptimierung next/image mit Vercel Image Optimization

Content-Bestandsaufnahme

Zähle und kategorisiere deinen Content:

SELECT post_type, post_status, COUNT(*) 
FROM wp_posts 
GROUP BY post_type, post_status;

Vergiss nicht: benutzerdefinierte Post-Typen, Taxonomie-Begriffe, Benutzerprofile, Menüstrukturen, Widget-Konfigurationen und Option-Werte. Die "einfache" WordPress-Website hat wahrscheinlich mehr Content-Typen als du denkst.

URL-Mapping

Exportiere jede URL. Jede einzelne. Verwende Screaming Frog oder einen einfachen Sitemap-Crawl:

curl -s https://yoursite.com/sitemap_index.xml | \
grep -oP '<loc>\K[^<]+' | \
xargs -I {} curl -s {} | \
grep -oP '<loc>\K[^<]+' > all-urls.txt

Diese Datei ist Gold. Du wirst sie für Weiterleitungs-Mapping, SEO-Erhaltung und QA-Tests nach der Migration verwenden.

WordPress to Next.js Migration auf Vercel - Architektur

Auswahl deines Headless-CMS-Backends

Du brauchst irgendwo zum Speichern und Verwalten von Content. Die drei häufigsten Wege im Jahr 2026:

Option 1: WordPress als Headless-CMS

Ja, du kannst WordPress als Backend behalten und Next.js als Frontend verwenden. WPGraphQL (jetzt bei v2.1) macht dies überraschend praktikabel. Deine Redakteure behalten die vertraute Admin-Oberfläche. Du bekommst ein modernes Frontend.

// lib/wordpress.js
const API_URL = process.env.WORDPRESS_GRAPHQL_URL;

export async function getPostBySlug(slug) {
  const res = await fetch(API_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      query: `
        query PostBySlug($slug: ID!) {
          post(id: $slug, idType: SLUG) {
            title
            content
            date
            featuredImage {
              node {
                sourceUrl
                altText
              }
            }
            seo {
              title
              metaDesc
              opengraphImage {
                sourceUrl
              }
            }
          }
        }
      `,
      variables: { slug },
    }),
    next: { revalidate: 60 },
  });
  const json = await res.json();
  return json.data.post;
}

Der Nachteil? Du wartest immer noch eine WordPress-Installation. Sicherheits-Updates, PHP-Versionsverwaltung, Datenbank-Backups — alles bleibt auf deinem Teller. Und du zahlst immer noch für WordPress-Hosting.

Option 2: Purpose-Built Headless CMS

Das empfehle ich für die meisten Migrationen. Verschiebe deinen Content zu einem CMS, das von Grund auf für API-First-Auslieferung gebaut wurde.

CMS Preisgestaltung (2026) Beste für Content-Modellierung API-Typ
Sanity Kostenlos, $15/Benutzer/Mo Pro Komplexer Content, Echtzeit-Zusammenarbeit Exzellent, Code-definiert GROQ + GraphQL
Contentful Kostenlos, $300/Mo Team Enterprise, große Teams Gut, UI-definiert REST + GraphQL
Storyblok Kostenlos, €106/Mo Business Visuelles Editing, Komponenten Großartig, visuell REST + GraphQL
Strapi v5 Kostenlos (selbst-gehostet), Cloud ab $29/Mo Volle Kontrolle, Open Source Flexibel, UI-definiert REST + GraphQL
Payload CMS 3.0 Kostenlos (selbst-gehostet) Entwickler, die Code-First wollen Exzellent, Code-definiert REST + GraphQL

Wenn dein Team bei Social Animal die Migration handhabt, empfehlen wir typischerweise Sanity oder Payload für Headless-CMS-Entwicklung — sie geben Entwicklern die meiste Kontrolle über Content-Modellierung, während Redakteure glücklich bleiben.

Option 3: Markdown/MDX im Repository

Für Entwickler-Blogs und Dokumentations-Websites ist das Speichern von Content als MDX-Dateien in deinem Git-Repo der einfachste Ansatz. Kein CMS zum Verwalten, keine API-Aufrufe, Content versioniert neben Code. Aber das funktioniert nur, wenn deine Content-Redakteure sich mit Git-Workflows wohlfühlen.

Content-Migrationsstrategie

Exportieren aus WordPress

Der eingebaute WordPress-Export (Tools → Export) gibt dir eine XML-Datei. Es ist ein Anfang, aber es ist unordentlich. Für strukturierte Migration verwende ich ein benutzerdefiniertes WP-CLI-Skript:

// export-content.php
<?php
$posts = get_posts([
    'post_type' => ['post', 'page', 'your_custom_type'],
    'posts_per_page' => -1,
    'post_status' => 'publish',
]);

$export = [];
foreach ($posts as $post) {
    $export[] = [
        'id' => $post->ID,
        'title' => $post->post_title,
        'slug' => $post->post_name,
        'content' => apply_filters('the_content', $post->post_content),
        'excerpt' => $post->post_excerpt,
        'date' => $post->post_date,
        'modified' => $post->post_modified,
        'author' => get_the_author_meta('display_name', $post->post_author),
        'categories' => wp_get_post_categories($post->ID, ['fields' => 'names']),
        'tags' => wp_get_post_tags($post->ID, ['fields' => 'names']),
        'featured_image' => get_the_post_thumbnail_url($post->ID, 'full'),
        'acf' => function_exists('get_fields') ? get_fields($post->ID) : [],
        'yoast' => [
            'title' => get_post_meta($post->ID, '_yoast_wpseo_title', true),
            'description' => get_post_meta($post->ID, '_yoast_wpseo_metadesc', true),
        ],
    ];
}

file_put_contents('export.json', json_encode($export, JSON_PRETTY_PRINT));

Transformieren von Content

WordPress-Content wird als HTML mit Gutenberg-Block-Markup gespeichert. Du musst entscheiden: das HTML behalten und rendern, oder zu einem strukturierten Format deines CMS konvertieren?

Für Sanity verwende ich @sanity/block-tools um HTML zu Portable Text zu konvertieren. Für Contentful handhabt ihre Migration CLI die Rich-Text-Konvertierung. Egal wie, budget Zeit für Content-Bereinigung — WordPress-Content ist voll von [shortcodes], Inline-Stilen und fehlerhaftem HTML, das bereinigt werden muss.

// migrate-to-sanity.js
import { htmlToBlocks } from '@sanity/block-tools';
import { JSDOM } from 'jsdom';
import { Schema } from '@sanity/schema';

const schema = Schema.compile({ /* your schema */ });
const blockContentType = schema.get('post')
  .fields.find(f => f.name === 'body').type;

function convertPost(wpPost) {
  return {
    _type: 'post',
    title: wpPost.title,
    slug: { current: wpPost.slug },
    publishedAt: wpPost.date,
    body: htmlToBlocks(
      wpPost.content,
      blockContentType,
      { parseHtml: (html) => new JSDOM(html).window.document }
    ),
  };
}

Bild-Migration

Überspringe das nicht. Lade jedes Bild von wp-content/uploads herunter, lade es erneut zu deinem CMS oder CDN hoch (Cloudinary, Vercel Blob Storage, S3), und aktualisiere alle Content-Referenzen. Ich schreibe typischerweise ein Skript, das:

  1. Die Export-JSON nach Bild-URLs crawlt
  2. Jedes Bild herunterlädt
  3. Zu den neuen Speicher hochlädt
  4. Eine URL-Mapping-Datei erstellt
  5. Find-and-Replace über alle Content läuft

Neuerstellung deines Frontends in Next.js 15

Next.js 15 (stabil seit Spätsommer 2024, mit 15.2 aktuell im Jahr 2026) verwendet standardmäßig den App Router. Hier ist die Struktur, die ich für Content-lastige Websites verwende:

app/
├── layout.tsx          # Root-Layout mit Schriften, Analytics
├── page.tsx            # Homepage
├── blog/
│   ├── page.tsx        # Blog-Listing mit Paginierung
│   └── [slug]/
│       └── page.tsx    # Individuelle Blog-Beiträge
├── [slug]/
│   └── page.tsx        # Generische Seiten
├── sitemap.ts          # Dynamische Sitemap-Generierung
├── robots.ts           # robots.txt
└── not-found.tsx       # Benutzerdefinierte 404

Statische Generierung mit ISR

Für die meisten Content-Seiten ist Incremental Static Regeneration der Sweet Spot — statische Performance mit dynamischer Frische:

// app/blog/[slug]/page.tsx
import { getPostBySlug, getAllPostSlugs } from '@/lib/cms';
import { notFound } from 'next/navigation';

export async function generateStaticParams() {
  const slugs = await getAllPostSlugs();
  return slugs.map((slug) => ({ slug }));
}

export async function generateMetadata({ params }) {
  const post = await getPostBySlug(params.slug);
  if (!post) return {};
  return {
    title: post.seo?.title || post.title,
    description: post.seo?.description || post.excerpt,
    openGraph: {
      images: [post.featuredImage?.url],
    },
  };
}

export const revalidate = 3600; // Revalidiere alle Stunde

export default async function BlogPost({ params }) {
  const post = await getPostBySlug(params.slug);
  if (!post) notFound();

  return (
    <article className="prose lg:prose-xl">
      <h1>{post.title}</h1>
      <time dateTime={post.date}>{formatDate(post.date)}</time>
      <PostBody content={post.body} />
    </article>
  );
}

Für Websites, die Echtzeit-Updates brauchen (Nachrichten, Live-Content), verwende On-Demand-Revalidation via Webhooks von deinem CMS. Die meisten Headless-CMS-Plattformen unterstützen Webhook-Trigger beim Content-Publish.

Wenn du dich Next.js-Entwicklung anschaust und die Rendering-Trade-Offs tiefer verstehen möchtest, haben wir das separat geschrieben.

URL-Struktur und SEO-Erhaltung

Das ist nicht verhandelbar. Wenn du deine URL-Struktur verlierst, verlierst du deine Suchranking. Punkt.

Weiterleitungs-Map

WordPress verwendet URL-Patterns wie /2024/03/post-slug/ oder /category/term/. Deine Next.js-Website verwendet wahrscheinlich /blog/post-slug. Erstelle eine Weiterleitungs-Map:

// next.config.js
module.exports = {
  async redirects() {
    return [
      // Datumbasierte URLs zu sauberen Slugs
      {
        source: '/:year(\\d{4})/:month(\\d{2})/:slug',
        destination: '/blog/:slug',
        permanent: true,
      },
      // Kategorie-Archive
      {
        source: '/category/:slug',
        destination: '/blog?category=:slug',
        permanent: true,
      },
      // Paginierung
      {
        source: '/page/:num',
        destination: '/blog?page=:num',
        permanent: true,
      },
      // Feed-URLs
      {
        source: '/feed',
        destination: '/rss.xml',
        permanent: true,
      },
    ];
  },
};

Für große Websites (1000+ Weiterleitungen), verwende stattdessen Vercels vercel.json-Konfiguration oder Middleware — next.config.js-Weiterleitungen haben ein weiches Limit von etwa 1024 Einträgen, bevor Build-Zeiten zu leiden anfangen.

Strukturierte Daten

WordPress-Plugins wie Yoast generieren automatisch JSON-LD. Du musst das replizieren:

// components/structured-data.tsx
export function ArticleSchema({ post }) {
  const schema = {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: post.title,
    datePublished: post.date,
    dateModified: post.modified,
    author: {
      '@type': 'Person',
      name: post.author,
    },
    image: post.featuredImage?.url,
    publisher: {
      '@type': 'Organization',
      name: 'Your Site Name',
      logo: { '@type': 'ImageObject', url: '/logo.png' },
    },
  };

  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

XML-Sitemap

Next.js 15 macht dynamische Sitemaps unkompliziert:

// app/sitemap.ts
import { getAllPosts, getAllPages } from '@/lib/cms';

export default async function sitemap() {
  const posts = await getAllPosts();
  const pages = await getAllPages();

  return [
    { url: 'https://yoursite.com', lastModified: new Date() },
    ...pages.map((page) => ({
      url: `https://yoursite.com/${page.slug}`,
      lastModified: page.modified,
    })),
    ...posts.map((post) => ({
      url: `https://yoursite.com/blog/${post.slug}`,
      lastModified: post.modified,
    })),
  ];
}

Bereitstellung auf Vercel: Konfiguration, die tatsächlich funktioniert

Projekt-Setup

npx create-next-app@latest my-migrated-site --typescript --tailwind --app
cd my-migrated-site
vercel link

Umgebungsvariablen

Stelle diese in Vercels Dashboard ein, nicht in .env-Dateien, die zu Git committed sind:

CMS_API_URL=https://your-cms-api-endpoint
CMS_API_TOKEN=your-read-only-token
REVALIDATION_SECRET=a-random-string-for-webhook-auth
SITE_URL=https://yoursite.com

Vercel-Konfiguration

// vercel.json
{
  "crons": [
    {
      "path": "/api/revalidate-sitemap",
      "schedule": "0 */6 * * *"
    }
  ],
  "headers": [
    {
      "source": "/fonts/(.*)",
      "headers": [
        { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" }
      ]
    }
  ]
}

On-Demand Revalidation Webhook

// app/api/revalidate/route.ts
import { revalidatePath } from 'next/cache';
import { NextRequest, NextResponse } from 'next/server';

export async function POST(request: NextRequest) {
  const secret = request.headers.get('x-revalidation-secret');
  if (secret !== process.env.REVALIDATION_SECRET) {
    return NextResponse.json({ error: 'Invalid secret' }, { status: 401 });
  }

  const body = await request.json();
  const { slug, type } = body;

  if (type === 'post') {
    revalidatePath(`/blog/${slug}`);
    revalidatePath('/blog'); // Revalidiere auch das Listing
  } else {
    revalidatePath(`/${slug}`);
  }

  return NextResponse.json({ revalidated: true });
}

Verweise den Webhook deines CMS auf https://yoursite.com/api/revalidate mit dem Secret-Header. Jetzt erscheinen Content-Updates innerhalb von Sekunden ohne vollständige Rebuilds.

Performance-Benchmarks: Vorher und Nachher

Diese sind echte Zahlen von Migrationen, die wir bei Social Animal 2025-2026 abgeschlossen haben:

Metrisch WordPress (WP Engine) Next.js (Vercel) Verbesserung
Lighthouse Performance 62-78 95-100 +30-40%
Largest Contentful Paint 2,8-4,2s 0,8-1,4s 60-70% schneller
Time to First Byte 800ms-1,5s 50-120ms 90%+ schneller
Cumulative Layout Shift 0,12-0,25 0,01-0,05 ~80% Reduktion
Monatliche Hosting-Kosten $115/Mo Durchschnitt $20-40/Mo 60-80% Ersparnis
Build-Zeit (500 Seiten) N/A (dynamisch) 45-90 Sekunden N/A
Seiten/Sekunde (ISR) 15-30 req/s 10.000+ vom Edge Größenordnungen

Die TTFB-Verbesserung allein ist die Migration wert. WordPress generiert jede Seite durch PHP und MySQL. Vercel bedient vorab geränderte Seiten von Edge-Knoten an über 300 Orten weltweit.

Häufige Migrations-Fallstricke

Fallstrick 1: WordPress-RSS-Feeds vergessen. Wenn Menschen deinen Feed abonnieren, leite /feed/ und /rss/ zu einem neuen RSS-Endpoint. Next.js generiert standardmäßig keine Feeds — du brauchst eine benutzerdefinierte Route.

Fallstrick 2: WordPress-Shortcodes fehlen. Content, das aus WordPress exportiert wird, ist voller [gallery], [embed] und Plugin-spezifischen Shortcodes. Wenn du diese nicht parsest und konvertierst, werden sie als reiner Text gerendert. Schreibe Transformers für jeden Shortcode-Typ, den dein Content verwendet.

Fallstrick 3: WordPress-Kommentar-Daten ignorieren. Wenn du wertvolle Comment-Threads hast, migriere sie zu einem Service wie Disqus oder baue ein benutzerdefiniertes Kommentar-System. Die meisten Leute lassen Kommentare einfach fallen, aber frag zuerst die Stakeholder.

Fallstrick 4: Nicht-Testen von internen Links. WordPress-Content ist voll von internen Links mit absoluten URLs (https://yoursite.com/old-path/). Diese müssen zu relativen Pfaden oder deiner neuen URL-Struktur aktualisiert werden. Ein einfacher Regex-Find-and-Replace während der Migration handhabt die meisten Fälle.

Fallstrick 5: wp-content/uploads-Referenzen vergessen. Selbst nach der Image-Migration kann alter Content /wp-content/uploads/2024/03/image.jpg-Pfade referenzieren. Richte eine Catch-All-Weiterleitung ein oder proxy diese zu deinem neuen Image-CDN.

Wenn dies überwältigend wirkt, ist das ehrlich gesagt normal. Eine richtige Migration dauert 4-12 Wochen je nach Komplexität der Website. Schau dir unsere Preisgestaltung an oder kontaktiere uns direkt, wenn du erfahrene Hände für das Projekt möchtest.

FAQ

Wie lange dauert eine WordPress-zu-Next.js-Migration? Für eine Website mit 100-500 Seiten, erwarte 4-8 Wochen mit einem dedizierten Entwickler. Größere Websites mit benutzerdefinierten Post-Typen, E-Commerce oder mehrsprachigem Content können 8-16 Wochen dauern. Die Content-Migration selbst ist normalerweise 20% der Arbeit — die anderen 80% sind Template-Neuerstellung, Edge-Case-Handhabung und QA-Tests jeder URL.

Werde ich meine Google-Rankings während der Migration verlieren? Nicht, wenn du Umleitungen richtig handhabst. Implementiere 301-Umleitungen für jede URL, die sich ändert, bewahre deine Meta-Titles und Beschreibungen, reiche deine neue Sitemap zu Google Search Console ein, und verwende das Change-of-Address-Tool, wenn deine Domain sich ändert. Erwarte eine kleine Ranking-Fluktuation für 2-4 Wochen, dann Erholung oder Verbesserung, wenn Google bessere Core Web Vitals erkennt.

Kann ich WordPress als mein CMS mit Next.js verwenden? Absolut. Das wird "Headless WordPress" genannt und es ist ein beliebter Ansatz. Verwende WPGraphQL um deinen Content als API freizugeben, dann konsumiere ihn aus Next.js. Deine Redakteure behalten das WordPress-Admin-Panel, das sie kennen. Der Hauptnachteil ist, dass du immer noch eine WordPress-Installation wartest — Sicherheits-Updates, Hosting, der ganze Stack.

Wie viel kostet es, von WordPress zu Next.js zu migrieren? DIY mit einem Entwickler: 100-300 Stunden Arbeit. Agency-Migration: typischerweise $15.000-$75.000 je nach Komplexität. Laufende Hosting-Kosten sinken normalerweise — Vercel Pro bei $20/Benutzer/Monat versus verwaltetes WordPress-Hosting bei $50-$300/Monat. Der ROI kommt von reduzierten Hosting-Kosten, besserer Performance (was Conversion-Raten verbessert) und niedrigerem Maintenance-Overhead.

Sollte ich den Pages Router oder App Router in Next.js 15 verwenden? App Router, Punkt. Im Jahr 2026 ist der App Router die stabile Standardeinstellung mit Server Components, Streaming und parallelen Routes. Der Pages Router funktioniert immer noch und ist nicht veraltet, aber neue Features und Optimierungen sind App Router-erste. Jede Migration, die wir bei Social Animal durchführen, verwendet den App Router exklusiv. Schau dir unsere Next.js-Entwicklungs-Fähigkeiten für mehr über unseren Ansatz an.

Was ist mit Formularen und dynamischer Funktionalität? Next.js API-Routes (oder Server Actions im App Router) handhabt Formular-Einreichungen, Suche, Authentifizierung und jegliche Server-Seite-Logik. Für Kontaktformulare kannst du Server Actions mit einem Service wie Resend für Email-Versand verwenden. Für Suche, bedenke Algolia oder Meilisearch. Für Authentifizierung, NextAuth.js (jetzt Auth.js v5) deckt die meisten Fälle.

Ist Vercel die einzige Option zum Hosten von Next.js? Nein. Du kannst Next.js auf Netlify, AWS Amplify, Cloudflare Pages oder Self-Host mit Node.js deployen. Allerdings wird Vercel vom Next.js-Team gebaut, und die Integration zeigt sich — ISR, Edge-Middleware, Bild-Optimierung und Analytics funktionieren alle beste auf Vercel. Die DX-Lücke zwischen Vercel und Alternativen hat sich 2026 verengt, aber Vercel bleibt der Pfad des geringsten Widerstands.

Was ist, wenn ich einen WooCommerce-Store migrieren muss? Das ist ein größeres Projekt. Die meisten Teams migrieren die Storefront zu Next.js während sie das Commerce-Backend zu Shopify verschieben (mit Storefront API), Medusa.js oder Saleor. Shopifys Hydrogen-Framework ist eine andere Option, aber wenn du volle Kontrolle über das Frontend möchtest, ist Next.js mit Shopifys API der beweisteste Weg. Erwarte, dass die E-Commerce-Migration 4-8 Wochen zu deiner Timeline hinzufügt.