Ich baue Websites seit Jahren mit Headless-CMS-Plattformen. Contentful, Sanity, Strapi -- du kennst sie alle, ich habe sie alle integriert. Aber irgendwann Ende 2025 fiel mir ein Muster auf: Bei einer wachsenden Anzahl von Projekten griff ich überhaupt nicht mehr zu einem CMS. Stattdessen versendete ich vollständige Full-Stack-Apps mit Next.js auf Vercel, Supabase für Daten und Authentifizierung, und der Claude API für jede Content-Intelligence, die ich brauchte. Kein CMS-Anbieter. Keine Content-Modellierungs-UI. Keine monatlichen Seat-Lizenzen.

Das ist nicht kontrar sein wollen. Es gibt absolut Projekte, bei denen ein Headless CMS die richtige Wahl ist -- wir bauen viele davon bei Social Animal (schau dir unsere Headless-CMS-Entwicklungsarbeit an). Aber es gibt eine spezifische Klasse von Anwendungen, bei denen dieser anbieterfreie Stack nicht nur machbar ist, sondern besser. Lass mich dir genau zeigen, wie es funktioniert, wann du es verwenden solltest, und wie du es von Grund auf aufbaust.

Inhaltsverzeichnis

• Warum Entwickler das CMS fallen lassen
• Der Stack auf einen Blick
• Einrichten deines Next.js-Projekts auf Vercel
• Supabase als dein Backend: Authentifizierung, Datenbank und Speicher
• Integration der Claude API für Content Intelligence
• Erstellen einer benutzerdefinierten Admin-Oberfläche
• Echte Kosten: Was dieser Stack dich tatsächlich kostet
• Wann du immer noch ein CMS verwenden solltest
• Produktionsbereitschafts-Checkliste
• Häufig gestellte Fragen

Warum Entwickler das CMS fallen lassen

Lass uns ehrlich sein, was ein CMS dir gibt: eine UI für nicht-technische Leute, um Inhalte zu bearbeiten, eine strukturierte Datenschicht, vielleicht etwas Medienverwaltung, und eine API, um alles abzurufen. Das ist wirklich wertvoll, wenn du ein Marketing-Team hast, das jeden Tag Blog-Beiträge veröffentlicht.

Aber hier ist, was ich 2026 immer wieder sehe:

• SaaS-Produkte, bei denen der "Inhalt" benutzergenerierten Daten ist, nicht redaktionelle Kopie
• Interne Tools, bei denen das Team technisch genug ist, um direkt eine Datenbank zu bearbeiten oder ein einfaches Admin-Panel zu verwenden
• KI-native Anwendungen, bei denen Inhalte on-the-fly generiert, zusammengefasst oder transformiert werden
• Startups, die sich $300-500/Monat für ein CMS nicht leisten können, wenn sie nur drei Benutzer haben

Für diese Projekte ist ein CMS Overhead. Du zahlst für Content-Modellierungsfunktionen, die du nicht verwendest, verwaltest API-Schlüssel für einen Service, der im Grunde nur ein schöner Datenbankwrapper ist, und handelst mit komplexer Webhook-Komplexität, um Dinge synchron zu halten.

Die Alternative? Besitze deine Datenschicht vollständig. Supabase gibt dir Postgres (eine echte Datenbank, nicht einen proprietären Content Store), Authentifizierung, Dateispeicher und Echtzeit-Abonnements. Claude kümmert sich um die Intelligence-Schicht. Next.js und Vercel kümmern sich um alles andere.

Der Stack auf einen Blick

Schicht	Technologie	Rolle	2026 Preise (Start)
Frontend & API	Next.js 15 (App Router)	UI, Server Components, Route Handlers	Kostenlos (Open Source)
Hosting & Edge	Vercel	Deployment, CDN, Serverless Functions	Kostenlos / $20/Mo Pro
Datenbank & Authentifizierung	Supabase	Postgres, Row Level Security, Auth, Storage	Kostenlos / $25/Mo Pro
KI-Schicht	Claude API (Anthropic)	Content-Generierung, Zusammenfassung, Klassifizierung	Pay-per-Token (~$3/$15 pro 1M Token für Sonnet 4)
Admin UI	Custom (React + Supabase)	Content-Verwaltung für dein Team	$0 (du baust es)

