§ 00 / products / goatcheese

GoatCheese. Describe the application; get the application.

Every line-of-business application is the same skeleton wearing different data: tables, screens to edit them, an API, users and roles, a log of who changed what. GoatCheese makes that skeleton a build product. You write one schema that names your entities, their fields and who may touch them; one command turns it into a working, documented application. Your effort goes into the ten percent that is actually your business.

what it is
command-line, schema-driven build engine
made by
APIgoat, in-house
version
v0.9
in production
six applications
AI
none needed to build it · builds for it
§ 01 / the idea

Schema in, application out.

The schema is the single source of truth. Everything downstream is derived from it and can be derived again.

Illustrative session — output condensed. GoatCheese is a command-line tool; everything it does is a command you can script, run in CI, or hand to an AI assistant.

01/describe

Write the schema

One readable file: the entities (clients, quotes, projects…), their fields and types, how they relate, and which roles may read, write or delete each one. It is the model of the business, not a pile of configuration — a product owner can follow it.

02/build

Run one command

gc build. The engine reads the schema and produces the whole application: database, admin screens, API, authentication, permissions, audit trail, an MCP server for AI assistants, deployment and backup commands, and the documentation to go with it. Minutes, not sprints.

03/extend

Add what is yours

Business rules — pricing, approvals, notifications, connectors to other systems — live in hooks and wrapper classes that sit beside the generated code, never inside it. Change the schema, rebuild, and your logic is still there.

§ 02 / what one build produces

The ninety percent nobody wants to write twice.

Each piece below is generated from the schema, consistent with every other piece, and thrown away and rebuilt whenever the model changes.

01

Database

Tables, keys, relations and indexes created from the schema; migrations when it changes. No hand-written table definitions to drift out of sync.

02

Admin interface

Lists, forms, filters, search and exports for every entity, shaped by the same roles that guard the API. Ready on day one, refined later.

03

REST API

A consistent endpoint per entity — list, read, create, update, delete — each route checked against the role matrix before it runs.

04

Users, roles, sessions

Sign-in with short-lived tokens and rotating refresh, role-based access down to entity and field, and optional OAuth 2.1 so other applications and AI assistants log in as a named user.

05

Audit trail

Who did what, to which record, when — recorded on every write, in the admin and through the API alike. The question "who changed this?" has an answer.

06

MCP server

The application is exposed to AI assistants through the Model Context Protocol: the same entities, the same permissions, reads separated from writes, writes confirmed before they execute.

07

Security check

Every build and deploy ends with an audit: access-rule coverage, headers, cookie flags, secrets, file permissions, dependencies. Findings land in a report before they land in production.

08

Deploy & backup

Commands to ship a release, run migrations and take or restore a backup — the operational chores are part of the build, not an afterthought.

09

Documentation

Reference docs for the data model and the API, regenerated with every build, so what is written down is what actually runs.

§ 03 / why it holds up

Rules that keep a generated app maintainable.

Code generators have a bad reputation: fast on day one, unmaintainable by month six. These constraints are what make the difference.

generated vs. written
A hard line between the two. Generated files are never edited by hand; custom logic lives in hooks and wrappers. Rebuilding is always safe, so the schema stays honest.
one source of truth
Database, screens, API, permissions, AI tools and docs all read the same schema. Add a field once and it appears everywhere, with the right access rules, in the same build.
permissions first
Roles are declared next to the data they protect and enforced at every door — admin, API and MCP. There is no path around them because there is no path that was written separately.
no AI needed — builds for AI
The engine itself has no model in the loop: same schema, same application, every time — deterministic, reviewable, reproducible. What it builds is made for AI: every application ships an MCP server, so an assistant like Claude can work in it as a named user with the same rights, through tools that expose business operations — "create a quote", "record a payment" — rather than raw tables.
boring by design
Conventional storage, conventional web stack, plain files you can read. Modern enough to be productive, mature enough to be quiet at 3 am.
proven, not published
In-house tooling, matured over six production applications and years of client back offices. You don't buy the engine; you get what it builds — and the next project starts further along.
§ 04 / built with it

Not a demo. The foundation under everything here.

Every APIgoat product and most client back offices of the last few years come out of the same engine. Each one exposes its own MCP server.

01/chatbot

APIchatbot

Multi-tenant AI chatbot platform: clients, document libraries, keys, usage billing and a client portal — all schema entities, plus retrieval logic in hooks.

product page →
02/billing

BillBoy

Invoicing and time tracking for freelancers: clients, projects, time logs, expenses with receipt scanning, clean invoices.

billboy.apigoat.com →
03/crm

LL-TEQ CRM

Contacts, companies, quotes, invoices, payments and document storage for a field-service company — steered day to day from an AI assistant.

04/trading

apigtbot

Paper-trading crypto bot platform: runs, strategies, decisions and P&L as entities; the daemons and market feeds as custom services beside them.

05/accounting

GoatCheese accounting

Accounting and time tracking: clients, suppliers, bills, payments, expenses, projects — the engine running its author's own books.

06/education

apigTutor

A voice-first French tutor for kids with a mobile app and a parent admin — the back office and progress data generated, the voice sessions custom.

07/and way more

…and way more

Eighteen projects on the engine so far: dashboards, client portals, a family organiser, a raid planner, a subscription manager, a lottery back office. Whatever the schema describes.

Start further along.

A custom CRM, ERP module, portal or back office on GoatCheese starts with a working, documented, AI-ready application in the first week — and the budget goes to what makes it yours. Send a brief; get a shape and a quote within one business day.