Ein Shop, fünf Stacks: Wie NovaDB als CMS, PIM und DAM in jede Architektur passt
NovaDB ersetzt nicht Ihr Frontend, sondern speist es. Redaktion, Produktmanagement und Medienverwaltung arbeiten in einem System; Ihre Website liest das Ergebnis über eine HTTP-Schnittstelle, die Delivery API, und ist sonst völlig frei in der Wahl von Sprache, Framework und Hosting. Das behaupten viele Headless-Systeme. Wir haben es deshalb nicht behauptet, sondern gebaut: einen vollständigen Online-Shop, Nova Merchandising, und diesen Shop in fünf verschiedenen Technologien, die alle dieselben Daten live aus NovaDB lesen und für Besucher nicht zu unterscheiden sind.
Dieser Artikel zeigt, was dabei herausgekommen ist. Er richtet sich an drei Gruppen. Agenturen sehen, wie schnell eine Website auf NovaDB steht und wie wenig Code dafür nötig ist. Produktmanager sehen, wie Produkte, Werte und Preise je Markt gepflegt werden, ohne dass dafür ein Entwickler gebraucht wird. Lead und Senior Developer sehen den Weg von der URL bis zum HTML in React Router, Blazor, Razor mit htmx, Nuxt und Astro, jeweils mit dem Code, der mit NovaDB spricht, und mit den Stellen, an denen sich die Stacks unterscheiden.
Alle fünf Demos laufen öffentlich, ihr Quelltext ist jeweils ein eigenes Repository und ist so geschrieben, dass Sie ihn lesen, verstehen und für Ihr eigenes Projekt verändern können. Kein SDK, keine versteckte Schicht: Wer die Delivery API mit einem einfachen HTTP-Client anspricht, sieht in jeder Demo genau das, was über die Leitung geht.
Nova Merchandising, die Startseite in Deutsch. Jeder Preis, jedes Foto und jedes Wort ist ein Datensatz in NovaDB. Wo finde ich den Shop und den Code?
Der Shop läuft unter www.merch.novadb.com. Das ist die Referenz-Demo (React Router) unter der zentralen Adresse. Die Startadresse wählt die Region nach der Sprache Ihres Browsers: Deutschland mit Euro, Großbritannien mit Pfund, die USA mit Dollar. Der Checkout läuft im Testmodus, es wird nichts verkauft.
Jeden der fünf Stacks gibt es zusätzlich unter einer eigenen Adresse und mit eigenem Quelltext. Beides ist bei jedem Stack im Abschnitt Wie sehen die fünf Demos im Detail aus? verlinkt; alle Repositories finden Sie gesammelt unter github.com/novadb.
Der Shop und die Idee
Was ist Nova Merchandising?
Nova Merchandising verkauft Merchandise für Menschen, die bauen, testen und ausliefern: T-Shirts, Tassen, Kapuzenpullover, Thermoskannen, Sticker und Laptop-Hüllen mit Sprüchen wie „Content is Data“ oder „API-First Developer“. Der Shop ist bewusst klein, aber vollständig. Er hat alles, was eine echte Website braucht, und genau das ist der Punkt: Eine Demo mit zwei Seiten und einer Produktliste beweist nichts.
- Drei Regionen. Die erste URL-Stelle entscheidet über Sprache, Texte, Währung und Preise:
/de/zeigt Deutsch und Euro,/uk/Englisch und Pfund,/us/Englisch und Dollar. Kein Cookie, kein Marktschalter, keine versteckte Zustandsverwaltung. - Seitenbaum und Kollektionen. Startseite, Shop mit sechs Kategorieseiten, drei Kollektionen, „Über uns“, „Hinter den Kulissen“ und Impressum. Die Redaktion legt Seiten an und ordnet sie in NovaDB; die Website folgt den Daten.
- Eine Produktreihe mit Filtern. Gruppe, Farbe, Material, Verfügbarkeit und Preis, Sortierung, Suche mit Vorschlägen, „Mehr anzeigen“ in Zwölferschritten.
- Kaufen über das vorhandene Shopsystem. Am Produkt steht eine einzige ID, die des Shopsystems. In dieser Demo ist es Shopify: Sein Buy Button bringt Warenkorb und Checkout mit, und der Checkout läuft im Testmodus. Mit einem anderen Shopsystem trägt das Produkt dessen ID.
- Funktioniert ohne JavaScript. Filter, Sortierung, Suche und „Mehr anzeigen“ sind echte Formulare. JavaScript macht sie schneller, aber nicht erst möglich.
Eine Kategorie mit Live-Filtern. Warum bauen wir denselben Shop fünfmal?
Weil „NovaDB passt zu jedem Stack“ ein Satz ist, den jeder schreiben kann. Ein Entwicklungsleiter, der eine Plattform auswählt, will wissen, wie sie sich in seinem Stack anfühlt: wie viele Zeilen es sind, wie idiomatisch der Code ist und was passiert, wenn er etwas ändern möchte. Eine einzige Demo beantwortet das nur für einen Stack. Fünf Demos mit gleichem Verhalten beantworten es für fünf und zeigen nebenbei, was an der Integration Konstante ist und was Geschmack des Frameworks.
Jede Demo wird an denselben fünf Zielen gemessen, in dieser Reihenfolge:
- Leicht zu lesen. Ein kurzer Weg von der URL zum HTML, keine eigene Schicht dazwischen. Weniger Zeilen schlagen mehr.
- Es geht um NovaDB. Der Code, der mit der Delivery API spricht (Client, Namen, Abbildung, Rendern der Inhalte), ist das, was ein Leser mitnimmt: offen, an einer Stelle je Thema.
- Alles andere klein, aber sauber. Shop, Bilder, SEO und Deployment je in der kleinsten Form, die im Konzept richtig ist.
- Modern und idiomatisch. So geschrieben, wie ein erfahrener Entwickler dieses Stacks heute schreibt. Eine Portierung übersetzt Verhalten, nicht Code.
- Vollständig. Eine echte Website, die gegen die Live-API läuft, die gemeinsame Testsuite besteht und genauso aussieht und sich genauso verhält wie die anderen.
„Der Vertrag legt fest, was die Website tut. Die Ziele entscheiden, wie. Innerhalb des Vertrags schlägt Lesbarkeit jede Raffinesse.“
Leitsatz der Demos, sinngemäß
Dieser Vertrag ist ein Dokument, das unabhängig von jeder Programmiersprache beschreibt, was die Website tut: Routen, Regionen, Breadcrumbs, Suche, Medien, SEO. Wo eine Demo wegen ihres Ansatzes abweichen muss, steht die Abweichung in einer Liste und im README der Demo, mit den Teilen der Testsuite, die für sie nicht gelten. Nichts bleibt stillschweigend weg.
Aus dieser Arbeit sind vier Aussagen entstanden, die wir Ihnen mit den Demos belegen können:
- NovaDB passt zu jeder Architektur. Serverseitig gerendert, hydriert, rein statisch vorgebaut, mit Blazor oder fast ohne JavaScript: Die Daten kommen immer auf demselben Weg an.
- NovaDB braucht kein SDK und kein Framework. Die .NET-Demos lesen mit einem schlichten
HttpClientundSystem.Text.Json, die anderen mitfetch. - NovaDB funktioniert mit dem, worüber Entwickler heute sprechen. React Router 8, Nuxt 4, Astro 7, ASP.NET Core 10, htmx 4.
- Eine Website auf NovaDB ist schnell. Alle fünf Demos lesen live aus der Delivery API, und die antwortet so zügig, dass keine Demo eine eigene Datenbank oder einen Suchindex braucht.
Seiten: NovaDB als CMS
Wo beginnt die Arbeit in NovaDB?
„Was ein Objekt hat, ist konfiguriert, nicht programmiert.“
Der Satz, der auch auf der Seite des Shops steht
Jede Seite, jedes Produkt und jedes Bild dieses Shops wird in NovaDB gepflegt, und zwar an einer Stelle. Die Seite „Hinter den Kulissen“ des Shops zeigt dazu Bildschirmfotos aus dem System; sie sind die Grundlage der Bilder in diesem Artikel. Alle Bildschirmfotos aus NovaDB sind englisch, weil die Oberfläche des Systems in dieser Sprache lief.
Alle starten im selben Bereich, „Products & Pages“. Er zeigt, woraus der Shop besteht: Seiten, Produkte, Produktgruppen, Farben, Materialien, Oberflächen und Bilder. Dazu zwei Arten, den Bestand zu durchsuchen, das Produktportfolio und den Seitenbaum, und ein Dashboard. Welche Bereiche es gibt und was darin liegt, ist frei konfigurierbar. Ein kleiner Shop wie dieser kommt mit einem aus; ein größeres Unternehmen richtet einen je Team, Marke oder Markt ein.
Wichtig für alle drei Zielgruppen: Den Typ „Product“ mit Farbe, Material, Oberfläche, Preis je Markt und Shopify-ID haben wir für diese Demo in NovaDB angelegt, kein Code der Website definiert ihn. Ein anderer Shop bekommt andere Typen und andere Felder, ein Hoodie andere als eine Tasse. So sieht der Typ in NovaDB aus.
Der Bereich „Products & Pages“ in NovaDB. Wie baut die Redaktion Seiten?
Aus fertigen Bausteinen. Die Redaktion baut jede Seite aus denselben Bausteinen, den Visual Components: Hero, Split, Rail, Kapitel, farbiges Band und so weiter. Der Editor zeigt sie so, wie Besucher sie sehen werden, und einen neuen Abschnitt zieht man per Drag-and-drop auf die Seite. Die Seite „Coffee & Code“ im Bild besteht nur aus solchen Bausteinen; es gibt keinen Code, der speziell für sie geschrieben wurde.
Für diesen Shop haben wir uns auf 27 Bausteine festgelegt, jeder benennt eine Form und kein Thema. Eine Seite wird aus ihnen gemacht, ein Baustein nie für eine einzelne Seite. Das ist eine Entscheidung des Projekts, keine Grenze von NovaDB: Einige Bausteine wie Hero, Split oder Kapitel braucht ohnehin fast jede Website, und alle sind wie der Rest des Modells Konfiguration. Ein neuer Baustein ist schnell angelegt, einer, den niemand braucht, ebenso schnell entfernt. Die feste Auswahl zahlt sich in der Zusammenarbeit aus: Die Entwickler stylen eine überschaubare Zahl von Formen, und die Redaktion baut damit beliebig viele Seiten, ohne zu fragen.
Damit der Editor wie die Website aussieht, kommt sein Stylesheet aus derselben CSS-Datei wie die Seite selbst: Ein markierter Abschnitt von site.css wird dem Editor mitgegeben. Was die Redaktion sieht, ist keine Annäherung, es ist dasselbe CSS.
Der Seiteneditor mit der Palette der Bausteine. Für Entwickler: ein Komponentenbaum, ein Renderer
Der Inhalt einer Seite ist ein Visual Document: im Grunde ein Komponentenbaum, wie man ihn aus React oder Vue kennt, und davon einer je Sprache. Jede Komponente darin hat type, definition, element und class. Der Typ bestimmt den Rest: Eine group enthält weitere Komponenten, ein text hat XHTML als Inhalt, image und object verweisen mit einer objectId auf ein Bild, ein Produkt oder eine andere Seite. Das CMS nennt sogar das Element (section, div, h2) und die CSS-Klasse. Ein Renderer muss die 27 Bausteine deshalb nicht kennen. Er schreibt <element class> und setzt Inhalt oder Kinder hinein. Der ganze Renderer der Referenz-Demo in React:
function ContentNode({ node, ctx, sizes = CONTENT_SIZES }: { node: VNode; ctx: Ctx; sizes?: string }) {
const Tag = (node.element || "div") as keyof JSX.IntrinsicElements;
switch (node.type) {
case "group": {
const childSizes = node.class === "merchChapter" ? CHAPTER_SIZES : node.class === "imageWithCaption" ? sizes : CONTENT_SIZES;
return <Tag className={node.class}>{node.children?.map((child, i) => <ContentNode key={i} node={child} ctx={ctx} sizes={childSizes} />)}</Tag>;
}
case "image":
return node.objectId && ctx.images[node.objectId] ? <img className={node.class} src={ctx.images[node.objectId]} srcSet={srcSet(ctx.images[node.objectId])} sizes={sizes} alt="" loading="lazy" /> : null;
case "object": {
const product = node.objectId ? ctx.products[node.objectId] : undefined;
const target = node.objectId ? ctx.targets[node.objectId] : undefined;
if (product) return <Tag className={node.class}><ProductCard product={product} ctx={ctx} /></Tag>;
return target ? <Tag className={node.class}><PageTeaser target={target} /></Tag> : null;
}
default:
return <Tag className={node.class} dangerouslySetInnerHTML={{ __html: rewriteLinks(node.content ?? "", ctx.targets) }} />;
}
}
Das sind rund zwanzig Zeilen. Ein eingebettetes Produkt wird zur Produktkarte, eine eingebettete Seite zum Teaser, und Links im Text, die in NovaDB auf ein Objekt zeigen, werden in Adressen der Website umgeschrieben. Mehr passiert nicht. Wer morgen einen 28. Baustein einführt, ändert NovaDB und das Stylesheet, aber keine Zeile in diesem Renderer. Typen, Attribute und Bausteine sind dabei selbst Konfiguration in NovaDB; so sieht der Typ „Product“ dort aus.
Produkte und Märkte: NovaDB als PIM
Wie pflegt das Produktmanagement Produkte?
Mit Werten statt Freitext. Farbe, Material und Oberfläche sind in diesem Shop keine Textfelder, sondern eigene Objekte, die die Produktdatenmanager einmal pflegen. Ein Produkt verweist auf sie. Dadurch heißt „Schwarz“ in jedem Produkt gleich und in jeder Sprache so, wie es dort heißen soll (Schwarz, Black), und eine Farbe trägt außerdem den Hex-Wert ihres Farbfelds. Eine neue Farbe braucht keinen Code und kein CSS: Sie wird in NovaDB angelegt, und der Farbfilter der Website zeigt sie mit dem richtigen Farbfeld, in der Referenz-Demo nach spätestens einer Minute.
Auch die Namen der Produktfelder kommen aus NovaDB. Die Website druckt „Artikelnummer“ oder „Farbe“ unter dem Namen, den ein Redakteur im System sieht, nämlich dem Namen der Attributdefinition. Wer einen Namen ändern will, ändert ihn dort und nicht im Code.
Das Portfolio zeigt die Produktgruppen als Baum und ihre Produkte als Kacheln. Jede Produktgruppe auf der Website ist eine Kategorieseite mit einer Live-Auswahl; eine Kollektion dagegen ist eine Seite, in die die Redaktion Produktkarten beliebiger Gruppen einsetzt.
Das Produktportfolio: Gruppen als Baum, ihre Produkte als Kacheln.
Ein Produkt in NovaDB: links das Formular mit ähnlichen Produkten, Artikelnummer, Farbe und Preisen je Markt, rechts die Vorschau, so wie der Shop es zeigt. Ein Produkt, jeder Markt
Preise werden je Markt eingegeben, und welche Märkte es gibt, ist ebenfalls konfigurierbar. Technisch ist der Preis eine Variante: Das Attribut ist von der Variantenachse merchMarket abhängig, mit den Mitgliedern merchMarketEU, merchMarketUK und merchMarketUS. Die Region der URL wählt das Mitglied. Ohne variants=… fehlt der Preis, und ein Filter oder eine Sortierung nach ihm ist ein Fehler 400, eine Eigenschaft, die man früh lernt und danach schätzt: Ein Preis aus dem falschen Markt kann gar nicht erst auf die Seite kommen.
Auch Suchmaschinen sehen die Region: Jede Seite und jedes Produkt trägt eine absolute canonical-Adresse und hreflang-Verweise auf alle drei Regionen (de, en-GB, en-US) und auf die Startadresse, die eine Region wählt (x-default). Eine gefilterte Ansicht nennt die Seite ohne Filter als kanonisch.
Fehlende Übersetzungen bleiben fehlend
Eine Entscheidung, die uns Diskussionen mit Agenturen erspart hat: Die Website fällt nie auf eine andere Sprache zurück. Ein sprachabhängiges Attribut liefert den Wert, der für genau diese Sprache eingegeben wurde, und nichts sonst; fehlt die Übersetzung, fehlt der Schlüssel im Ergebnis, und die Website lässt die Stelle aus. Der displayName eines Objekts ist nie leer, weil er auf eine Sprache zurückfällt, die einen Text hat. Er ist deshalb ein Etikett und keine Übersetzung, und die Demos drucken ihn nie anstelle eines fehlenden Texts. Das macht Lücken sichtbar, statt sie zu verstecken, und das Dashboard (unten) kann sie zählen.
Auch die Oberflächentexte liegen in NovaDB
Die Texte der Oberfläche („In den Warenkorb“, „Mehr anzeigen“, „Suchen nach …“) sind merchLabel-Objekte mit einem sprachneutralen Schlüssel und einem Text je Sprache. Alle fünf Demos lesen sie von dort, statt sie zu kopieren. Ein geänderter Text ist eine Änderung in NovaDB und kein Release. Dass eine Agentur ihrem Kunden diese Texte selbst überlassen kann, ist in der Praxis oft der Moment, in dem ein Headless-Projekt für die Fachabteilung real wird.
Ein Dashboard als Beispiel
Ein Dashboard ist frei konfigurierbar und kann deshalb beantworten, was einem Team wichtig ist: fehlende Übersetzungen, Produkte ohne Bild, Preise, die noch zu prüfen sind. Dieses hier ist ein kleines Beispiel. Es zählt die kaufbaren Produkte, also die, die auf Lager sind und eine Shopify-ID tragen, insgesamt und je Gruppe.
Es ist eine kleine Vorlage, die in NovaDB selbst liegt, für Entwickler eine Razor-Ansicht. Eine Falle, in die wir dabei gelaufen sind und die wir Ihnen ersparen wollen: Ein nicht gesetztes Attribut liest sich als ein Eintrag mit dem Wert null, nicht als leere Liste. Die Ansicht prüft deshalb jeden Eintrag, bevor sie zählt.
Ähnlich flexibel sind die Vorschauen neben den Formularen: Jede Art von Objekt kann beliebig viele eigene Vorschauen haben, und eine Änderung an einer Vorschau erreicht alle, die Produkte pflegen, sofort.
Ein Dashboard als Beispiel: Welche Produkte lassen sich auf der Website kaufen? Das Kuchendiagramm zählt alle, die Balken je Gruppe, darunter die Vertriebskanäle. Bilder: NovaDB als DAM
Wo liegen die Bilder?
Einmal, in der Medienbibliothek. Jedes Bild liegt genau einmal in NovaDB, mit Vorschau, Datei und den Seiten, die es verwenden. Seiten und Produkte verweisen nur darauf; ein Bild wird an einer einzigen Stelle gepflegt. Welche Angaben ein Bild trägt, etwa Copyright oder Fotograf, ist frei konfigurierbar. Wer die Datei eines Bildes ersetzt, ändert sie auf jeder Seite, die es zeigt.
Für die Website ist ein Bild ein Objekt eines Dateityps: Das Objekt ist die Datei. Der Typ gibt zwei Attribute an die Delivery API frei, den MD5-Wert und die Dateiendung. Beide zusammen sind eine Inhaltsadresse: files/{md5}{ext} liefert immer genau dieselben Bytes. Daraus folgt alles Weitere.
Die Medienbibliothek mit ihren Vorschauen. Nie ein veraltetes Bild
Der Browser eines Besuchers bekommt nie die alte Fassung eines Bildes zu sehen, und Bilder laden trotzdem schnell. Der Shop bietet jede Datei unter einem Namen an, der seinen Inhalt nie ändert:
/media/{md5}/original{ext}: der Proxy zufiles/{md5}{ext}. Jede Datei wird einmal von NovaDB geholt und auf der Platte behalten./media/{md5}/{breite}{ext}.webp: dieselbe Datei skaliert auf 400, 800, 1200 oder 1600 Pixel als WebP mit Qualität 80, nie vergrößert, einmal erzeugt und auf der Platte behalten.- Alle Antworten tragen
Cache-Control: public, max-age=31536000, immutable, einen ETag und antworten bei Anfrage mit 304. - Jedes Bild im HTML hat ein
srcsetmit allen vier Breiten und einsizes, das zu seinem Platz im Layout passt.
Dass die Bilder über die eigene Website laufen und nicht direkt von NovaDB, hat einen zweiten Grund: Der Zugang zur Delivery API ist ein serverseitiges Geheimnis, der Browser bekommt ihn nie zu sehen.
Der Datensatz eines Bildes: Vorschau, Dateityp, Dateiname und die Seite, die es verwendet. Für Entwickler: API, Suche und Kauf
Über die Delivery API, eine HTTP-Schnittstelle mit JSON. Die vollständige Beschreibung finden Sie in der API-Dokumentation; hier das, was für die Demos wichtig ist. Ein Produkt, so wie die Website es liest:
GET /branches/merchDemo/types/merchProduct/objects
?lang=de-DE&props=0&take=1&variants=merchMarketEU
&filter=merchProductSku: "NM-MG-02-GRN"
&resolve=merchProductImages
Authorization: Basic …
{
"objs": [{
"meta": { "id": 4711 },
"props": {
"merchProductName": "\"API-First\" Developer",
"merchProductSku": "NM-MG-02-GRN",
"merchProductPrice": 12.9,
"merchProductInStock": true,
"merchProductImages": [4712]
}
}],
"refs": [{
"meta": { "id": 4712 },
"props": { "externalBinaryMD5": "3f2a…", "externalBinaryFileExtension": ".png" }
}],
"more": false
}
Die Antwort ist hier gekürzt. Alles Wichtige steht in diesem Aufruf, und jeder Teil davon ist in der Website ein bewusster Entschluss:
| Konzept | Was es ist | Was die Website damit macht |
|---|---|---|
| Branch | merchDemo | Die Einheit der Veröffentlichung. Die Website legt sich auf einen fest und mischt nie zwei. |
| Identifier | merchProduct, merchProductSku | Numerische IDs von Branches, Typen und Attributen unterscheiden sich je Installation, API-Identifier nicht. Der Code spricht nur Identifier und hält alle in einer Datei. Sie sind Konfiguration in NovaDB, hier am Typ „Product“ zu sehen. |
lang | de-DE, en-US | Eine Sprache je Anfrage. Der Wert dieser Sprache, sonst nichts. |
variants | merchMarketEU … | Wählt den Markt. Ohne ihn gibt es keinen Preis. |
resolve | merchProductImages | Liefert die Bilder des Produkts in refs derselben Antwort mit, ohne zweite Anfrage. |
filter, sort | Lucene-Syntax mit :, $score | Volltextsuche. Eingaben von Besuchern werden zu Präfix-Begriffen (+term*) bereinigt, nie unverändert durchgereicht. |
skip, take, more | höchstens 1000 je Seite | Die Website liest einen Typ Seite für Seite, bis more falsch ist. |
props | 0 oder 1 | 0 liefert die freigegebenen Attribute des Typs, 1 alle benannten; nötig für NovaDBs eigene Typen, etwa die Attributnamen. |
So sucht der Shop
Die Suche der Website ist ein einziger Filter:
(merchProductName: +kaff* || merchProductSku: +kaff* || merchProductDescription: +kaff*) sort=$score
Produkte werden nach Name, Artikelnummer und Beschreibung gefunden und nach Relevanz sortiert; dazu kommen bis zu fünf Seiten über Titel und Inhalt. Die Vorschläge unter dem Suchfeld sind dieselbe Abfrage mit kleineren Grenzen: höchstens fünf Produkte und drei Seiten, und nichts unterhalb von zwei Zeichen.
Warum es kein SDK gibt
Weil die Schnittstelle klein genug ist, dass ein SDK mehr verdeckt als hilft. Der gesamte Client der Referenz-Demo hat rund 50 Zeilen Code: Basic-Auth aus der Umgebung, ein Zwischenspeicher von 60 Sekunden, Seitenweise lesen. Der Kern ist diese Funktion:
export async function list(type: string, q: ListQuery): Promise<{ objs: NovaObject[]; refs: NovaObject[] }> {
const take = q.take ?? PAGE_SIZE;
const all: { objs: NovaObject[]; refs: NovaObject[] } = { objs: [], refs: [] };
for (let skip = 0, more = true; more; skip += take) {
const url = deliveryUrl(`types/${type}/objects`, { lang: q.lang, props: q.props ?? 0, skip, take, filter: q.filter, sort: q.sort, variants: q.variants, resolve: q.resolve });
const page = await getJson<ListResponse>(url);
all.objs.push(...page.objs);
all.refs.push(...(page.refs ?? []));
more = page.more && q.take === undefined;
}
return all;
}
Wer sie liest, hat die Schnittstelle verstanden. Und weil sie so klein ist, sieht sie in jeder Sprache fast gleich aus, wie die Demos weiter unten zeigen.
Wie kommt der Kauf ins Shopsystem?
Mit einer einzigen ID, und nicht nur mit Shopify. NovaDB ist an kein Shopsystem gebunden: Wer einen Shop betreibt, hat ein Shopsystem, und die Website muss ein Produkt nur an dieses übergeben. Dafür genügt die ID, unter der das Shopsystem das Produkt kennt.
In dieser Demo ist es Shopify. Ein Produkt in NovaDB trägt das Attribut merchProductShopifyId; die Produktseite gibt es an den Buy Button von Shopify weiter (data-shopify-product), und der bringt seinen eigenen Warenkorb und seinen eigenen Checkout mit. Wir bauen weder Warenkorb noch Bestellstrecke nach. Das ist die kleinste Form, die im Konzept richtig ist.
Shopify kennt dieselben Produkte, mit deutschen und englischen Titeln und festen Preislisten für Pfund und Dollar neben den Euro-Preisen, und veröffentlicht sie nur im Kanal des Buy Buttons. NovaDB merkt sich je Produkt die Shopify-ID. Die Preise, die Besucher sehen, kommen trotzdem aus NovaDB, und zwar aus dem Markt der Region; Shopify rechnet nur ab. Dass Shopify dieselben Titel und Preise kennt, besorgt ein Job in NovaDB und nicht die Redaktion von Hand.
Der schwebende Warenkorb am Seitenrand ist der von Shopify, in der Sprache der Region. Der Checkout des Demo-Shops läuft im Testmodus: Hier wird nichts verkauft.
Bei einem anderen Shopsystem oder einem eigenen Checkout ändert sich nur, welche ID am Produkt steht und welcher Button sie liest. Datenmodell, Pflege und Website bleiben dieselben.
Die Startseite bei 390 Pixel Breite. Gebaut mit Agenten
Das Datenmodell des Shops ist konfiguriert und nicht programmiert: Typen, Attribute, Bausteine, Vorschauen und das Dashboard sind Einstellungen in NovaDB. Eine Regel hat sich dabei bewährt, weil sie Streit erspart: Jeder API-Identifier trägt ein Präfix (hier merch), ist über alle Branches eindeutig und wird nicht mehr umbenannt, sobald eine Website ihn liest. Für die Website ist er Teil des Vertrags.
Danach trennen sich die Wege. Die Struktur ändern die Entwickler, mit Bedacht und selten. Inhalte ändert die Redaktion im Editor, jederzeit und ohne Release: einen Text, eine Seite, ein Bild, einen Preis.
Wie baut eine Agentur ihre Website mit Agenten?
In NovaDB ist nicht nur der Inhalt über eine Schnittstelle erreichbar, sondern auch die Konfiguration. Die Delivery API liefert einem KI-Agenten die veröffentlichten Daten. Die CMS API zeigt ihm das ganze Modell: Typen, Attribute, Formulare, Bausteine, Vorschauen und Dashboards. Und er kann es nicht nur lesen, sondern auch anlegen und erweitern.
Anderswo schreibt KI Texte in ein fertiges System. Bei NovaDB kann sie das System mitbauen, in dem diese Texte später gepflegt werden. Für eine Agentur heißt das: Website, Datenmodell und Redaktionsoberfläche entstehen zusammen mit dem Agenten, in dem Stack, den das Team beherrscht. Die Demos dieses Artikels sind der Ausgangspunkt, und der Agent liest sie wie jeder Entwickler.
Die Kontrolle bleibt beim Menschen. Lesen, Inhalte schreiben und die Konfiguration ändern sind getrennte Rechte, und Änderungen entstehen in einem Branch, bevor sie jemand übernimmt.
Der Typ „Product“ in NovaDB: API-Identifier und Attribute sind Konfiguration, lesbar und änderbar über die CMS API. Fünf Stacks. Ein Ergebnis.
Wie sehen die fünf Demos im Detail aus?
Alle fünf liefern dieselben Seiten mit demselben HTML und denselben CSS-Klassen, und alle laufen live. Jede Demo ist ein eigenes Repository (merch-react-router, merch-blazor-dotnet und so weiter) mit eigenem README, eigener Abhängigkeitsverwaltung und eigenem Dockerfile. Es gibt keinen Code, der zwischen den Demos geteilt wird, damit jede für sich lesbar bleibt. Geteilt werden nur Dateien, die für alle gleich sein müssen: das Stylesheet, die Schriften, die Logos und das Skript site.js, soweit eine Demo keine eigenen Client-Komponenten hat.
Jeder Stack hat unten seinen eigenen Abschnitt. Der Button Live-Demo ansehen öffnet denselben Shop, ausgeliefert von genau diesem Stack; er sieht für Besucher so aus wie www.merch.novadb.com. Der Link Quelltext auf GitHub führt zum öffentlichen Repository mit einem README zum Starten und der Datei NOVADB.md, die beschreibt, wie die Website NovaDB liest.
Die Demos unterscheiden sich darin, wann sie rendern und wie viel JavaScript im Browser landet; das zeigen die Abschnitte unten. Im Aufwand unterscheiden sie sich kaum: Jede der fünf Websites kommt mit rund 1.500 Zeilen Code aus, gezählt ohne Kommentare, Tests und das gemeinsame Stylesheet. Astro bringt zusätzlich den Builder und die Auslieferung über Caddy mit, die bei den anderen der Framework-Server übernimmt. Das hat uns beim Bauen am meisten überrascht: Wenn der Weg von der Schnittstelle zur Seite kurz ist, entscheidet nicht die Technologie über den Aufwand, sondern der Umfang des Shops.
React Router 8: die Referenz
Die erste Demo definiert HTML-Struktur, CSS-Klassen, Schlüssel der Oberflächentexte, Routen und Verhalten, die alle anderen übernehmen. Sie rendert auf dem Server, danach übernimmt React: Navigation mit <Link>, und die Live-Auswahl, die Suchvorschläge und der Shopify-Button sind Komponenten, die Formulare als Fetcher an die Aktionen der Routen schicken. Der Delivery-Client und der Renderer der Inhalte sind die beiden Ausschnitte weiter oben. Die Identifier stehen alle in einer Datei, schema.ts:
export const PRODUCT = {
name: "merchProductName",
description: "merchProductDescription",
sku: "merchProductSku",
group: "merchProductGroupRef",
price: "merchProductPrice",
inStock: "merchProductInStock",
images: "merchProductImages",
similar: "merchProductSimilar",
shopifyId: "merchProductShopifyId",
color: "merchProductColorRef",
} as const;
Wer ein neues Attribut liest, trägt es dort ein und nirgendwo sonst. Die Demo hat keine Abweichungen vom Vertrag.
ASP.NET Core 10 Blazor: Razor-Komponenten ohne Interaktivität
Die Blazor-Demo benutzt nur Razor-Komponenten (.razor) und rendert sie ausschließlich auf dem Server, als statisches SSR, ohne blazor.web.js und ohne Verbindung zum Server nach dem Laden. Das gemeinsame site.js übernimmt die Interaktion. Für .NET-Teams ist sie der vertrauteste Einstieg, und sie zeigt, dass „Blazor“ nicht „WebSocket“ heißen muss.
Der Client ist ein schlichter HttpClient ohne das Paket NovaDB.Content, damit der Leser das Protokoll sieht. Bemerkenswert ist, dass der Zwischenspeicher die Aufgabe behält und nicht das Ergebnis, sodass gleichzeitige Anfragen eine einzige Abfrage teilen:
public async Task<ListResult<TProps>> ListAsync<TProps>(string type, ListQuery q)
{
var take = q.Take ?? PageSize;
var result = new ListResult<TProps>([], []);
for (var skip = 0; ; skip += take)
{
var url = QueryHelpers.AddQueryString($"branches/{Uri.EscapeDataString(Branch)}/types/{type}/objects", new Dictionary<string, string?>
{
["lang"] = q.Lang, ["props"] = q.Props.ToString(), ["skip"] = skip.ToString(), ["take"] = take.ToString(),
["filter"] = q.Filter, ["sort"] = q.Sort, ["variants"] = q.Variants, ["resolve"] = q.Resolve,
}.Where(p => !string.IsNullOrEmpty(p.Value)));
var page = await GetJsonAsync<ListPage<TProps>>(url);
result.Objs.AddRange(page.Objs);
result.Refs.AddRange(page.Refs ?? []);
if (!page.More || q.Take is not null) return result;
}
}
Der Renderer der Inhalte ist als C#-Komponente geschrieben (BuildRenderTree) und nicht als Razor-Markup. Der Grund steht im Code: Das CMS nennt das Element jeder Komponente, und Markup kann kein Element schreiben, dessen Name eine Variable ist. Bilder skaliert die Demo mit SkiaSharp.
Razor Pages + htmx 4: das Gegenmodell
Die dritte Demo ist das Gegenstück zu React: ASP.NET Core 10 mit Razor Pages (nur .cshtml, kein Blazor) und htmx 4 statt site.js. Der Browser lädt nur htmx und ein kleines Skript für den Shopify-Button. Die Live-Auswahl ist dasselbe POST-Formular wie ohne JavaScript; mit htmx geht es im Hintergrund an dieselbe Adresse, und aus der Antwort wird nur #range genommen und in die Seite gemorpht, sodass Karten, Fokus und Scrollposition stehen bleiben:
<section id="range" hx-select:inherited="#range" hx-target:inherited="#range" hx-swap:inherited="outerMorph"
hx-on::before:request="this.ariaBusy = true"
hx-on::before:swap="this.scrolled = scrollY">
<form id="facets" hx-post="@action" hx-trigger="submit, change[target.type !== 'number'] from:#range">
…
</form>
</section>
Selbst die Suchvorschläge kommen hier als fertiges HTML vom Server. Für Teams, die Server-HTML lieben und JavaScript misstrauen, ist sie die interessanteste Demo.
Nuxt 4 + Vue 3: Nitro-Routen und Komponenten
Die Nuxt-Demo rendert auf dem Server und hydriert dann. Die Live-Auswahl und die Suchvorschläge sind Vue-Komponenten, der Shopify-Button ein Client-Plugin, und die Nitro-Serverrouten lesen die Delivery API. Ein vollständiger Endpunkt, die Suchvorschläge, sind 20 Zeilen Code:
export default defineEventHandler(async (event): Promise<Suggestions> => {
const form = await readForm(event);
const region = form.get("lang");
if (!isRegion(region)) throw createError({ statusCode: 404 });
const q = (form.get("q") ?? "").trim();
const productFilter = q.length >= 2 ? searchFilter(q, PRODUCT_SEARCH_FIELDS) : undefined;
if (!productFilter) return { products: [], pages: [] };
const [products, pages] = await Promise.all([loadProducts(region, productFilter, "$score", 5), searchPages(region, q, 3)]);
return {
products: products.map((p) => ({ name: p.name, url: p.url, image: p.image ? smallSrc(p.image) : null, price: formatPrice(p.price, region) })),
pages: pages.map((p) => ({ title: p.title, url: p.url })),
};
});
Nuxt ist die Demo für Teams, die ganz in Vue zu Hause sind: Nach dem ersten Laden ist die Seite eine vollständige Vue-Anwendung. Wie viel JavaScript im Browser landet, entscheidet dabei das Frontend und nicht NovaDB; dieselben Daten tragen ebenso gut eine Seite fast ohne JavaScript.
Astro 7: vorgebaut, in drei Teilen
Die Astro-Demo ist die erste mit einem eigenen Ansatz: Sie baut alle Seiten vorab aus der Delivery API zu HTML.
Welche Seiten es gibt, fragt sie beim Bauen NovaDB: getStaticPaths liest je Region den Seitenbaum und alle Produkte aus der Delivery API und nennt Astro jede Adresse; daraus wird je eine HTML-Datei. Der Kern der Route src/pages/[region]/[...path].astro:
export const getStaticPaths = (async () => {
const perRegion = await Promise.all(REGIONS.map(async (region) => {
const [site, products] = await Promise.all([loadSite(region), loadProducts(region, MARKET[region])]);
const paths = [...site.byPath.keys(), ...products.map((p) => p.path)];
return paths.map((path) => ({ params: { region, path: path || undefined } })); // the home page has no path
}));
return perRegion.flat();
}) satisfies GetStaticPaths;
const { region, path = "" } = Astro.params;
const data = (await loadPage(region as Region, path))!; // `getStaticPaths` lists only what exists
Eine neue Seite in NovaDB hat ihre Adresse deshalb nach dem nächsten Build. Wie das Bauen und Ausliefern läuft, zeigt der eigene Abschnitt gleich unten.
Was bringt Astro, wenn alle Demos schnell sind?
Schnell sind alle fünf Demos. Das liegt weniger am Framework als an der Delivery API: Eine Seite braucht einige Abfragen, die API beantwortet sie zügig, und die Demos halten die Antworten 60 Sekunden im Speicher. Auf einer Maschine gemessen liefert schon die Referenz-Demo eine Seite in weniger als zehn Millisekunden. Eine eigene Datenbank, einen Suchindex oder einen vorgeschalteten Cache braucht keine von ihnen.
Astro beantwortet deshalb eine andere Frage: Wo liegt die Website? Die Astro-Demo baut alle Seiten vorab aus der Delivery API zu HTML und erzeugt dabei jedes Bild, das die Seiten zeigen. Heraus kommen Dateien, nichts als Dateien. Und Dateien lassen sich dorthin legen, wo die Besucher sind.
Der Inhalt im Land der Kunden
- Nah am Besucher. Ein CDN wie Cloudflare oder ein vergleichbares Angebot verteilt statische Dateien auf Rechenzentren in vielen Ländern. Ein Besucher in München, London oder Chicago bekommt die Seite aus seiner Nähe, ohne dass irgendwo ein Server für ihn rendert.
- Günstig. Statische Auslieferung kostet wenig und wächst mit dem Verkehr, ohne dass jemand Server nachlegt. Eine Kampagne mit plötzlich zehnfachem Besuch wird zur Frage der Bandbreite und bleibt ein ruhiger Tag für den Betrieb.
- Kein Schlüssel am Rand. Der Zugang zur Delivery API bleibt beim Builder und bei der kleinen App für Filter und Suche. In die Rechenzentren des CDN gehen fertige Seiten und Bilder, keine Zugangsdaten.
Was eine Anfrage braucht, also abgeschickte Filter, die Suche und ihre Vorschläge, beantwortet weiter eine kleine Node-App. Sie kann zentral laufen oder ihrerseits als Funktion am Rand des Netzes. Für ein CDN ändert sich, wohin der Builder veröffentlicht, und eine Regel schickt POST-Anfragen an die App. Die Seiten selbst bleiben, wie sie sind.
Eine Produktseite der Astro-Demo: fertiges HTML, als Datei ausgeliefert. So läuft die Demo heute
Unsere Demo liefert ihre Dateien selbst aus. Der Aufbau hat drei Teile, die getrennt laufen und getrennt skalieren (drei Deployments, oder alles zusammen mit compose.yaml):
- Caddy nimmt jede Anfrage an und liefert Seiten und Bilder als Dateien aus seinem eigenen Ordner, in beliebig vielen Replikaten. Genau diese Rolle übernimmt beim Kunden das CDN.
- Eine kleine Node-App beantwortet abgeschickte Filter und Suchen und das JSON der Suchvorschläge. Nie eine Seite, nie ein Bild.
- Ein Builder (genau einer) baut neu, wenn sich der Branch ändert, erzeugt die Bilder und veröffentlicht beides.
Woher weiß der Builder, dass sich etwas geändert hat? Er fragt branches/{branch}/updateInfo mit einem ETag und bekommt 304, solange alles beim Alten ist. Die ganze Erkennung ist diese Funktion:
let etag;
async function changeVersion() {
const res = await fetch(new URL(`branches/${DEMO_BRANCH}/updateInfo`, NOVA_DELIVERY_URL), {
headers: { Authorization: authorization, Accept: "application/json", ...(etag && { "If-None-Match": etag }) },
}).catch((error) => console.warn("updateInfo unreachable:", error.cause?.code ?? error.message));
if (!res || res.status === 304) return undefined;
if (!res.ok) return void console.warn(`updateInfo answered ${res.status}`);
etag = res.headers.get("ETag") ?? undefined;
return (await res.json()).changeTrackingVersion;
}
Ändert eine Redakteurin eine Seite, erkennt der Builder es nach höchstens 30 Sekunden, wartet weitere 30 Sekunden, ob noch mehr kommt, baut in etwa sieben Sekunden und tauscht die fertige Fassung in einem Schritt aus, ohne dass ein Besucher es bemerkt. Eine Änderung steht so nach rund einer Minute auf der Website, für einen Katalog, eine Kampagne oder eine Marke mit Kunden in vielen Ländern genau der richtige Takt.
Eine Beobachtung aus der Entwicklung, die wir weitergeben möchten: Astro im Standalone-Modus ignoriert ein POST an einen vorab gerenderten Pfad. Ein Formular, das an dieselbe Adresse zurückschickt, verträgt sich deshalb nicht von selbst mit vorgebauten Seiten. Die Demo löst es mit einer Regel, die POST an die App verschiebt (post.mjs, drei Zeilen Code), statt das Formular zu verbiegen.
Was Sie mitnehmen
Agenturen
- Eine Website ist schnell aufgesetzt: Die Delivery API lässt sich mit einem einfachen HTTP-Client lesen.
- Der Stack ist Ihre Wahl. Bringen Sie mit, was Ihr Team beherrscht.
- Ein fester Satz an Bausteinen trennt Gestaltung von Redaktion: Sie stylen die Formen, die Redaktion baut damit Seiten. Welche Bausteine ein Projekt hat, legen Sie selbst fest; ein neuer ist Konfiguration.
- Ein Agent arbeitet mit: Er liest das Modell über die CMS API, legt Typen und Attribute an und erweitert sie, und die Website folgt den Daten.
- Eine Demo als Ausgangspunkt, vom Lesen bis zum Ändern.
Produktmanager
- Werte statt Freitext: eine Farbe, ein Material, eine Oberfläche, einmal gepflegt, in jeder Sprache.
- Preise je Markt, ohne dass ein Produkt dafür dreimal existiert.
- Vorschauen und Dashboards, die zeigen, was die Website zeigen wird und was noch fehlt.
- Neue Attribute werden konfiguriert und nicht programmiert.
Lead und Senior Developer
- Eine kleine, durchsichtige Schnittstelle: kein SDK, keine versteckte Schicht.
- Identifier statt IDs: derselbe Code läuft gegen jede Installation.
- Ein Renderer für beliebig viele Seiten, weil das CMS Element und Klasse liefert.
- Fünf Referenzen für Ihren Stack, dazu die Testsuite als Abnahmekriterium.
Wofür sind die Demos gedacht?
Die Demos sind Lehrmaterial und Ausgangspunkt, kein Produkt, das man installiert: Der Shop ist bewusst klein, Warenkorb und Checkout übernimmt in dieser Demo Shopify. Ihre Stärke zeigen sie, wenn Inhalte, Produktdaten und Medien zusammen gepflegt werden sollen, wenn mehrere Märkte und Sprachen ohne Wildwuchs zu bedienen sind und wenn die Website Teil einer größeren Architektur ist, die nicht von einem Hersteller vorgegeben wird.
Eine Produktseite bei 390 Pixel Breite. Was kann NovaDB über CMS, PIM und DAM hinaus?
Der Shop zeigt drei Rollen eines Systems, aber NovaDB ist eine Plattform, auf der Anwendungspakete laufen. Dieselbe Datenhaltung, dieselben Rechte, dieselbe Schnittstelle und derselbe Editor tragen weitere Aufgaben.
Wichtig für die Entscheidung: Das Wissen aus den Demos überträgt sich. Wer die Delivery API für den Shop liest, liest sie auch für ein Dokumentationsportal, und ein Entwickler, der einen Renderer für Visual Documents geschrieben hat, muss ihn für die nächste Anwendung nicht neu erfinden.
Das Redaktionssystem für Betriebsanleitungen und Servicedokumente, mit KI für Texte und Übersetzung.
Anleitungen und Service-Wissen sicher und mehrsprachig ausliefern, bereit für den Digitalen Produktpass.
Bilder, Videos, Dokumente und Designdateien an einer Stelle verwalten und über eine API ausliefern.
Shop, ERP, PIM, CMS und Kasse über APIs verbinden: im Großen, was die Demos im Kleinen vorführen.
Produktdaten zentral pflegen und an jeden Kanal liefern: die Rolle, die der Shop als PIM zeigt.
Inhalte für jede Website und jede App aus einem System: die Rolle, die der Shop als CMS zeigt.
Und wenn Ihr Thema keine Produkte kennt?
Gut. NovaDB kennt auch keine. „Produkt“, „Farbe“ und „Preis je Markt“ sind in diesem Shop konfiguriert, nicht eingebaut, und schon er verwaltet mehr als Produkte: Seiten, Bilder und die Texte der Oberfläche sind Objekte wie das T-Shirt. Die sechs Anwendungen oben sind fertige Pakete, keine Grenze.
Machen Sie die Probe und lesen Sie diesen Artikel als Messegesellschaft: Aus der Produktgruppe würde die Halle, aus dem Produkt der Stand, aus Farbe und Material würden Fläche und Lage, aus der Produktseite der Eintrag im Ausstellerkatalog. Client, Renderer und die Abfrage der Delivery API blieben, wie sie hier stehen. Dieselbe Probe können Sie mit den Hauptwörtern Ihres Themas oder Ihres Kunden machen: Kurs, Termin, Referent. Norm, Abschnitt, Fassung.
Zwei Projekte, die kein Shop sind: Bei TRUMPF liegen die Texte, die Werkzeugmaschinen auf ihren Bedienoberflächen zeigen, etwa Fehlermeldungen, in NovaDB und werden von dort übersetzt und veröffentlicht. Bei der NürnbergMesse pflegen Aussteller ihre Unternehmens- und Produktdaten in einem Self-Service selbst, ein Datenbestand für mehrere Messen und Marken; die erste Fassung mit den Kernfunktionen stand nach wenigen Wochen.
Die Grenze kennen Sie aus diesem Shop: Was bestellt, gebucht oder abgerechnet wird, gehört in das System dafür, so wie hier der Warenkorb zu Shopify. Was jemand pflegt, was aufeinander verweist und in mehreren Sprachen oder Kanälen erscheinen soll, dafür ist NovaDB gebaut, ob man es PIM nennt oder nicht.

