One Shop, Five Stacks: How NovaDB as CMS, PIM and DAM Fits Into Any Architecture
NovaDB doesn’t replace your frontend, it feeds it. Editors, product management and media management work in one system; your website reads the result through an HTTP interface, the Delivery API, and is otherwise completely free in its choice of language, framework and hosting. Many headless systems claim that. So we didn’t just claim it, we built it: a complete online shop, Nova Merchandising, and we built that shop in five different technologies, all of which read the same data live from NovaDB and are indistinguishable to visitors.
This article shows what came out of it. It is aimed at three groups. Agencies see how quickly a website is up and running on NovaDB and how little code it takes. Product managers see how products, values and prices per market are maintained without needing a developer. Lead and senior developers see the path from URL to HTML in React Router, Blazor, Razor with htmx, Nuxt and Astro, each with the code that talks to NovaDB and with the places where the stacks differ.
All five demos run publicly, and the source of each is its own repository, written so that you can read it, understand it and change it for your own project. No SDK, no hidden layer: anyone who talks to the Delivery API with a plain HTTP client sees in every demo exactly what goes over the wire.
Nova Merchandising, the home page in German. Every price, every photo and every word is a record in NovaDB. Where Do I Find the Shop and the Code?
The shop runs at www.merch.novadb.com. That is the reference demo (React Router) at the central address. The start address picks the region according to your browser’s language: Germany with euros, the UK with pounds, the US with dollars. Checkout runs in test mode; nothing is sold.
Each of the five stacks is also available at its own address and with its own source code. Both are linked for every stack in the section What Do the Five Demos Look Like in Detail?; you can find all repositories together at github.com/novadb.
The Shop and the Idea
What Is Nova Merchandising?
Nova Merchandising sells merchandise for people who build, test and ship: T-shirts, mugs, hoodies, insulated flasks, stickers and laptop sleeves with slogans such as “Content is Data” or “API-First Developer”. The shop is deliberately small, but complete. It has everything a real website needs, and that is exactly the point: a demo with two pages and a product list proves nothing.
- Three regions. The first URL segment decides language, texts, currency and prices:
/de/shows German and euros,/uk/English and pounds,/us/English and dollars. No cookie, no market switch, no hidden state management. - Page tree and collections. Home page, shop with six category pages, three collections, “About”, “Behind this shop” and imprint. Editors create pages and arrange them in NovaDB; the website follows the data.
- A product range with filters. Group, color, material, availability and price, sorting, search with suggestions, “Show more” in steps of twelve.
- Buying through the existing shop system. The product carries a single ID, the one from the shop system. In this demo that is Shopify: its Buy Button brings cart and checkout with it, and checkout runs in test mode. With a different shop system, the product carries that system’s ID.
- Works without JavaScript. Filters, sorting, search and “Show more” are real forms. JavaScript makes them faster, but it isn’t what makes them possible in the first place.
A category with live filters. Why Do We Build the Same Shop Five Times?
Because “NovaDB fits every stack” is a sentence anyone can write. A head of development choosing a platform wants to know how it feels in their stack: how many lines it takes, how idiomatic the code is and what happens when they want to change something. A single demo answers that for one stack only. Five demos with the same behavior answer it for five, and incidentally show what is constant about the integration and what is down to the framework’s taste.
Each demo is measured against the same five goals, in this order:
- Easy to read. A short path from URL to HTML, no layer of our own in between. Fewer lines beat more.
- It’s about NovaDB. The code that talks to the Delivery API (client, names, mapping, rendering the content) is what a reader takes away: in the open, in one place per concern.
- Everything else small, but sound. Shop, images, SEO and deployment, each in the smallest form that is right in concept.
- Modern and idiomatic. Written the way an experienced developer of this stack writes today. A port translates behavior, not code.
- Complete. A real website that runs against the live API, passes the shared test suite, and looks and behaves just like the others.
“The contract defines what the website does. The goals decide how. Within the contract, readability beats any cleverness.”
Guiding principle of the demos, paraphrased
This contract is a document that describes, independently of any programming language, what the website does: routes, regions, breadcrumbs, search, media, SEO. Where a demo has to deviate because of its approach, the deviation is recorded in a list and in the demo’s README, together with the parts of the test suite that don’t apply to it. Nothing is silently left out.
Four statements came out of this work, and we can back them up with the demos:
- NovaDB fits every architecture. Server-rendered, hydrated, purely static and prebuilt, with Blazor or almost without JavaScript: the data always arrives the same way.
- NovaDB needs neither an SDK nor a framework. The .NET demos read with a plain
HttpClientandSystem.Text.Json, the others withfetch. - NovaDB works with what developers are talking about today. React Router 8, Nuxt 4, Astro 7, ASP.NET Core 10, htmx 4.
- A website on NovaDB is fast. All five demos read live from the Delivery API, and it answers so promptly that no demo needs a database or search index of its own.
Pages: NovaDB as CMS
Where Does the Work in NovaDB Begin?
“What an object has is configured, not programmed.”
The sentence that also appears on the shop’s own page
Every page, every product and every image of this shop is maintained in NovaDB, in one place. The shop’s “Behind this shop” page shows screenshots from the system; they are the basis of the images in this article. All screenshots from NovaDB are in English because the system’s interface was running in that language.
Everyone starts in the same Application Area, “Products & Pages”. It shows what the shop is made of: pages, products, product groups, colors, materials, finishes and images. Plus two ways to browse the data, the product portfolio and the page tree, and a dashboard. Which Application Areas exist and what is in them is freely configurable. A small shop like this one gets by with one; a larger company sets up one per team, brand or market.
Important for all three audiences: we created the “Product” type with color, material, finish, price per market and Shopify ID in NovaDB for this demo; no website code defines it. Another shop gets other types and other fields, a hoodie other ones than a mug. This is what the type looks like in NovaDB.
The “Products & Pages” Application Area in NovaDB. How Do Editors Build Pages?
From ready-made building blocks. Editors build every page from the same building blocks, the Visual Components: Hero, Split, Rail, Chapter, colored band and so on. The editor shows them the way visitors will see them, and a new section is added by dragging it onto the page. The page “Coffee & Code” in the picture consists only of such building blocks; no code was written specially for it.
For this shop we settled on 27 building blocks, each naming a shape and not a topic. A page is made from them, a building block is never made for a single page. That is a decision of the project, not a limit of NovaDB: building blocks such as Hero, Split or Chapter are needed by almost every website anyway, and all of them are configuration, like the rest of the model. A new building block is quickly created, one nobody needs just as quickly removed. The fixed selection pays off in collaboration: the developers style a manageable number of shapes, and editors build as many pages as they like with them, without having to ask.
So that the editor looks like the website, its stylesheet comes from the same CSS file as the page itself: a marked section of site.css is handed to the editor. What editors see is not an approximation, it is the same CSS.
The page editor with the palette of building blocks. For developers: one component tree, one renderer
The content of a page is a Visual Document: essentially a component tree like the ones you know from React or Vue, one per language. Every component in it has type, definition, element and class. The type determines the rest: a group contains further components, a text has XHTML as its content, image and object point with an objectId to an image, a product or another page. The CMS even names the element (section, div, h2) and the CSS class. A renderer therefore does not have to know the 27 building blocks. It writes <element class> and puts the content or the children into it. The entire renderer of the reference 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) }} />;
}
}
That is around twenty lines. An embedded product becomes a product card, an embedded page a teaser, and links in the text that point to an object in NovaDB are rewritten to addresses of the website. Nothing more happens. Whoever introduces a 28th building block tomorrow changes NovaDB and the stylesheet, but not a line in this renderer. Types, attributes and building blocks are themselves configuration in NovaDB; this is what the “Product” type looks like there.
Products and Markets: NovaDB as PIM
How Does Product Management Maintain Products?
With values instead of free text. In this shop, color, material and finish are not text fields but objects of their own, which the product data managers maintain once. A product refers to them. As a result, “black” has the same name in every product and, in every language, the name it should have there (Schwarz, Black), and a color also carries the hex value of its swatch. A new color needs no code and no CSS: it is created in NovaDB, and the website’s color filter shows it with the right swatch, in the reference demo after a minute at most.
The names of the product fields also come from NovaDB. The website prints “SKU” or “Color” under the name an editor sees in the system, namely the name of the attribute definition. Whoever wants to change a name changes it there and not in the code.
The portfolio shows the product groups as a tree and their products as tiles. Every product group on the website is a category page with a live range; a collection, by contrast, is a page into which editors insert product cards from any groups.
The product portfolio: groups as a tree, their products as tiles.
A product in NovaDB: on the left the form with similar products, SKU, color and prices per market, on the right the preview, as the shop shows it. One product, every market
Prices are entered per market, and which markets exist is also configurable. Technically, the price is a variant: the attribute depends on the variant axis merchMarket, with the members merchMarketEU, merchMarketUK and merchMarketUS. The URL’s region selects the member. Without variants=… the price is missing, and filtering or sorting by it is a 400 error, a property you learn early and then appreciate: a price from the wrong market can’t even get onto the page.
Search engines see the region too: every page and every product carries an absolute canonical address and hreflang links to all three regions (de, en-GB, en-US) and to the start address that picks a region (x-default). A filtered view names the page without the filter as canonical.
Missing translations stay missing
A decision that has spared us discussions with agencies: the website never falls back to another language. A language-dependent attribute returns the value that was entered for exactly this language, and nothing else; if the translation is missing, the key is missing in the result, and the website leaves the spot out. An object’s displayName is never empty because it falls back to a language that has a text. It is therefore a label and not a translation, and the demos never print it in place of a missing text. This makes gaps visible instead of hiding them, and the dashboard (below) can count them.
The UI texts are in NovaDB too
The texts of the interface (“Add to cart”, “Show more”, “Search for …”) are merchLabel objects with a language-neutral key and one text per language. All five demos read them from there instead of copying them. A changed text is a change in NovaDB and not a release. That an agency can leave these texts to its client is, in practice, often the moment when a headless project becomes real for the business department.
A Dashboard as an Example
A dashboard is freely configurable and can therefore answer what matters to a team: missing translations, products without an image, prices still to be reviewed. This one is a small example. It counts the products that can be bought, meaning those that are in stock and carry a Shopify ID, in total and per group.
It is a small template that lives in NovaDB itself, a Razor view for developers. A trap we fell into and want to spare you: an unset attribute reads as one entry with the value null, not as an empty list. The view therefore checks every entry before it counts.
The previews next to the forms are similarly flexible: every kind of object can have any number of previews of its own, and a change to a preview reaches everyone who maintains products immediately.
A dashboard as an example: which products can be bought on the website? The pie chart counts all of them, the bars each group, below them the sales channels. Images: NovaDB as DAM
Where Are the Images?
Once, in the media library. Every image lives exactly once in NovaDB, with preview, file and the pages that use it. Pages and products only point to it; an image is maintained in a single place. Which details an image carries, such as copyright or photographer, is freely configurable. Whoever replaces an image’s file changes it on every page that shows it.
For the website, an image is an object of a file type: the object is the file. The type releases two attributes to the Delivery API, the MD5 value and the file extension. Together they are a content address: files/{md5}{ext} always returns exactly the same bytes. Everything else follows from that.
The media library with its previews. Never an outdated image
A visitor’s browser never gets to see the old version of an image, and images still load fast. The shop offers every file under a name whose content never changes:
/media/{md5}/original{ext}: the proxy tofiles/{md5}{ext}. Each file is fetched from NovaDB once and kept on disk./media/{md5}/{width}{ext}.webp: the same file scaled to 400, 800, 1200 or 1600 pixels as WebP at quality 80, never enlarged, generated once and kept on disk.- All responses carry
Cache-Control: public, max-age=31536000, immutableand an ETag, and answer a conditional request with 304. - Every image in the HTML has a
srcsetwith all four widths and asizesthat fits its place in the layout.
That the images go through the website itself and not directly from NovaDB has a second reason: access to the Delivery API is a server-side secret, which the browser never gets to see.
An image’s record: preview, file type, file name and the page that uses it. For Developers: API, Search and Purchase
Through the Delivery API, an HTTP interface with JSON. You’ll find the complete description in the API documentation; here is what matters for the demos. A product, the way the website reads it:
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
}
The response is shortened here. Everything important is in this call, and every part of it is a deliberate decision in the website:
| Concept | What it is | What the website does with it |
|---|---|---|
| Branch | merchDemo | The unit of publication. The website commits to one and never mixes two. |
| Identifier | merchProduct, merchProductSku | Numeric IDs of branches, types and attributes differ per installation, API identifiers do not. The code speaks only identifiers and keeps them all in one file. They are configuration in NovaDB, visible here on the “Product” type. |
lang | de-DE, en-US | One language per request. The value of that language, nothing else. |
variants | merchMarketEU … | Selects the market. Without it there is no price. |
resolve | merchProductImages | Returns the product’s images in refs of the same response, without a second request. |
filter, sort | Lucene syntax with :, $score | Full-text search. Visitors’ input is cleaned into prefix terms (+term*), never passed through unchanged. |
skip, take, more | at most 1000 per page | The website reads a type page by page until more is false. |
props | 0 or 1 | 0 returns the type’s released attributes, 1 all named ones; needed for NovaDB’s own types, such as the attribute names. |
How the shop searches
The website’s search is a single filter:
(merchProductName: +kaff* || merchProductSku: +kaff* || merchProductDescription: +kaff*) sort=$score
Products are found by name, SKU and description and sorted by relevance; up to five pages, found by title and content, are added. The suggestions under the search field are the same query with smaller limits: at most five products and three pages, and nothing below two characters.
Why there is no SDK
Because the interface is small enough that an SDK hides more than it helps. The entire client of the reference demo is around 50 lines of code: Basic auth from the environment, a 60-second cache, reading page by page. The core is this function:
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;
}
Whoever reads it has understood the interface. And because it is so small, it looks almost the same in every language, as the demos further down show.
How Does the Purchase Get to the Shop System?
With a single ID, and not only with Shopify. NovaDB is not tied to any shop system: whoever runs a shop has a shop system, and the website only has to hand a product over to it. The ID under which the shop system knows the product is enough for that.
In this demo it is Shopify. A product in NovaDB carries the attribute merchProductShopifyId; the product page passes it on to Shopify’s Buy Button (data-shopify-product), which brings its own cart and its own checkout. We rebuild neither the cart nor the checkout flow. That is the smallest form that is right in concept.
Shopify knows the same products, with German and English titles and fixed price lists for pounds and dollars alongside the euro prices, and publishes them only in the Buy Button channel. NovaDB remembers the Shopify ID for each product. The prices visitors see still come from NovaDB, namely from the region’s market; Shopify only handles the billing. That Shopify knows the same titles and prices is taken care of by a job in NovaDB and not by editors by hand.
The floating cart at the edge of the page is Shopify’s, in the region’s language. The demo shop’s checkout runs in test mode: nothing is sold here.
With a different shop system or a checkout of your own, only the ID on the product and the button that reads it change. Data model, maintenance and website stay the same.
The home page at 390 pixels wide. Built With Agents
The shop’s data model is configured, not programmed: types, attributes, building blocks, previews and the dashboard are settings in NovaDB. One rule has proved its worth because it prevents arguments: every API identifier carries a prefix (here merch), is unique across all branches and is not renamed once a website reads it. For the website, it is part of the contract.
From there, the paths diverge. The developers change the structure, deliberately and rarely. Editors change content in the editor, at any time and without a release: a text, a page, an image, a price.
How Does an Agency Build Its Website With Agents?
In NovaDB, not only the content is reachable through an interface but also the configuration. The Delivery API gives an AI agent the published data. The CMS API shows it the whole model: types, attributes, forms, building blocks, previews and dashboards. And it can not only read it but also create and extend it.
Elsewhere, AI writes texts into a finished system. With NovaDB, it can help build the system in which those texts are later maintained. For an agency that means: website, data model and editing interface come into being together with the agent, in the stack the team knows best. The demos in this article are the starting point, and the agent reads them like any developer.
Control stays with the human. Reading, writing content and changing the configuration are separate permissions, and changes are made in a branch before anyone adopts them.
The “Product” type in NovaDB: API identifiers and attributes are configuration, readable and changeable through the CMS API. Five Stacks. One Result.
What Do the Five Demos Look Like in Detail?
All five deliver the same pages with the same HTML and the same CSS classes, and all of them run live. Each demo is its own repository (merch-react-router, merch-blazor-dotnet and so on) with its own README, its own dependency management and its own Dockerfile. No code is shared between the demos, so that each stays readable on its own. Only files that have to be identical for all are shared: the stylesheet, the fonts, the logos and the script site.js, as far as a demo has no client components of its own.
Each stack has its own section below. The View live demo button opens the same shop, delivered by exactly this stack; to visitors it looks like www.merch.novadb.com. The Source code on GitHub link leads to the public repository with a README on how to start and the file NOVADB.md, which describes how the website reads NovaDB.
The demos differ in when they render and how much JavaScript ends up in the browser; the sections below show that. In effort they hardly differ: each of the five websites gets by with around 1,500 lines of code, counted without comments, tests and the shared stylesheet. Astro additionally brings the builder and the delivery via Caddy, which in the others is handled by the framework’s server. That surprised us most while building: when the path from the interface to the page is short, it is not the technology that determines the effort but the scope of the shop.
React Router 8: The Reference
The first demo defines HTML structure, CSS classes, UI text keys, routes and behavior, all of which the others adopt. It renders on the server, after which React takes over: navigation with <Link>, and the live range, the search suggestions and the Shopify button are components that send forms as fetchers to the routes’ actions. The Delivery client and the content renderer are the two excerpts further up. The identifiers are all in one file, 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;
Whoever starts reading a new attribute registers it there and nowhere else. The demo has no deviations from the contract.
ASP.NET Core 10 Blazor: Razor Components Without Interactivity
The Blazor demo uses only Razor components (.razor) and renders them exclusively on the server, as static SSR, without blazor.web.js and without a connection to the server after loading. The shared site.js takes care of interaction. For .NET teams it is the most familiar way in, and it shows that “Blazor” does not have to mean “WebSocket”.
The client is a plain HttpClient without the NovaDB.Content package, so that the reader sees the protocol. Worth noting: the cache keeps the task and not the result, so concurrent requests share a single query:
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;
}
}
The content renderer is written as a C# component (BuildRenderTree) and not as Razor markup. The reason is in the code: the CMS names the element of every component, and markup cannot write an element whose name is a variable. The demo scales images with SkiaSharp.
Razor Pages + htmx 4: The Counter-Design
The third demo is the counterpart to React: ASP.NET Core 10 with Razor Pages (only .cshtml, no Blazor) and htmx 4 instead of site.js. The browser loads only htmx and a small script for the Shopify button. The live range is the same POST form as without JavaScript; with htmx it goes to the same address in the background, and only #range is taken from the response and morphed into the page, so that cards, focus and scroll position stay in place:
<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>
Even the search suggestions arrive here as finished HTML from the server. For teams that love server HTML and distrust JavaScript, it is the most interesting demo.
Nuxt 4 + Vue 3: Nitro Routes and Components
The Nuxt demo renders on the server and then hydrates. The live range and the search suggestions are Vue components, the Shopify button is a client plugin, and the Nitro server routes read the Delivery API. A complete endpoint, the search suggestions, is 20 lines of 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 is the demo for teams that are completely at home in Vue: after the first load, the page is a full Vue application. How much JavaScript ends up in the browser is decided by the frontend and not by NovaDB; the same data just as well supports a page with almost no JavaScript.
Astro 7: Prebuilt, in Three Parts
The Astro demo is the first with an approach of its own: it builds all pages ahead of time into HTML from the Delivery API.
It asks NovaDB at build time which pages exist: getStaticPaths reads the page tree and all products from the Delivery API for each region and tells Astro every address; one HTML file is made from each. The core of the 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
A new page in NovaDB therefore has its address after the next build. How building and serving work is shown in the dedicated section right below.
What Does Astro Bring if All Demos Are Fast?
All five demos are fast. That has less to do with the framework than with the Delivery API: a page needs a few queries, the API answers them promptly, and the demos keep the responses in memory for 60 seconds. Measured on one machine, even the reference demo delivers a page in under ten milliseconds. None of them needs a database of its own, a search index or an upstream cache.
Astro therefore answers a different question: where does the website live? The Astro demo builds all pages ahead of time from the Delivery API into HTML and generates every image the pages show along the way. What comes out is files, nothing but files. And files can be put where the visitors are.
The content in the customers’ country
- Close to the visitor. A CDN such as Cloudflare or a comparable offering distributes static files across data centers in many countries. A visitor in Munich, London or Chicago gets the page from nearby, without a server rendering anything for them anywhere.
- Inexpensive. Static delivery costs little and grows with traffic without anyone adding servers. A campaign with suddenly ten times the visits becomes a question of bandwidth and remains a quiet day for operations.
- No key at the edge. Access to the Delivery API stays with the builder and with the small app for filters and search. What goes into the CDN’s data centers is finished pages and images, no credentials.
What a request needs, meaning submitted filters, the search and its suggestions, is still answered by a small Node app. It can run centrally or itself as a function at the edge of the network. For a CDN, what changes is where the builder publishes, and one rule sends POST requests to the app. The pages themselves stay as they are.
A product page of the Astro demo: finished HTML, delivered as a file. How the demo runs today
Our demo serves its files itself. The setup has three parts that run separately and scale separately (three Deployments, or everything together with compose.yaml):
- Caddy accepts every request and serves pages and images as files from its own folder, in as many replicas as you like. In a customer’s setup, the CDN takes on exactly this role.
- A small Node app answers submitted filters and searches and the JSON of the search suggestions. Never a page, never an image.
- A builder (exactly one) rebuilds when the branch changes, generates the images and publishes both.
How does the builder know that something has changed? It asks branches/{branch}/updateInfo with an ETag and gets 304 as long as everything is as it was. The whole detection is this function:
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;
}
When an editor changes a page, the builder notices at most 30 seconds later, waits another 30 seconds to see whether more is coming, builds in about seven seconds and swaps in the finished version in one step, without any visitor noticing. A change is thus on the website after about a minute: exactly the right pace for a catalog, a campaign or a brand with customers in many countries.
An observation from development that we would like to pass on: Astro in standalone mode ignores a POST to a prerendered path. A form that posts back to the same address therefore does not get along with prebuilt pages by itself. The demo solves it with a rule that moves POST to the app (post.mjs, three lines of code) instead of bending the form.
What You Take Away
Agencies
- A website is quickly set up: the Delivery API can be read with a simple HTTP client.
- The stack is your choice. Bring what your team knows best.
- A fixed set of building blocks separates design from editing: you style the shapes, and editors build pages with them. Which building blocks a project has is up to you; a new one is configuration.
- An agent joins in: it reads the model through the CMS API, creates and extends types and attributes, and the website follows the data.
- A demo as a starting point, from reading to changing.
Product managers
- Values instead of free text: one color, one material, one finish, maintained once, in every language.
- Prices per market, without a product having to exist three times for that.
- Previews and dashboards that show what the website will show and what is still missing.
- New attributes are configured, not programmed.
Lead and senior developers
- A small, transparent interface: no SDK, no hidden layer.
- Identifiers instead of IDs: the same code runs against every installation.
- One renderer for any number of pages, because the CMS supplies element and class.
- Five references for your stack, plus the test suite as an acceptance criterion.
What are the demos for?
The demos are teaching material and a starting point, not a product you install: the shop is deliberately small, and in this demo Shopify takes care of cart and checkout. They show their strength when content, product data and media are to be maintained together, when several markets and languages have to be served without sprawl, and when the website is part of a larger architecture that isn’t dictated by a single vendor.
A product page at 390 pixels wide. What Can NovaDB Do Beyond CMS, PIM and DAM?
The shop shows three roles of one system, but NovaDB is a platform on which application packages run. The same data storage, the same permissions, the same interface and the same editor carry further tasks.
Important for the decision: the knowledge from the demos carries over. Whoever reads the Delivery API for the shop reads it for a documentation portal too, and a developer who has written a renderer for Visual Documents does not have to reinvent it for the next application.
The authoring system for operating manuals and service documents, with AI for text and translation.
Deliver manuals and service knowledge securely and in multiple languages, ready for the Digital Product Passport.
Manage images, videos, documents and design files in one place and deliver them through an API.
Connect shop, ERP, PIM, CMS and point of sale through APIs: on a large scale what the demos show on a small one.
Maintain product data centrally and deliver it to every channel: the role the shop shows as a PIM.
Content for every website and every app from one system: the role the shop shows as a CMS.
And What If Your Topic Has No Products?
Good. Neither does NovaDB. “Product”, “color” and “price per market” are configured in this shop, not built in, and even this shop manages more than products: pages, images and the UI texts are objects like the T-shirt. The six applications above are ready-made packages, not a limit.
Try the test and read this article as a trade fair organizer: the product group would become the hall, the product the booth, color and material would become area and location, the product page the entry in the exhibitor directory. Client, renderer and the Delivery API query would stay as they stand here. You can run the same test with the key nouns of your topic or your customer: course, session, speaker. Standard, section, version.
Two projects that are not a shop: at TRUMPF, the texts that machine tools show on their user interfaces, such as error messages, live in NovaDB and are translated and published from there. At NürnbergMesse, exhibitors maintain their company and product data themselves in a self-service, one data set for several trade fairs and brands; the first version with the core functions was up after a few weeks.
You know the limit from this shop: what is ordered, booked or invoiced belongs in the system built for it, just as the cart belongs to Shopify here. Things that someone maintains, that refer to each other and are meant to appear in several languages or channels: that is what NovaDB is built for, whether you call it PIM or not.