Gesamtkosten für eine produktive App mit moderatem Traffic: $45-100/Monat. Vergleiche das mit einem typischen Headless-CMS-Setup, bei dem das CMS allein $99-500/Monat kosten könnte, bevor du überhaupt für Hosting zahlst.

Einrichten deines Next.js-Projekts auf Vercel

Ich gehe davon aus, dass du Node.js 20+ und ein Vercel-Konto hast. Wenn du neu bei Next.js bist, hat unser Team ausführlich darüber auf unserer Next.js-Entwicklungs-Fähigkeitsseite geschrieben.

npx create-next-app@latest my-app --typescript --tailwind --app --src-dir
cd my-app

Next.js 15 mit dem App Router ist die Grundlage. Wir verwenden Server Components standardmäßig, was bedeutet, dass der größte Teil unseres Datenabrufs auf dem Server passiert -- keine exponierten API-Schlüssel, keine Client-seitigen Lade-Spinner für anfängliche Inhalte.

Hier ist meine typische Projektstruktur für diesen Stack:

src/
├── app/
│   ├── (public)/           # Marketing-Seiten, Blog
│   ├── (dashboard)/        # Authentifizierter Admin-Bereich
│   │   ├── layout.tsx      # Auth-Check-Wrapper
│   │   ├── posts/
│   │   ├── media/
│   │   └── settings/
│   ├── api/
│   │   ├── ai/             # Claude-API-Routen
│   │   └── webhooks/       # Supabase-Echtzeit-Hooks
│   └── layout.tsx
├── lib/
│   ├── supabase/
│   │   ├── client.ts       # Browser-Client
│   │   ├── server.ts       # Server-Client
│   │   └── admin.ts        # Service-Role-Client
│   ├── claude.ts           # Anthropic-SDK-Wrapper
│   └── utils.ts
├── components/
└── types/

Umgebungsvariablen

Du benötigst diese in deiner .env.local:

NEXT_PUBLIC_SUPABASE_URL=your-project-url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
SUPABASE_SERVICE_ROLE_KEY=your-service-key
ANTHROPIC_API_KEY=sk-ant-...

Deployment auf Vercel

Push zu GitHub. Verbinde das Repo in Vercel. Füge deine Umgebungsvariablen hinzu. Fertig. Ich werde das nicht weiter ausführen -- Vercels DX für Next.js-Deployment ist die beste in der Branche und du kennst wahrscheinlich schon, wie es funktioniert.

Eine Sache ist zu beachten: Nutze Vercels Edge Config, wenn du Feature Flags oder Konfigurationen brauchst, die sich ohne erneutes Deployment aktualisieren. Es ist eine kleine Sache, aber es ersetzt noch ein weiteres SaaS-Tool.

Supabase als dein Backend: Authentifizierung, Datenbank und Speicher

Hier passiert die Magie. Supabase ist nicht nur "Firebase aber Postgres" -- es ist eine vollständige Backend-Plattform, die dir gehört. Deine Daten leben in einer Standard-PostgreSQL-Datenbank. Wenn du jemals gehen möchtest, machst du pg_dump und verlässt dich. Versuche das mit einem proprietären CMS.

Datenbankschema

Nehmen wir an, du baust eine inhaltsgesteuerte App (die Art von Sache, für die du normalerweise zu einem CMS greifen würdest). Hier ist ein Schema, das Artikel, Medien und grundlegende Taxonomie behandelt:

-- UUID-Generierung aktivieren
create extension if not exists "uuid-ossp";

-- Content-Tabelle (ersetzt dein CMS-Content-Modell)
create table public.posts (
  id uuid default uuid_generate_v4() primary key,
  title text not null,
  slug text unique not null,
  body text, -- Markdown-Inhalt
  excerpt text,
  status text default 'draft' check (status in ('draft', 'published', 'archived')),
  author_id uuid references auth.users(id),
  featured_image text, -- Supabase-Speicherpfad
  metadata jsonb default '{}', -- Flexible Felder, keine Migration nötig
  published_at timestamptz,
  created_at timestamptz default now(),
  updated_at timestamptz default now()
);

