Next.js CMS for client sites
A Next.js CMS for client sites your agent writes
jtakeit is a git-based Next.js CMS for client sites: your agent builds a static export into a repository you keep, the owner edits by tapping the text on the page, and the platform runs forms, bookings, hosting and the domain.
$ npx create-next-app@latest client-site --ts --app
$ cd client-site
# next.config.mjs: output 'export', basePath from SITE_URL
$ npm run build
$ ls dist
404.html _meta.json _next index.html robots.txt sitemap.xml
$ git push origin main
# then, over MCP: validate_catalogue → commit_and_build01/ what it needs
What a Next.js CMS needs for client sites
A client site built in Next.js needs more than a place to keep words. The owner has to change their own text without calling you, and the site still has to take enquiries, take bookings and let the client leave with their data.
Edits that can’t break the design
The owner taps the text on the page and fills only the fields the catalogue declares. No add-page or add-block button, by design.
Content in your repository
The published words are JSON in the git repository you keep. Every save is a commit.
Enquiry forms
Forms are protected against spam, and enquiries arrive in Telegram, email or the admin inbox.
Paid bookings
The bookings module sends paid bookings straight to the business’s own Stripe.
A preview before payment
The client signs off on the real site, on a preview, before it goes live.
A way out
Enquiries and bookings export as CSV and JSON. Export never needs a live subscription.
02/ git or api
Git-based, or a Next.js headless CMS?
A headless CMS keeps content in its own database and serves it over an API — a good fit when a content team publishes to a website, an app and more. A client site has one owner and one site, so jtakeit keeps its words in the repository next to the code.
| A typical headless CMS | jtakeit | |
|---|---|---|
| Published content | In the CMS’s database, fetched over its API | JSON in your repository |
| How the build gets it | An API call from the build or from the server | A file the platform assembles for each build |
| A save | A record update | A commit; drafts stay in the platform’s database |
| Where the owner edits | A separate admin app | On the page itself, by tapping its text |
| Forms, bookings, hosting | Outside the CMS, added separately | Run by the platform, with billing, backups and the domain |
| The site as it was in March | Depends on the CMS’s history | One command in git |
03/ static export
Next.js static export on jtakeit
The platform builds every site the same way: it runs the project’s build, then serves the folder the build writes. Next.js fits as a static export — HTML written at build time, with no server running when somebody visits.
// next.config.mjs
const site = new URL(process.env.SITE_URL ?? 'http://localhost:3000/');
export default {
output: 'export', // static HTML, no server at request time
basePath: site.pathname.replace(/\/$/, ''), // '' live, '/p/<slug>' in preview
trailingSlash: true, // /about/index.html, not /about.html
images: { unoptimized: true },
};
// package.json — the platform runs `npm run build` and serves dist/
"scripts": { "build": "next build && rm -rf dist && cp -R out dist" }
// public/_meta.json — copied into dist/ with the rest of public/
{ "immutable": ["/_next/static/"] }// lib/jtk.ts — runs at build time, never in the browser
import { readFileSync } from 'node:fs';
const file = process.env.JTK_CONTENT_FILE;
export const published = file ? JSON.parse(readFileSync(file, 'utf8')) : null;
// data-jtk-path only when the platform asks for it
export const tap = (path: string) =>
process.env.PUBLIC_JTK_ANNOTATE ? { 'data-jtk-path': path } : {};
// app/page.tsx
<h1 {...tap('blocks[0].title')}>{hero.title}</h1>
// app/robots.ts
export const dynamic = 'force-static';
const site = process.env.SITE_URL!.replace(/\/?$/, '/');
export default function robots() {
return { rules: { userAgent: '*', allow: '/' },
sitemap: new URL('sitemap.xml', site).href };
}Set for every build
SITE_URLthe site’s address: the host for the canonical and the sitemapPUBLIC_JTK_ANNOTATEwhen set, mark every field the owner may editJTK_CONTENT_FILEwhere the published content was assembled for this build to read
What the build must contain
- A page of its own for every address — each page in its own folder, not a loose HTML file beside the others.
- Assets that work under the preview address. A preview is served under a path of its own, so the base path comes from the site’s address the platform sets.
- A 404 page, which the static export writes for you.
- A robots.txt that lets crawlers in, and a sitemap on the site’s address.
- A canonical on that host on every page, and no noindex anywhere — the platform refuses a build that has one.
- A caching note marking Next’s hashed assets as never changing, so they are cached for good.
- The catalogue of what the owner may edit, written by hand or by your own tool and checked by the platform. Forms send their enquiries to the platform.
04/ written by your agent
Next.js, with your agent setting up the contract
Astro is the scaffold jtakeit ships. On Next.js there is no starter to clone: you — or your AI agent, for example Claude Code through jtakeit’s MCP server — lay the project out to the documented contract, and the platform checks it the same way it checks any other site.
| Astro scaffold | Next.js static export | |
|---|---|---|
| Starting point | jtakeit’s Astro scaffold | Your own Next.js project |
| Catalogue | Generated and checked by the scaffold’s catalogue tool | Written by hand or by your own tool |
| Forms and specimens | Included | Yours to build; forms send enquiries to the platform |
| Dependencies | Pre-baked | Installed by your build |
| A build | Under a minute | About 90 seconds |
How the flow works with Claude Code →
How editing is declared on the Astro scaffold →
05/ choosing
Choosing the best CMS for Next.js client sites
Start with what the site has to do when somebody visits it. If it needs the server at request time — incremental static regeneration, API routes, middleware, server actions or pages rendered per request — jtakeit is not the tool: it serves static output only, on every framework.
If the site can be built ahead of time, the question becomes who edits it. jtakeit is for developers whose clients should change their own words — and nothing else — without a call to you, and who would rather not run forms, bookings, billing, backups, hosting and the domain themselves.
Not tied to Next.js? The Astro CMS for client sites is the shipped scaffold and builds in under a minute. How the git-based editing works on any generator is on the static CMS for client sites page.
06/ questions
Next.js CMS questions
- Does jtakeit support Next.js?
- Yes, as a static export. The platform runs the project’s build and serves the folder it writes, so a Next.js site fits when it is built ahead of time as a static export and copied to that folder. Astro is the scaffold jtakeit ships; on Next.js you lay the project out to the same documented contract yourself.
- Can I use the App Router?
- The App Router can produce a static export as long as nothing in the site needs a server at request time: no incremental static regeneration, no route handlers or server actions that run per request, no middleware and no rendering that depends on the request. That is a limit of Next.js static export itself, so check your app against Next.js’s static-export documentation.
- Is there an official Next.js starter?
- No. There is no Next.js starter, plugin or SDK. The scaffold jtakeit ships is Astro. On Next.js you — or your AI agent — set up the documented contract: the build writes to the folder the platform serves, it reads the published words from a file the platform prepares, and the catalogue of what the owner may edit is written by hand or by your own tool and checked by the platform.
- How long does a build take?
- About 90 seconds for a site that is not on the Astro scaffold, because the build installs your own dependencies. The Astro scaffold has its dependencies pre-baked and builds in under a minute.
- How does the client edit a Next.js site?
- By tapping the text on the page. The site’s catalogue declares which fields the owner may fill, and when the platform asks for it, your pages mark those fields. Every save is a commit to your repository, and the next build reads the published words from the file the platform prepares.
- What does it cost?
- Signing up, building and previewing are free. Once a site goes live you pay a wholesale price per live site, monthly or yearly, and charge your client your own price — the same on Next.js as on Astro. The numbers are on the pricing page.
07/ try it free
Try it on a real client site
Sign up in the panel and build your first client site — on the Astro scaffold or as a Next.js static export. You pay a wholesale price only when a site goes live.
Try for freeadmin.jtakeit.com
- Free until a site goes live
- Then a wholesale price per live site, from €5 a month
- The code stays in your git repository