Get started

THE HEADLESS CMS GENERATOR FOR DEVELOPERS

Generate.
Customize.
Ship.

Build your headless CMS and backend with Go, PostgreSQL and React. Define your models in the UI, generate the project, and make it yours.

Get startedRead docs

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 ADMINACTUAL SCREENSHOT PENDING

Your generated admin

Screenshot slot — actual Generator/admin image pending

One project, from visual models to the generated admin.

Your application. Your code. Your rules.

Get startedRead docs

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

Extend custom code, configure access, and deploy with generated Docker workflows.

Generated zonesCustom zones

Your application. Your code. Your rules.

Get startedRead docs

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, separate from generated code, through regeneration.

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.

Explore the generated stack and customization boundaries.

Read docs

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 source build · 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

CI supports archive and registry delivery. Source builds run manually on one server.

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.

Generate the Go backend and React admin, configure access and deployment, then extend your application in custom code.

Get startedRead docs