-- Tags / Taxonomie
create table public.tags (
  id uuid default uuid_generate_v4() primary key,
  name text unique not null,
  slug text unique not null
);

create table public.post_tags (
  post_id uuid references public.posts(id) on delete cascade,
  tag_id uuid references public.tags(id) on delete cascade,
  primary key (post_id, tag_id)
);

-- Row Level Security
alter table public.posts enable row level security;

-- Jeder kann veröffentlichte Posts lesen
create policy "Public can read published posts"
  on public.posts for select
  using (status = 'published');

-- Authentifizierte Benutzer können ihre eigenen Posts verwalten
create policy "Authors can manage own posts"
  on public.posts for all
  using (auth.uid() = author_id);

Diese metadata jsonb-Spalte ist der Schlüssel. Sie gibt dir die Flexibilität von benutzerdefinierten CMS-Feldern ohne dass du Migrationen durchführen musst, jedes Mal wenn das Marketing-Team ein neues Feld will. Brauchst du eine SEO-Beschreibung? metadata->>'seo_description'. Brauchst du ein Open-Graph-Bild-Override? metadata->>'og_image'. Es ist schemalos, wo du Flexibilität brauchst, strukturiert, wo du Integrität brauchst.

Authentifizierungseinrichtung

Supabase Auth kümmert sich um alles. E-Mail/Passwort, Magic Links, OAuth mit Google/GitHub -- es ist alles eingebaut.

// lib/supabase/server.ts
import { createServerClient } from '@supabase/ssr'
import { cookies } from 'next/headers'

export async function createClient() {
  const cookieStore = await cookies()

  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll()
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value, options }) =>
            cookieStore.set(name, value, options)
          )
        },
      },
    }
  )
}

Dateispeicher

Supabase Storage ersetzt das, was auch immer dein CMS als Medienbibliothek hatte. Erstelle einen Bucket namens media, richte eine Policy ein, und du hast einen S3-kompatiblen Dateispeicher mit automatischen CDN-URLs.

// Datei hochladen
const { data, error } = await supabase.storage
  .from('media')
  .upload(`posts/${slug}/${file.name}`, file, {
    cacheControl: '3600',
    upsert: false,
  })

// Öffentliche URL abrufen
const { data: { publicUrl } } = supabase.storage
  .from('media')
  .getPublicUrl(`posts/${slug}/${file.name}`)

Integration der Claude API für Content Intelligence

Hier weicht der 2026-Stack am stärksten von traditioneller Webentwicklung ab. Die Claude API ist nicht nur ein Chatbot -- sie ist eine Intelligence-Schicht, die ganze Kategorien von CMS-Plugins und Third-Party-Services ersetzen kann.

Hier ist, wofür ich sie in Produktion nutze:

• Automatisches Generieren von SEO-Metadaten aus Post-Inhalten
• Content-Zusammenfassung für Auszüge und Social Cards
• Content-Klassifizierung und automatisches Tagging
• Intelligente Suche, die Intent versteht, nicht nur Keywords
• Draft-Unterstützung für Content-Autoren

Einrichten des Anthropic SDK

npm install @anthropic-ai/sdk

// lib/claude.ts
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY!,
})

export async function generateSEOMetadata(content: string, title: string) {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: `Given this article title and content, generate SEO metadata.

Title: ${title}
Content: ${content.slice(0, 3000)}

Respond with JSON only:
{
  "seo_title": "50-60 char title with primary keyword",
  "seo_description": "120-160 char meta description",
  "excerpt": "1-2 sentence hook for social sharing",
  "suggested_tags": ["tag1", "tag2", "tag3"]
}`,
      },
    ],
  })

  const text = message.content[0].type === 'text' ? message.content[0].text : ''
  return JSON.parse(text)
}

