Skip to content

A one-page business website, built by an agent and run on Starter

The ebitex team
A browser window showing a small business’s one-page website, with a cloud above it for the host and a bright star beside it for the agent that built it.

Most small-business websites are one page. A name, a sentence about what the business does, a few services, a way to get in touch. The client wants to change the words themselves without phoning you, and does not want to pay for a platform built for a company a hundred times their size.

This guide builds exactly that, end to end. The domain and hosting are on Cloudflare. Claude Code builds the content in ebitex, through the ebitex MCP server, and then writes the Vite and React front end that renders it. After that the site runs on the $20 Starter plan, and your client edits a sentence, presses Publish, and the live page changes with no deploy and no message to you.

The shape of it

There are three pieces, and they are deliberately separate.

Cloudflare holds the domain and serves a folder of static files. That folder is built once and rarely changes. ebitex Content holds everything a client would want to edit: the words, and which sections appear in which order. The browser joins them. The site asks the Content Delivery API what is published at the current address and renders what comes back.

Because the text is not in the files you deploy, you deploy when the design changes. A client changing their opening hours is not a deploy.

The plan: build on the trial, run on Starter

An agent authoring your content through the MCP server is a Pro feature. Pro is $50 a month, and every new organization starts with a 14-day free trial of it, no card required. The trial counts as Pro for everything, including the MCP server. So the sequence is: build the site on the trial, then switch to Starter ($20 a month) before you pay for anything.

You create the organization, then hand it over. The trial is for the first organization you create, so creating it yourself is what gets you the 14 days and the MCP server. The customer ends up owning the account: Part 4 transfers ownership to them. That works because subscribing during the trial converts the organization and unlocks invitations, and billing does not start until the trial ends. There is one step you must not skip, which is the customer replacing your card with theirs before that date.

Programmatic authoring is the one exception to a rule worth knowing: no other Content capability is tied to a plan. Localization, personalization, workflow, Adapters and streams are on every plan, and what a plan buys is scale and environments. So nothing you learn here limits what the finished site can do on Starter.

That works because building is the part you need an agent for. Once the site exists, the client is editing words in the browser, which every plan can do. Here is exactly what happens, and what to watch.

  • The key stops working on Starter, by design. A management key is checked against the plan on every request, not only when it is created. Once the organization is on Starter, the agent can no longer write. That is the right ending for this job, and you should revoke the key anyway.
  • Nothing is deleted when you go down a plan. Everything you built keeps working. The only effect is that you cannot create more of something than Starter allows. Build inside the Starter limits from the start, so there is nothing to find out later: one site, ten pages, fifty Components, one authoring environment. A one-page site uses a sliver of that.
  • Subscribe bills the plan you have selected, and a trial has Pro selected. Do nothing and you are billed for Pro. Before you subscribe, open Organizations > Subscriptions & Billing and choose Switch trial to Starter. Do it when the build is finished, not before, because the switch is what turns the MCP server off. The trial countdown does not restart or shorten.
  • Handing over needs a subscription, and a subscription needs a card. Ownership is transferred by inviting the customer and promoting them to Owner, and invitations unlock only once the organization is subscribed. Subscribing during the trial does not charge yet, so it is safe, provided the customer swaps in their own card before the trial ends. Part 4 has the order.
  • The free trial is for the first organization you create. Any later organization starts without a trial and needs payment set up before it can be used. That is fine for one build. For your next customer, the realistic route is the month of Pro described at the end of Part 4.

If 14 days is too tight, or you would rather work as a member than hold a key, there is a second path at the end of Part 4: pay for a month of Pro, then step down.

Starter’s other limits matter for the finished site. It allows 6,000 Content Delivery requests a day, and 150 a minute. A visit typically costs one request, so that is roughly 6,000 page views a day, far above what most local-business sites see, and the number to check if a client expects a big launch.

Two honest limits of the approach itself. The page is rendered in the browser, so the delivered HTML is an empty shell and the content arrives a moment later. Search engines do render JavaScript, but if search ranking is the whole point of the site, use the server-rendered setup instead, which uses the same renderers. And when a client later needs something bigger than this, such as staging and live environments, or an agent doing more authoring, that is what Pro is for, and you can move up for as long as you need it.

Part 1: Cloudflare, a domain and a static site

Do this first, with an empty page, so the slow things (a domain, DNS) are settled and the 14-day clock has not started yet. The trial begins when you create the ebitex organization in Part 2, so do not create it early.

1. The domain