Conclusion: Less Layer, More NovaDB
Five stacks, one shop, one contract: the demos show that NovaDB as CMS, PIM and DAM in one system makes no demands on the frontend but delivers everything it needs. What stayed the same in every stack is telling: a small client of about fifty lines, a renderer that knows nothing about the building blocks, identifiers in one place, images via content addresses. What differed was taste: when rendering happens, how much JavaScript ends up in the browser and where the server stops.
If you, as an agency or development team, want to know how NovaDB feels in your stack, the shortest way is this: open the demo of your stack, read the client and the renderer, and change something. If you, as a product manager, want to see how your data would be maintained, we will show you the system live.
All three, in one system. As a CMS, NovaDB delivers the pages that editors assemble from building blocks in the editor. As a PIM, it holds the products with values such as color and material, texts per language and prices per market. As a DAM, it manages every image exactly once.
For the website, these are not three sources: page, product and image are objects that it reads through the same Delivery API. That is why in the shop a product card can sit in the middle of an editorial page without two systems having to be reconciled. Further tasks such as technical documentation run as application packages on the same platform.
Any that can speak HTTP. The Delivery API returns JSON, and whether it becomes HTML on the server, in the browser or already at build time is up to you. The demos show five paths to the same result: React Router 8 and Nuxt 4 render on the server and hydrate, Blazor renders statically on the server, Razor Pages with htmx 4 gets by with almost no JavaScript, and Astro 7 builds all pages ahead of time.
How much JavaScript ends up in the browser is decided by the frontend and not by NovaDB: in all five demos, filters, sorting and search are real forms that also work without JavaScript.
No. The Delivery API is an HTTP interface with JSON, and a simple HTTP client is enough: the .NET demos use an
HttpClientwithSystem.Text.Json, the others usefetch. The reference demo’s client has around 50 lines of code. It contains authentication with Basic auth, a 60-second cache and reading page by page.For .NET there is a ready-made package,
NovaDB.Content. The demos deliberately do without it so that you see the protocol: whoever has read the one function that fetches a list of objects can rebuild the interface in any language.Less than most people expect. Each of the five demos is a complete shop with three regions, filters and search and gets by with around 1,500 lines of code, counted without comments, tests and the shared stylesheet. The part that talks to NovaDB is the smallest: a client with about 50 lines and a renderer for the page content with around 20.
Technology barely changes the effort; the scope is determined by what the website is supposed to do. The data model is configured in NovaDB and not programmed, and editors build new pages from existing building blocks without any code being created.
No. The Delivery API brings its own search index, and the website queries it directly. The search result is a single filter over the products’ name, SKU and description, sorted by relevance; the suggestions under the search field are the same query with smaller limits. The API also returns the hit counts per facet, matching the current search. The demos count them themselves because they load the products of a selection in full anyway.
The demos keep the API’s responses in memory for only 60 seconds. That is enough because the API answers promptly: measured on one machine, the reference demo delivers a page in under ten milliseconds. So there is no second data set that would have to be kept in sync with NovaDB.
After about a minute and without a release. The demos that render on the server keep responses of the Delivery API in memory for 60 seconds; after that the website shows the new text or the new price. The Astro demo builds its pages ahead of time: it detects a change after 30 seconds at most, waits another 30, builds in about seven seconds and swaps in the finished version in one step.
This applies to everything that editors and product management maintain, including the UI texts. Only what changes the structure needs a deployment, such as a new attribute that the website is to display.
As variants. A product’s price depends on the axis
merchMarket, with one member each for the euro, pound and dollar markets. Product management enters the three prices on the same product; there is no separate product per country. Withvariants=, the website names exactly one member and chooses it according to the URL’s region.Without this parameter, the price is missing in the response, and a filter or a sort by it ends in a 400 error. That is intended: a price from the wrong market can’t even get onto the page.
The website leaves the spot out. A language-dependent attribute returns exactly the value that was entered for the requested language; if it is missing, the key is missing in the response. The demos neither fall back to another language nor to the object’s display name, which is a label for editors and not a translation.
That spares you the most unpleasant kind of error: a German sentence on the English page that nobody notices. A gap stays visible, and a dashboard in NovaDB can count it and show what is still to be translated.
Yes, in two stages. The images of all demos carry names whose content never changes. Every response is therefore marked as immutable (
immutable, one year) and can be cached permanently by any CDN without a stale image ever being served.The Astro demo goes further: it builds all pages ahead of time into files that can be distributed close to your customers with Cloudflare or a comparable offering. Only submitted filters and the search are answered by a small Node app. Access to the Delivery API stays with the builder and with this app; only finished pages and images go to the edge of the network.
Yes. You may take the code of any demo, change it and use it in customer projects. The repositories are called
merch-react-router,merch-blazor-dotnet,merch-razor-htmx,merch-vue-nuxtandmerch-astroand are located at github.com/novadb.Each repository stands on its own, with its own README, its own dependencies and a
Dockerfile; the fileNOVADB.mddescribes how the website reads NovaDB. Replace the shop’s data model with your own, and take along, as your acceptance criterion, the roughly 45 Playwright tests that run against every demo.Talk to us, via the contact page or with a demo request. Technically, a demo needs only three pieces of information: address, user and password of the Delivery API of your NovaDB instance. They are provided as environment variables, locally as well as in the container.
The credentials are a server-side secret. The browser never gets to see them; that is also why the images go through the website and not directly from NovaDB. The interface itself is described in the API documentation, and each demo’s README explains how to start.
Yes, and not just for reading. The Delivery API provides the published content, the CMS API content and configuration: an agent can read, create and change types, attributes, forms and building blocks. The permissions for reading, writing and configuration are separate, and changes are made in branches.

Michael Stegmann
Managing Partner at Noxum with more than 30 years of professional experience in software development and web development. As a specialist in AI and AI development, he leads strategy and conceptual development, builds innovative software solutions and advances the company's technological evolution.



