export async function classifyContent(content: string, existingTags: string[]) {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 256,
    messages: [
      {
        role: 'user',
        content: `Classify this content into the most relevant tags from the existing list. You may suggest up to 2 new tags if nothing fits.

Existing tags: ${existingTags.join(', ')}

Content: ${content.slice(0, 2000)}

Respond with JSON: { "tags": ["tag1", "tag2"], "new_tags": ["maybe-new"] }`,
      },
    ],
  })

  const text = message.content[0].type === 'text' ? message.content[0].text : ''
  return JSON.parse(text)
}

API-Route für KI-Funktionen

// app/api/ai/seo/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server'
import { generateSEOMetadata } from '@/lib/claude'

export async function POST(request: NextRequest) {
  const supabase = await createClient()
  const { data: { user } } = await supabase.auth.getUser()

  if (!user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  const { content, title } = await request.json()
  
  try {
    const metadata = await generateSEOMetadata(content, title)
    return NextResponse.json(metadata)
  } catch (error) {
    return NextResponse.json(
      { error: 'AI generation failed' },
      { status: 500 }
    )
  }
}

Die Kosten hier sind vernachlässigbar. Ein typischer SEO-Metadaten-Generierungsaufruf verwendet vielleicht 4.000 Input-Token und 200 Output-Token. Bei Claude Sonnets Preisgestaltung von ungefähr $3/1M Input-Token und $15/1M Output-Token sind das etwa $0,015 pro Aufruf. Du könntest Metadaten für 1.000 Artikel für $15 generieren.

Erstellen einer benutzerdefinierten Admin-Oberfläche

Das ist der Teil, der Menschen nervös macht. "Wenn ich kein CMS habe, wie können nicht-technische Menschen Inhalte bearbeiten?"

Du baust eine einfache Admin-UI. Und 2026 ist "einfach" tatsächlich einfach. Hier ist eine einfache Post-Editor-Komponente:

// app/(dashboard)/posts/[id]/editor.tsx
'use client'

import { useState } from 'react'
import { createBrowserClient } from '@supabase/ssr'

export function PostEditor({ post }: { post: Post }) {
  const [title, setTitle] = useState(post.title)
  const [body, setBody] = useState(post.body || '')
  const [saving, setSaving] = useState(false)
  
  const supabase = createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  )

  async function save() {
    setSaving(true)
    const { error } = await supabase
      .from('posts')
      .update({
        title,
        body,
        updated_at: new Date().toISOString(),
      })
      .eq('id', post.id)

    setSaving(false)
    if (error) alert('Save failed: ' + error.message)
  }

  async function generateSEO() {
    const res = await fetch('/api/ai/seo', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ title, content: body }),
    })
    const metadata = await res.json()
    // Generierte Metadaten auf den Post anwenden
    await supabase
      .from('posts')
      .update({ metadata, excerpt: metadata.excerpt })
      .eq('id', post.id)
  }

  return (
    <div className="max-w-4xl mx-auto p-6">
      <input
        type="text"
        value={title}
        onChange={(e) => setTitle(e.target.value)}
        className="text-3xl font-bold w-full mb-4 border-b pb-2"
      />
      <textarea
        value={body}
        onChange={(e) => setBody(e.target.value)}
        className="w-full h-96 font-mono text-sm p-4 border rounded"
      />
      <div className="flex gap-4 mt-4">
        <button onClick={save} disabled={saving}
          className="px-4 py-2 bg-blue-600 text-white rounded">
          {saving ? 'Saving...' : 'Save Draft'}
        </button>
        <button onClick={generateSEO}
          className="px-4 py-2 bg-purple-600 text-white rounded">
          ✨ Generate SEO Metadata
        </button>
      </div>
    </div>
  )
}

Ja, das ist eine einfache Textarea. In einem echten Projekt würdest du etwas wie Tiptap, MDXEditor oder BlockNote für reichhaltige Bearbeitung einswappen. Der Punkt ist: Die Admin-Oberfläche ist dein Code. Du kontrollierst jeden Pixel, jeden Workflow, jede Berechtigung. Kein Kampf mit CMS-UI-Einschränkungen.

Für komplexere Projekte sollte Refine oder AdminJS als Admin-Panel-Frameworks in Betracht gezogen werden, die direkt mit Supabase verbunden sind. Sie werden dir Wochen sparen.

Echte Kosten: Was dieser Stack dich tatsächlich kostet

