Skip to content

From an empty organization to a client’s site, and then to your own code

The ebitex team
Ready-made page sections sliding into a client’s web page, and an arrow carrying the finished page out of a bracket labelled yours.

The slowest part of a content-managed site is rarely the code. It is the modelling: deciding what a hero is, what a section is, what a theme is, and getting an editor to a state where a client can change a sentence. Starting from an empty organization, that is a day or two before anything is on screen.

The ebitex starter kit skips it. It installs a working set of Contracts, Templates, categories and a demo page into your organization in one step, and a React renderer draws them. The guide for it budgets under half an hour from nothing to a rendered page. After that, everything is yours: edit it, rename it, delete the parts you do not want, and, when you are ready, remove the dependency on the renderer altogether.

From an empty organization to a deployed client site with the starter kit, in under two minutes.

What you are installing

The kit is a head start, not a theme. In your organization it adds an experience Contract (the base of a page, with a theme, an inline hero and a list of sections), ten section Contracts (hero, rich text, media, card, feature, banner, call to action, tabs, accordion and grid), an action Contract for buttons and links, a Template for each, and nine groups of categories for theme, appearance, layout, width, background, aspect ratio, emphasis, tone and action style. Optionally it adds a finished demo home page built only from those parts.

One design choice matters for everything that follows. A section never stores how it looks. A page’s hero and sections are presentations: a Template, that Template’s settings, and a Component that holds only the words and media. Layout, width, background, appearance and tone are chosen in the settings, where a section is placed, so one Component can appear in several places in different ways. And they are categories, so the choices are editable in Content without touching code.

Step 1: install it

In Content, open Tools → Starter kits. A new organization’s empty Components list also offers Start from a starter kit, which goes to the same page.

The kit’s media fields choose from your Assets library, so Assets has to be connected to Content first. If it is not, the page offers Connect Assets, which turns the plugin on, creates a channel and a key for Content, and registers them in one confirmed step. You do not handle the key.

Then read the preview. It says what installing will add, by kind, how many items you already have (which are kept exactly as they are), and which environment it will go into. Leave Include the demo experience on, and select Install the kit. It runs as a background job. If it stops, nothing you already had has changed, and running it again only adds what is missing, so it is safe at any point.

Step 2: publish the demo and make a key

Open Composer, find the site named ebitex demo, and publish its root. The demo’s Components publish with it, because publishing is what makes content visible to a delivery key.

Then create a browser-safe delivery key restricted to the origin you will run the site on, such as http://localhost:5190 while you try it. A site’s JavaScript is public, so a key that works only from the origins you list is the one that is safe to ship.

Step 3: run the renderer

The renderer is published as @ebitex/starter-kit-react, and the public samples repository has a complete site built on it that reads your organization through @ebitex/content-sdk and draws every section with Tailwind.

git clone https://github.com/ebitex-io/samples.git
cd samples/samples/starter-kit
cp .env.example .env
# set VITE_CONTENT_DELIVERY_KEY in .env to your browser-safe key
npm install
npm run dev

Open http://localhost:5190 and the demo home page is there: a hero, a banner, an introduction, three features, three cards, tabs, an accordion and a call to action, with a switch in the corner for the reader’s light, dark or system colours. If it says the content could not be loaded, check that the key’s allowed origins include that address and that you published the site root.

One thing the demo does not have is a picture, because an image belongs to one organization. Its media section shows a labelled placeholder until you upload an image in Assets, make it public, and choose it in the Demo: picture Component.

Make it the client’s, without code

This is the part a client sees, and none of it needs a deploy.

  • Change the words. Prose, headings and buttons are ordinary Component fields. Edit them, or delete the demo’s Components and write your own.
  • Choose a theme. Open the page’s Template settings and set the theme to default, dark or brand. A theme is chosen once for the whole experience, and an empty one means the default.
  • Give one section a different look. In the section’s Template settings, set its appearance: muted, inverted, brand or highlight. Leave it on Inherit to take the parent’s, so what is nested inside follows it.
  • Edit the choices themselves. Layout, width, tone and the rest are categories. Rename them or add your own under Categories.