Register it in Cloudflare’s dashboard under Domain Registration, or add a domain you already own to Cloudflare and change its nameservers to the two Cloudflare gives you. Either way it ends up in the same place: a zone in the client’s Cloudflare account. Prefer the client’s own account, with you invited as a member, so the domain is theirs when the engagement ends.

2. The project

You will build in one project from here to the end. Create it now:

npm create vite@latest my-site -- --template react-ts
cd my-site
npm install
npm install --save-dev wrangler

3. Tell Cloudflare how to serve it

Cloudflare serves a built folder as static assets from a Worker. The one setting that matters for a site like this is the fallback, because ebitex decides what exists at each address and so every path has to be answered by the same index.html. Create wrangler.jsonc in the project root:

{
  "name": "my-site",
  "compatibility_date": "2026-10-06",
  "assets": {
    "directory": "./dist/",
    "not_found_handling": "single-page-application"
  }
}

Without that last setting, a request for /about is answered with a 404 before your code runs.

4. Deploy the empty page

npm run build
npx wrangler deploy

The first deploy asks you to sign in to Cloudflare in the browser, and prints a workers.dev address. Open it and you should see Vite’s starter page. To deploy on every push instead, connect the repository to the Worker in the dashboard and give it npm run build as the build command; the wrangler.jsonc above is what it reads.

5. Put the domain on it

Add a route to wrangler.jsonc so the Worker answers on the real hostname, then deploy again:

"routes": [{ "pattern": "www.example.com", "custom_domain": true }]

Cloudflare creates the DNS record and the certificate for you. Write down the exact origin you now have, https://www.example.com. Part 2 needs it.

Part 2: the content, built by Claude Code

1. Start the trial and mint a key

Sign up at ebitex.io and create the organization, which starts the 14 days. Name it for the customer, since that is whose it will be. Then open Content, and under Settings > API Keys > Management keys create a key. Four things are fixed at the moment you create it, and none can be widened afterwards, so choose them deliberately:

  • Environment: the one shown in the switcher at the top. A key works in that one authoring environment and no other. A new organization starts with a default one, which is the one you want.
  • Role: the role it acts as. A key can only do what that role can do. Choose the least powerful role that can create content and publish it.
  • Permissions: tick Read, Authoring (it creates and edits individual items, and is the only one that can delete) and Publish. Leave Write off; it is for applying whole bundles, which this is not.
  • Expiry: 30 days. The trial is 14, and you will revoke it sooner.

The key is shown once, and a management key can change your content, so treat it like a password. It never goes into the project’s files or a browser. A key belongs to the organization, not to you, so it outlives your membership if you forget it. That is why revoking it is the first step of the handover in Part 4.

2. Give it to Claude Code

From the project directory:

claude mcp add ebitex-content -e EBITEX_CONTENT_MANAGEMENT_KEY=<your key> -- npx -y @ebitex/content-mcp

The default scope for claude mcp add is local to you and this project, which keeps the key out of anything you commit. Start Claude Code and ask it to call content_whoami before it does anything else. It reports the organization, the environment and the role the key resolved to, and which tools it withheld. If any of that is not what you expected, stop and fix the key.

3. Brief it

The server knows nothing about your content model. It asks the platform what exists and relays every refusal whole, so the agent can read an error, fix the one field it names, and try again. What it needs from you is the model, and the business. Something close to this works:

Using the ebitex-content MCP server, build a one-page site for <business name>, <what they do>.
First read ebitex-content://help/agent-authoring, then call content_describe. Check what exists
before creating anything, and use these exact external ids.

Contracts:
- hero: headline (short text, mandatory), subheadline (long text), label (short text), url (short text)
- services: heading (short text, mandatory), body (rich text)
- page: title (short text, mandatory), sections (presentation, enumerable)
Templates, each supporting the Contract of the same name, with no settings: hero, services, page.
Components: a page called Home whose sections are a hero and a services block.
Then create the site if the environment has none, make its root node present the Home component
through the page template, and publish. Show me the publish plan before you execute it.

Copy: <the headline, the services, the contact details>.
Stay within one site, ten pages and fifty components. Do not create anything I have not listed.

Two parts of that earn their keep. Exact external ids, because the Template ids are what your renderers will be named after in Part 3, and an agent left to choose them will choose something. And the publish plan first, because it is where the system tells you what is about to go live and what is blocking it.

Watch it work. It will read the field types’ own schemas, create the three Contracts, then the Templates, then the Components, then the node, and publish. It is also worth reading what it wrote. Open Contracts, Templates and Composer in the app and check them against the list above. This is also what your client will see, so it is the first review of the handover.

4. A key the browser may hold

