jtakeit
Try for free

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.

zsh — client-site
$ 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_build
A Next.js static export laid out to jtakeit’s contract: one build, in the folder the platform serves.

01/ 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.

Where content lives: a typical headless CMS, described in general terms, compared with jtakeit. Individual products differ — check the one you are considering.
A typical headless CMSjtakeit
Published contentIn the CMS’s database, fetched over its APIJSON in your repository
How the build gets itAn API call from the build or from the serverA file the platform assembles for each build
A saveA record updateA commit; drafts stay in the platform’s database
Where the owner editsA separate admin appOn the page itself, by tapping its text
Forms, bookings, hostingOutside the CMS, added separatelyRun by the platform, with billing, backups and the domain
The site as it was in MarchDepends on the CMS’s historyOne 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 · package.json · public/_meta.json
// 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/"] }
A static export writes to its own folder by default, so the build script copies it to the one the platform serves.
lib/jtk.ts · app/page.tsx · app/robots.ts
// 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 };
}
Read the published words at build time; annotate only when the platform asks.

Set for every build

  • SITE_URLthe site’s address: the host for the canonical and the sitemap
  • PUBLIC_JTK_ANNOTATEwhen set, mark every field the owner may edit
  • JTK_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 scaffoldNext.js static export
Starting pointjtakeit’s Astro scaffoldYour own Next.js project
CatalogueGenerated and checked by the scaffold’s catalogue toolWritten by hand or by your own tool
Forms and specimensIncludedYours to build; forms send enquiries to the platform
DependenciesPre-bakedInstalled by your build
A buildUnder a minuteAbout 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