Because the values are categories, a non-developer can retune the look of a site without a pull request.

Then make it yours, with a little code

The renderer is built to be outgrown one piece at a time, so there is no cliff between "using the package" and "writing your own". To add it to a site you already have:

npm install @ebitex/content-sdk @ebitex/starter-kit-react react-markdown remark-gfm
@import "tailwindcss";
@import "@ebitex/starter-kit-react/styles.css";
@source "../node_modules/@ebitex/starter-kit-react/dist";

Then give the content provider the kit’s renderers. Replacing how one Template draws is one entry in the map, keyed by the Template’s external id:

import { createContentClient } from '@ebitex/content-sdk'
import { ContentProvider, Experience } from '@ebitex/content-sdk/react'
import { EbitexMarkdown, EbitexProvider, Frame, ebitexRenderers, type EbitexRendererProps } from '@ebitex/starter-kit-react/react'

const content = createContentClient({ apiKey: 'your-browser-safe-key' })

function MyCallToAction({ settings, component }: EbitexRendererProps) {
  return (
    <Frame settings={settings}>
      <aside>
        <h2>{String(component.content.heading)}</h2>
      </aside>
    </Frame>
  )
}

export function App({ pathname }: { pathname: string }) {
  return (
    <EbitexProvider>
      <ContentProvider client={content} renderers={{ ...ebitexRenderers(), 'ebitex-cta-template': MyCallToAction }} markdown={EbitexMarkdown}>
        <Experience path={pathname} />
      </ContentProvider>
    </EbitexProvider>
  )
}

The component receives the Template’s settings (width, background, appearance and so on) and the Component’s content, and drawing inside Frame applies the settings. The same map draws a Template of your own: create a Contract that inherits the kit’s presentation base, a Template that supports it, and a renderer for the Template, then add the Template to the experience’s Sections. A Template with no renderer shows the content provider’s fallback, so a new Template never breaks a page.

The rest of the surface is just as small. link replaces how links navigate, so you can pass your router’s link component. Colours are --ebitex-* tokens you redefine after the import. A category you add draws as the default until you teach the renderer what it means, because the delivery API sends a category’s key and path but never its colours: the renderer owns the mapping, and a different renderer can map the same names to something else.

Eject when you want to stop depending on it

Sooner or later a client’s design stops resembling the kit’s. That is the point at which you copy it into your project:

npx starter-kit-eject src/kit

It copies the components, the token stylesheet and the category helpers into src/kit, and never overwrites a file that already exists. It also writes a note saying the code is now yours. You then import from the copies instead of the package, import the copied styles.css after Tailwind, and remove the dependency. From there it is an ordinary React codebase: nothing updates it.

The same is true of the content. Nothing links an installed item back to the kit, and a newer kit never changes what you have. Installing again only adds what is missing, so you can pick up new parts later without losing your changes.

What to know before you start

  • The page renders in the browser. The delivered HTML is a shell and the content arrives a moment later. If search ranking is the point of the site, use the server-rendered setup, which uses the same content.
  • Assets must be connected before the kit installs. The page does it for you in one step.
  • It needs the right permissions. Installing manages Contracts, Templates and the organization’s categories; the install page tells you which you lack before you start, and an Owner has all of them.
  • There is no update path, by design. That is what makes it yours.

If you build for clients

The kit is most useful repeated. Each ebitex organization installs its own copy, so a client’s changes never reach another’s, and the renderer you adapt once, with your design system’s tokens, is the part that carries from client to client. The partner program is built around that: a free sandbox per client, the starter kit as the first hour of the project, and a hand-over to the client when they are ready.

The full guide, with a troubleshooting table, is in the developer docs. The renderer’s reference is here.

This site runs on ebitex Content. This post was written as a Component, given an address on the Experience tree, and published through the same Delivery API any customer’s key reaches.