THE HEADLESS CMS GENERATOR FOR DEVELOPERS

Generate.
Customize.
Ship.

Build your headless CMS with Go, PostgreSQL and React. Evolve the model in the UI while developing business logic in custom code; regeneration preserves your extensions.

Your application. Your code. Your rules.

GO / POSTGRESQL / REACTEXPLORE THE WORKFLOW ↓

PRODUCT DEMO

See it in action

Define your models visually. Generate your project. Open your admin panel.

03 / GENERATED ADMINPRODUCT SCREENSHOT
Generated admin: records, filters and content languages.Generated admin: records, filters and content languages.

From model settings to the generated admin and deployment.

Your application. Your code. Your rules.

HOW IT WORKS

From models to your application

A visual starting point. A generated project. Space for your own code.

01 / WORKFLOW

Define models

Shape your entities, fields and relationships in the Generator UI.

EntitiesFieldsRelationships

02 / WORKFLOW

Generate project

Review changes and generate your Go backend and React admin.

Review changesGo + React

03 / WORKFLOW

Extend your app

Develop custom business logic alongside model changes. Regenerate the shared foundations and keep your extensions.

Generated zonesCustom zones

Your application. Your code. Your rules.

WHY ADMINGEN

Less boilerplate.
More control.

Visual model authoring

Define entities, fields and relationships in the UI. Review changes before generating.

Backend and admin together

Generate a Go backend and React admin from the same authored model.

Documented APIs

Generated OpenAPI artifacts describe the generated REST API.

Connected data

Model belongs-to and many-to-many relationships, including inverse views.

PostgreSQL migrations

Generate PostgreSQL schema changes as append-only migrations.

Code you can extend

Keep your logic in custom zones through regeneration. Connect your own React home page with Custom dashboard; disabling it preserves your code.

Access management

Choose admin CRUD and external API access per operation. Built-in accounts and roles; rules enforced by the backend.

Deployment choices

Run on one server or split frontend and backend across two. Choose image delivery and CI independently.

AI model assistant

Describe new entities, refine an unapplied proposal and review it before Apply. Saved entities stay under your manual control in Content.

Read guide

Visual admin editor

Arrange form fields, sections, rows and tabs. Save the layout in the model and generate it with your application.

Read guide

Your project’s brand

Brand the admin and sign-in page with separate titles, images and colors. Preview both themes with automatic readability adjustments; disabling branding preserves your settings.

Read guide

Demo settings you control

Build a guided demo with the viewing journeys you need. Add or remove journeys in the UI and choose whether to generate per-folder ADMINGEN.md guides.

Read guide

Explore the generated stack and customization boundaries.

Read docs

Standard use includes up to 15 authored entities without an account. AI, Admin editor and larger-model growth require the corresponding account access. Your generated application runs independently.

Account and access

BUILT FOR DEVELOPERS

Own your code. Keep your changes.

Generated foundations and your custom logic have separate homes.

Define your models visually

Entities · fields · relationships

Manifest → normalized spec

One authored model drives the generated project.

Review plan & diff → Generate

Review the changes before applying generation.

Go backend

Application and API

React admin

Generated admin interface

PostgreSQL migrations

Append-only schema changes

OpenAPI

Generated REST API contract

Access & auth

Account roles and operation rules

Deployment files

Docker · Nginx · delivery adapters

Generated zones

Generator-owned output. Avoid hand-editing files that regeneration replaces.

backend/internal/generated/**admin/src/features/<entity>/generated/**

Custom zones

Your extension logic belongs here and is preserved through regeneration.

backend/internal/custom/**admin/src/features/<entity>/custom/**

SCHEMATIC OUTPUT PATHS

backend/openapi/backend/migrations/

ACCESS, DEFINED PER OPERATION

Admin CRUD · per-operation access

External API · off / authenticated / anonymous

Field conditions for external List/Get · backend enforced

Extend custom zones. Keep generated zones generator-owned.

Read customization docs

DEPLOYMENT

Your servers. Your deployment path.

Generated Docker workflows for one server or separate frontend and backend servers. Choose how images arrive, which CI runs them, and where images are stored.

Single server

Admin, API and PostgreSQL on one prepared VPS.

ONE VPS · NGINX + HTTPS

Admin · API · PostgreSQL

Separate servers

Frontend ingress and admin on one VPS; API and PostgreSQL on another.

FRONTEND VPS

Nginx · HTTPS · Admin

BACKEND VPS

Nginx · API · PostgreSQL

Choose image delivery

Build on server

Manual or GitLab CI · single server

Image archives

Transfer over SSH · single or split

Registry images

Pull release images · single or split

Choose CI/CD and registry independently

Manual · GitLab CI · GitHub Actions

GitLab CI can build source on your VPS or deliver runner-built images. GitHub Actions supports archive and registry delivery.

IMAGE REGISTRY

GitLab Registry · GHCR · Docker Hub · Custom

Choose the registry independently of CI.

Nginx + HTTPS

Reverse proxy and certificate management with Certbot.

Generated configuration for prepared servers.

Public READ cache

Opt in to Nginx caching for anonymous List/Get responses, with configurable TTL.

Admin and authenticated requests bypass the cache. Cached responses may remain unchanged until TTL expiry.

Release and recovery

Environment profiles, release checks, image rollback and optional local or S3-compatible backups.

Image rollback and data restore are separate operations.

Configure hosts, domains and secret files in your deployment environment.

Read deployment docs

USE CASES

An admin for the work behind your product.

Turn your models into tools for the people who manage your data.

Internal tools

Give your team a place to manage records, relationships and routine updates, with access configured for each operation.

Content admin

Manage structured content and related data. Choose which external reads are available to your website or application.

SaaS backoffice

Build an admin for your product’s data, then add the custom workflows and business logic your team needs.

Data operations

Browse, search and update application data through generated screens, with relationships and validation defined by your models.

Examples of what you can build with Admingen.

START BUILDING

Start with your models. Build your application.

Develop the model and custom business logic in parallel. Generate the Go backend and React admin, configure access, and choose your deployment workflow.