Fazit: Weniger Schicht, mehr NovaDB
Fünf Stacks, ein Shop, ein Vertrag: Die Demos zeigen, dass NovaDB als CMS, PIM und DAM in einem System keine Vorgaben für das Frontend macht, aber alles liefert, was es braucht. Was bei jedem Stack gleich blieb, ist bezeichnend: ein kleiner Client mit etwa fünfzig Zeilen, ein Renderer ohne Kenntnis der Bausteine, Identifier an einer Stelle, Bilder über Inhaltsadressen. Was sich unterschied, war Geschmack: wann gerendert wird, wie viel JavaScript im Browser landet und wo der Server aufhört.
Wenn Sie als Agentur oder Entwicklungsteam wissen möchten, wie sich NovaDB in Ihrem Stack anfühlt, ist der kürzeste Weg: Öffnen Sie die Demo Ihres Stacks, lesen Sie den Client und den Renderer, und ändern Sie etwas. Wenn Sie als Produktmanager sehen wollen, wie Ihre Daten gepflegt würden, zeigen wir Ihnen das System live.
Alle drei, in einem System. Als CMS liefert NovaDB die Seiten, die die Redaktion im Editor aus Bausteinen zusammensetzt. Als PIM hält es die Produkte mit Werten wie Farbe und Material, Texten je Sprache und Preisen je Markt. Als DAM verwaltet es jedes Bild genau einmal.
Für die Website sind das keine drei Quellen: Seite, Produkt und Bild sind Objekte, die sie über dieselbe Delivery API liest. Deshalb steht im Shop eine Produktkarte mitten in einer redaktionellen Seite, ohne dass zwei Systeme abgeglichen werden. Weitere Aufgaben wie die technische Dokumentation laufen als Anwendungspakete auf derselben Plattform.
Jedes, das HTTP sprechen kann. Die Delivery API liefert JSON, und ob daraus auf dem Server, im Browser oder schon beim Bauen HTML wird, entscheiden Sie. Die Demos zeigen fünf Wege zum selben Ergebnis: React Router 8 und Nuxt 4 rendern auf dem Server und hydrieren, Blazor rendert statisch auf dem Server, Razor Pages mit htmx 4 kommt fast ohne JavaScript aus, und Astro 7 baut alle Seiten vorab.
Wie viel JavaScript im Browser landet, entscheidet dabei das Frontend und nicht NovaDB: In allen fünf Demos sind Filter, Sortierung und Suche echte Formulare, die auch ohne JavaScript funktionieren.
Nein. Die Delivery API ist eine HTTP-Schnittstelle mit JSON, und ein einfacher HTTP-Client genügt: Die .NET-Demos benutzen einen
HttpClientmitSystem.Text.Json, die anderenfetch. Der Client der Referenz-Demo hat rund 50 Zeilen Code. Darin stecken die Anmeldung mit Basic-Auth, ein Zwischenspeicher von 60 Sekunden und das seitenweise Lesen.Für .NET gibt es mit
NovaDB.Contentein fertiges Paket. Die Demos verzichten bewusst darauf, damit Sie das Protokoll sehen: Wer die eine Funktion gelesen hat, die eine Liste von Objekten holt, kann die Schnittstelle in jeder Sprache nachbauen.Weniger, als die meisten erwarten. Jede der fünf Demos ist ein vollständiger Shop mit drei Regionen, Filtern und Suche und kommt mit rund 1.500 Zeilen Code aus, gezählt ohne Kommentare, Tests und das gemeinsame Stylesheet. Der Teil, der mit NovaDB spricht, ist der kleinste: ein Client mit etwa 50 Zeilen und ein Renderer für die Seiteninhalte mit rund 20.
Die Technologie verändert den Aufwand kaum; den Umfang bestimmt, was die Website können soll. Das Datenmodell wird in NovaDB konfiguriert und nicht programmiert, und neue Seiten baut die Redaktion aus vorhandenen Bausteinen, ohne dass Code entsteht.
Nein. Die Delivery API bringt ihren eigenen Suchindex mit, und die Website fragt ihn direkt ab. Das Suchergebnis ist ein einziger Filter über Name, Artikelnummer und Beschreibung der Produkte, nach Relevanz sortiert; die Vorschläge unter dem Suchfeld sind dieselbe Abfrage mit kleineren Grenzen. Auch die Trefferzahlen je Facette liefert die API, passend zur aktuellen Suche. Die Demos zählen sie selbst, weil sie die Produkte einer Auswahl ohnehin vollständig laden.
Die Antworten der API halten die Demos lediglich 60 Sekunden im Arbeitsspeicher. Das genügt, weil die API zügig antwortet: Auf einer Maschine gemessen liefert die Referenz-Demo eine Seite in weniger als zehn Millisekunden. Es gibt also keinen zweiten Datenbestand, der mit NovaDB synchron gehalten werden müsste.
Nach etwa einer Minute und ohne Release. Die Demos, die auf dem Server rendern, halten Antworten der Delivery API 60 Sekunden im Speicher; danach zeigt die Website den neuen Text oder den neuen Preis. Die Astro-Demo baut ihre Seiten vorab: Sie erkennt eine Änderung nach höchstens 30 Sekunden, wartet weitere 30, baut in etwa sieben Sekunden und tauscht die fertige Fassung in einem Schritt aus.
Das gilt für alles, was Redaktion und Produktmanagement pflegen, auch für die Texte der Oberfläche. Ein Deployment braucht nur, was die Struktur verändert, etwa ein neues Attribut, das die Website anzeigen soll.
Als Varianten. Der Preis eines Produkts hängt von der Achse
merchMarketab, mit je einem Mitglied für den Euro-, den Pfund- und den Dollar-Markt. Das Produktmanagement gibt die drei Preise am selben Produkt ein; es gibt kein eigenes Produkt je Land. Die Website nennt mitvariants=genau ein Mitglied und wählt es nach der Region der URL.Ohne diese Angabe fehlt der Preis in der Antwort, und ein Filter oder eine Sortierung nach ihm endet mit einem Fehler 400. Das ist gewollt: Ein Preis aus dem falschen Markt kann gar nicht erst auf die Seite gelangen.
Die Website lässt die Stelle aus. Ein sprachabhängiges Attribut liefert genau den Wert, der für die angefragte Sprache eingegeben wurde; fehlt er, fehlt der Schlüssel in der Antwort. Die Demos fallen weder auf eine andere Sprache zurück noch auf den Anzeigenamen des Objekts, der ein Etikett für die Redaktion ist und keine Übersetzung.
Das erspart die unangenehmste Art von Fehler: einen deutschen Satz auf der englischen Seite, den niemand bemerkt. Eine Lücke bleibt sichtbar, und ein Dashboard in NovaDB kann sie zählen und zeigen, was noch zu übersetzen ist.
Ja, in zwei Stufen. Die Bilder aller Demos tragen Namen, die ihren Inhalt nie ändern. Jede Antwort ist deshalb als unveränderlich markiert (
immutable, ein Jahr) und lässt sich von jedem CDN dauerhaft zwischenspeichern, ohne dass je ein veraltetes Bild ausgeliefert wird.Die Astro-Demo geht weiter: Sie baut alle Seiten vorab zu Dateien, die sich mit Cloudflare oder einem vergleichbaren Angebot nahe bei Ihren Kunden verteilen lassen. Nur abgeschickte Filter und die Suche beantwortet eine kleine Node-App. Der Zugang zur Delivery API bleibt beim Builder und bei dieser App; an den Rand des Netzes gehen nur fertige Seiten und Bilder.
Ja. Sie dürfen den Code jeder Demo übernehmen, verändern und in Kundenprojekten einsetzen. Die Repositories heißen
merch-react-router,merch-blazor-dotnet,merch-razor-htmx,merch-vue-nuxtundmerch-astround liegen unter github.com/novadb.Jedes Repository steht für sich, mit eigenem README, eigenen Abhängigkeiten und einem
Dockerfile; die DateiNOVADB.mdbeschreibt, wie die Website NovaDB liest. Ersetzen Sie das Datenmodell des Shops durch Ihr eigenes, und nehmen Sie die rund 45 Playwright-Tests, die gegen jede Demo laufen, als Abnahmekriterium mit.Sprechen Sie uns an, über den Kontakt oder mit einer Demo-Anfrage. Technisch braucht eine Demo nur drei Angaben: Adresse, Benutzer und Passwort der Delivery API Ihrer NovaDB-Instanz. Sie stehen als Umgebungsvariablen bereit, lokal ebenso wie im Container.
Der Zugang ist ein Geheimnis des Servers. Der Browser bekommt ihn nie zu sehen; auch deshalb laufen die Bilder über die Website und nicht direkt von NovaDB. Die Schnittstelle selbst ist in der API-Dokumentation beschrieben, und das README jeder Demo erklärt den Start.
Ja, und nicht nur lesend. Die Delivery API liefert die veröffentlichten Inhalte, die CMS API Inhalte und Konfiguration: Ein Agent kann Typen, Attribute, Formulare und Bausteine lesen, anlegen und ändern. Die Rechte für Lesen, Schreiben und Konfiguration sind getrennt, Änderungen entstehen in Branches.

Michael Stegmann
Managing Partner bei Noxum mit mehr als 30 Jahren Berufserfahrung in der Softwareentwicklung und Webentwicklung. Als Spezialist für KI und KI-Entwicklung leitet er Strategie und Konzeption, entwickelt innovative Softwarelösungen und treibt die technologische Weiterentwicklung des Unternehmens voran.



