Lass uns konkrete Zahlen für eine inhaltsreiche Website mit 100K Seitenaufrufen/Monat nennen:

Service	Tier	Monatliche Kosten	Was du bekommst
Vercel	Pro	$20	1TB Bandbreite, 1000 GB-Stunden Serverless
Supabase	Pro	$25	8GB Datenbank, 250GB Bandbreite, 100K Auth-Benutzer
Claude API	Pay-as-you-go	~$10-30	~5M Token/Monat (SEO-Generierung, Zusammenfassungen, Suche)
Domain	Annual	~$1	.com-Domain
Gesamt		$56-76/Mo

Vergleiche das jetzt mit einem typischen Headless-CMS-Stack:

Service	Tier	Monatliche Kosten
Contentful	Team	$300
Vercel	Pro	$20
Algolia (Suche)	Build	$50
Auth0 (Authentifizierung)	Essentials	$35
Gesamt		$405/Mo

Das ist ein 5-6x Kostenunterschied. Und der Supabase-Stack gibt dir mehr Flexibilität, nicht weniger.

Wann du immer noch ein CMS verwenden solltest

Ich möchte hier realistisch sein. Wirf nicht dein CMS für jedes Projekt weg. Ein Headless CMS ist immer noch die bessere Wahl, wenn:

• Große redaktionelle Teams brauchen strukturierte Workflows (Genehmigungsketten, Zeitplanung, Rollen, die über grundlegende RBAC hinausgehen)
• Inhalt ist das Produkt -- Verlage, Mediaunternehmen, Dokumentations-Websites mit hunderten von Mitwirkenden
• Du brauchst visuelles Editing -- einige CMS-Plattformen bieten Live-Vorschau und visuelle Builder an, die Monate zum Replizieren brauchen würden
• Multi-Channel-Delivery -- wenn derselbe Inhalt eine Website, Mobile App, digitale Beschilderung und E-Mail speist, verdient sich das strukturierte Content-Modell eines CMS seinen Platz
• Lokalisierung im Maßstab -- CMS-Plattformen wie Contentful und Sanity haben ausgefeilte i18n-Workflows

Wir bauen immer noch viele Headless-CMS-Projekte bei Social Animal. Wenn das dein Projekt braucht, wende dich an uns. Aber für die wachsende Kategorie von Apps, bei denen es nicht nötig ist, hör auf, dafür zu zahlen.

Produktionsbereitschafts-Checkliste

Bevor du diesen Stack in die Produktion verschiebst, gehe diese Liste durch:

• Row Level Security Policies getestet für jede Tabelle (Supabase's Policy Simulator hilft dabei)
• Rate Limiting auf Claude-API-Routen (nutze Vercels @vercel/edge Rate Limiter oder upstash/ratelimit)
• Input-Validierung auf allen API-Routen (Zod ist dein Freund)
• Error Boundaries in deinem React-Tree für KI-Fehler (Claude wird gelegentlich zeitlich überschreitet)
• Caching-Strategie -- nutze unstable_cache oder revalidateTag in Next.js für datenbankgestützte Seiten
• Monitoring -- Vercel Analytics für Performance, Supabase Dashboard für Datenbank-Metriken, Anthropic Console für API-Nutzung
• Backup-Strategie -- Supabase Pro includes tägliche Backups, aber richte auch logische Replikation oder pg_dump Cron für Seelenfrieden ein
• Content Security Policy Header konfiguriert in next.config.js
• Bildoptimierung -- nutze Next.js <Image>-Komponente mit Supabase Storage URLs

Häufig gestellte Fragen

Kann Supabase wirklich ein Headless CMS ersetzen? Für viele Anwendungsfälle ja. Supabase gibt dir eine PostgreSQL-Datenbank mit REST und GraphQL API, die automatisch aus deinem Schema generiert werden, Dateispeicher, Authentifizierung und Echtzeit-Abonnements. Was es dir nicht gibt, ist eine polierte Content-Editing-UI out of the box -- du musst das selbst bauen oder ein Tool wie Refine verwenden. Wenn dein Team technisch ist oder klein, ist dieser Tradeoff absolut wert.

Wie viel kostet die Claude API für eine typische Website? Für eine Content-Website, die Claude für SEO-Metadaten-Generierung, Content-Zusammenfassung und grundlegende Klassifizierung nutzt, erwarte etwa $10-30/Monat mit moderater Nutzung (mehrere hundert KI-Operationen). Claude Sonnets Preisgestaltung 2026 liegt bei ungefähr $3 pro Million Input-Token und $15 pro Million Output-Token. Ein einzelner SEO-Metadaten-Generierungsaufruf kostet etwa $0,01-0,02.

Ist dieser Stack für Enterprise-Anwendungen geeignet? Das hängt von deiner Definition von Enterprise ab. Vercel und Supabase bieten beide Enterprise-Tiers mit SLAs, SOC 2 Konformität und dediziertem Support an. Der Stack handhabt hohen Traffic gut -- Next.js auf Vercel skaliert automatisch, und Supabase Pro unterstützt Connection Pooling und Read Replicas. Für Compliance-intensive Branchen würde Supabase's selbst gehostete Option verwendet, um Daten in deiner eigenen Infrastruktur zu halten.

Was ist mit Content-Vorschau und Draft-Workflows? Du baust sie. Next.js Draft Mode kombiniert mit einer status-Spalte in deiner Posts-Tabelle gibt dir Draft/Published-Workflows. Für Vorschau, erstelle eine authentifizierte Route, die Posts unabhängig vom Status abruft. Es sind vielleicht 50 Codezeilen versus Konfigurieren von Preview-URLs in einem CMS-Dashboard.

Wie handhabst du Rich-Text-Bearbeitung ohne CMS? Nutze eine moderne Rich-Text-Editor-Bibliothek. Tiptap (basierend auf ProseMirror) ist die beliebteste Wahl 2026 -- es unterstützt kollaboratives Editing, benutzerdefinierte Blöcke, Slash-Befehle und Markdown-Shortcuts. BlockNote ist eine weitere solide Option mit einer Notion-ähnlichen UI. Speichere die Ausgabe als HTML, Markdown oder JSON in deiner Supabase body-Spalte.

Kann ich von einem Headless CMS zu diesem Stack migrieren? Absolut. Die meisten Headless-CMS-Plattformen haben Export-APIs. Schreibe ein Migrations-Skript, das Inhalte von deiner CMS-API abruft und sie in Supabase-Tabellen einfügt. Wir haben diese Migration für mehrere Kunden durchgeführt und sind von Contentful und Sanity zu Supabase-gestützten Setups gewechselt. Der schwierigste Teil ist normalerweise, das proprietäre Rich-Text-Format des CMS auf Standard-HTML oder Markdown abzubilden.

Was passiert, wenn Supabase ausfällt? Supabase hat solide Uptime in 2025-2026 gehabt, aber kein Service ist perfekt. Da deine Daten in Standard-PostgreSQL leben, hast du Optionen: Richte Read Replicas ein, halte automatisierte Backups in S3, oder führe sogar eine Standby-Instanz. Wenn du auf Supabase's selbst gehosteter Tier bist, kontrollierst du die Infrastruktur vollständig. Das ist tatsächlich widerstandsfähiger als von einem CMS-Anbieter abhängig zu sein -- wenn Contentful einen Ausfall hat, kannst du nicht einfach "zu einem anderen Contentful wechseln".

Sollte ich diesen Stack für einen Blog oder Marketing-Website verwenden? Für einen persönlichen Entwickler-Blog oder eine Startup-Marketing-Website ist dieser Stack perfekt. Du bekommst vollständige Kontrolle, minimale Kosten und KI-gestützte Funktionen, die teure Plugins in einem CMS erfordern würden. Für ein großes Marketing-Team, das 20+ Artikel pro Woche mit komplexen Genehmigungsworkflows veröffentlicht, würdest du wahrscheinlich ein echtes CMS wollen. Es geht darum, das Werkzeug zum Team zu passen. Wenn du unsicher bist, welcher Ansatz zu deinem Projekt passt, schau auf unsere Preisseite oder kontaktiere uns für einen schnellen Beratungstermin.