The agent cannot make this one, and should not: a management key can never be made browser-safe. The site’s JavaScript is public, so its key is too, and Content has a kind of delivery key made for that. Under Settings > API Keys, create a delivery key, name it, and turn on Browser-safe key. List every origin the site runs on: http://localhost:5173 for development, and the production origin from Part 1, https://www.example.com. Copy it, because it is shown once.

It is safe to ship for two reasons. A delivery key can only read what you have published, which is public on the page anyway. And a browser-safe key answers only requests from the origins you listed, so another site cannot use it from its visitors’ browsers.

Part 3: the front end, by the same agent

The agent is still connected, which is the useful part. It can read the Contracts and Templates it just made, so it does not need the fields described to it twice. The brief is short.

1. Install the SDK

npm install @ebitex/content-sdk react-markdown remark-gfm

Put the delivery key in .env.local, which Vite’s template already keeps out of git:

VITE_CONTENT_DELIVERY_KEY=<your browser-safe key>

2. Ask for the renderers

Render the page we just published in this Vite + React + TypeScript project with
@ebitex/content-sdk, following https://developers.ebitex.io/getting-started/static-site/.
Read the key from import.meta.env.VITE_CONTENT_DELIVERY_KEY. Use content_describe to read the
hero, services and page Contracts, and add one renderer per Template in src/presentations/,
named by the Template id. Render a list of presentations with PresentationList, and RichText
markdown with react-markdown and remark-gfm. Plain, accessible CSS, no framework.
Run npm run build when you are done.

Two details are worth checking in whatever it writes, since they are the ones that go wrong quietly. The renderer’s file name is its registration, so hero.tsx renders the Template whose id is hero. And Content’s markdown is CommonMark plus GFM tables and strikethrough, and nothing else, so the markdown library should be configured for exactly those two.

3. What the code ends up as

It is short. This is src/main.tsx, the whole of the wiring:

import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import Markdown from 'react-markdown'
import remarkGfm from 'remark-gfm'
import { createContentClient } from '@ebitex/content-sdk'
import { ContentProvider, Experience, renderersFromGlob, type MarkdownRendererProps } from '@ebitex/content-sdk/react'

const content = createContentClient({
  apiKey: import.meta.env.VITE_CONTENT_DELIVERY_KEY,
  // A repeat visit paints from localStorage while the network resolve runs.
  cache: { persist: true },
})

const renderers = renderersFromGlob(import.meta.glob(['./presentations/*.tsx', '!./presentations/*.test.tsx']))

function Prose({ markdown }: MarkdownRendererProps) {
  return <Markdown remarkPlugins={[remarkGfm]}>{markdown}</Markdown>
}

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <ContentProvider client={content} renderers={renderers} markdown={Prose}>
      <Experience
        path={window.location.pathname}
        onRedirect={(target) => window.location.replace(target)}
        notFound={<p>Nothing is published at this address.</p>}
      />
    </ContentProvider>
  </StrictMode>,
)

createContentClient works out the site, the visitor’s language and the personalization context for you. <Experience> asks what is published at the current path and renders the Presentation found there by calling the renderer registered for its Template, and then does the same for every Presentation inside it.

Three details match the Northwind Coffee sample, which is the reference to compare against. The second pattern in the glob keeps a test file from being registered as a Template. The client finds your site itself when the organization publishes only one, which on Starter it always does; the sample lets you pin it with an optional VITE_CONTENT_SITE_ID to save one request on a first visit. And path reads window.location.pathname, so every navigation is a full page load, which is fine for one page. For several, pass a router’s pathname instead and navigate in onRedirect, as the sample does with React Router.

A renderer is an ordinary component that receives one Presentation. This is src/presentations/hero.tsx:

import type { PresentationRenderer } from '@ebitex/content-sdk/react'

interface HeroContent {
  headline: string
  subheadline?: string
  label?: string
  url?: string
}

const Hero: PresentationRenderer<HeroContent> = ({ component }) => {
  const { headline, subheadline, label, url } = component.content
  return (
    <section className="hero">
      <h1>{headline}</h1>
      {subheadline && <p>{subheadline}</p>}
      {label && url && <a className="button" href={url}>{label}</a>}
    </section>
  )
}

export default Hero

page.tsx renders <PresentationList items={component.content.sections} /> inside a <main>, and services.tsx renders its heading and <RichText fragments={component.content.body} />. Those three files plus main.tsx are the entire front end, and they build cleanly with npm run build, whose first step is a full type check.

4. Run it, then ship it

npm run dev

Open http://localhost:5173/. You should see the hero and the services section the agent published. If you see a panel instead, it says what to do. The two you will most likely meet are origin_denied, which means the page’s origin is not in the key’s allowed origins, and invalid_api_key, which means the key in .env.local is wrong or revoked.

Then deploy exactly as in Part 1:

npm run build
npx wrangler deploy

Part 4: land on Starter, and hand it over

The build is finished. Close the loop in this order, because each step depends on the one before.

  1. Revoke your management key in Settings > API Keys > Management keys, and remove the server from Claude Code with claude mcp remove ebitex-content. The agent has nothing left to do, and a credential that can change the content should not outlive its job.
  2. Replace the SDK’s default panels through <ContentProvider fallback> and errorFallback, and give <Experience> a loading placeholder as tall as the page, as the sample does, so the footer does not jump when the content arrives. Then deploy. They render in production too, and a visible gap is easier to find than a missing section.
  3. Switch the trial to Starter under Organizations > Subscriptions & Billing. If anything you built exceeds Starter’s limits, a summary says exactly what, and nothing is deleted or turned off.
  4. Subscribe. With more than two days of the trial left, nothing is charged yet: Stripe holds the subscription until the trial ends, and bills the card you entered then. Inside the last two days it bills immediately, and the page says so. Subscribing is also what unlocks invitations.
  5. Invite the customer. On the Members tab, invite their email address. You cannot invite someone as an Owner, so once they accept, change their role to Owner on the same tab.
  6. The customer replaces your card with theirs. As an Owner they can open Manage billing, which opens Stripe’s own billing portal, and update the payment method there. Do not skip this, and do it before the trial ends: until they do, the first charge goes to you.
  7. Step back. With a second Owner in place you are allowed to leave. On your own row, Leave organization… removes your access at once. Or you can stay, as described next.

If you stay on to maintain it

You do not have to leave. Starter includes three users, so you and the customer both fit. The customer, now an Owner, should narrow you: give you a minimal organization role, one that holds little or nothing, so you stay away from their billing, their API keys and their other products, and then give you your real role inside Content for the one environment. Content Author is usually right, and it can be limited further so you can write content without publishing it.

Ending it is as simple. On the Members tab, Remove from organization… takes effect immediately and everywhere: your access, your environment roles and any live preview links you held all stop at once. What you created stays, because it is the customer’s content. So does any API key you issued, because a key belongs to the organization, which is why step 1 above comes first.

The alternative: a month on Pro, then step down

The trial path is the cheapest, and its limit is the calendar. Fourteen days is enough for a one-page site and not always enough for a customer who takes a week to send their copy. It is also only available once: your next customer’s organization starts without a trial. In either case, keep Pro for longer and step down afterwards.

  1. Subscribe without switching the plan. Pro stays selected. With more than two days of the trial left, Stripe holds the subscription until the trial ends, so on a first organization you get the rest of the trial and then the first paid month on Pro, for one $50 charge. On a later organization there is no trial, and the first month is simply that $50.
  2. Hand over ownership as in Part 4, steps 5 and 6, so the customer’s card is the one that pays. You can work in Content as a member the whole time, and the management key stays available to the agent, short-lived, until you revoke it.
  3. When the site is live and the customer has what they need, step down. Under Organizations > Subscriptions & Billing an active subscription shows Manage billing, and Switch between plans is in the portal it opens. Everything from the trial path then applies unchanged: the key stops working, nothing is deleted, and Starter’s limits govern what can be created from then on.

Two things to settle with the customer before you start. Put the date in a calendar. A plan renews at the plan that is selected when it renews, so if the step down is forgotten, the second month is billed at Pro. And check what the portal says about when a change takes effect and whether anything is credited, because that is Stripe’s behaviour and the portal states it at the moment of choosing; this guide does not promise a refund it cannot see.

Weigh the price against what it buys. One month of Pro is $50, paid once if the step down happens on time, and it buys an agent doing the authoring and the front end, plus the time to finish properly. For a client site that would otherwise take a person days to model and wire up, that is a small, one-off cost of delivery, and it is reasonable to put it in the quote as exactly that. The site you hand over then runs on Starter at $20.

From here the customer edits the words, and nothing about the live site needs you. Changing a headline is an edit and a publish. A second page is a new node in Composer with the page Template and a new Component, and no new code. A new kind of section is a Contract, a Template and one renderer file. When the model settles, generate the types instead of keeping them by hand.

If you want a finished site to read after this one, the Northwind Coffee sample is the same approach carried a long way, with a blog series explaining each step.

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.