Guide

Admin panels for Go

Every application needs a screen where somebody internal can find a record, correct it, and get on with their day. In PHP that screen is Filament and it takes an afternoon. In Go there is no equivalent with that standing, which is why this search exists.

There are four ways teams solve it, and they differ on one question that matters more than any feature list: where does the admin's idea of your data live? In a config you write, in reflection over your structs, in a separate service, or in code generated into your repository. That answer decides what happens when the schema changes.

Star counts and activity dates checked against each project's source on 13 November 2026. Numbers move; the reasoning does not.

The four approaches

1. A Go admin library

You register tables and fields with a library that renders server-side HTML. Fast to start. The UI is the library's, and customising a screen means learning its extension model.

2. A general-purpose admin tool pointed at your database

Retool, Forest Admin, Appsmith and similar connect to Postgres directly. No Go code at all, excellent for internal operations, and your business rules are now in two places: your API and their query builder.

3. Build it yourself in React

What most teams end up doing. Total control, and the honest estimate is a month per application for tables with search, filters, sorting, pagination, bulk actions, CSV export and a form builder that handles relations.

4. Generate it from the model

A command writes the admin screen next to your Go model, into your repository. Regenerate when the model changes. You own the output and can edit it; the cost is a generator that has to be re-run and a convention to follow.

The options at a glance

Go admin panel options compared
OptionUI technologySchema lives inStarsLast activity
GoAdminServer HTML, AdminLTERegistered tables9.0kJune 2025
go-admin (team)Vue, separate appDatabase and config12.8kOctober 2026
QORServer HTMLStruct reflection5.3kNovember 2026
PocketBaseBundled dashboardThe database itself61.6kOctober 2026
Retool and similarHosted, drag and dropTheir query builderCommercialActive
GritReact, generatedYour Go modelSee repoNovember 2026

The options, in detail

1. GoAdmin

9,016 stars · last push June 2025 · Apache 2.0

The best-known Go admin library, explicitly inspired by laravel-admin. You register a table, describe its columns and form fields in Go, and it renders a themed admin with AdminLTE. It supports several databases and has a plugin system.

Strengths

  • A working admin from a short Go file per table
  • Several themes and multiple database drivers
  • No JavaScript build step anywhere

Trade-offs

  • No commits since June 2025
  • The visual style is of its era and not easy to escape
  • Customising beyond its model means fighting it

Best for: An internal tool where the look does not matter and the tables are simple.

2. go-admin (go-admin-team)

12,832 stars · active October 2026 · MIT

A different project with a confusingly similar name: a complete back-office application rather than a library. Gin and GORM on the server, a Vue and Element UI front end, with users, roles, menus and permissions already built. Much of the documentation is in Chinese.

Strengths

  • A whole working back office, not a library to assemble
  • RBAC, menu management and audit logging included
  • Actively maintained

Trade-offs

  • You adopt its project structure wholesale
  • Documentation is largely Chinese
  • The Vue front end is a second application to maintain

Best for: Teams happy to start from its codebase rather than add an admin to their own.

3. QOR

5,349 stars · active November 2026 · MIT

The oldest approach here. QOR reflects over your GORM structs and produces admin screens, with a set of adjacent modules for media, workflows and localisation. Being reflection-driven, it follows your model automatically.

Strengths

  • Follows your GORM models with little configuration
  • A family of modules: media, l10n, publishing, workflow
  • Long history in production

Trade-offs

  • A dated interface and a dated extension model
  • Reflection means surprises are discovered at runtime
  • Documentation is thin for its surface area

Best for: An existing GORM codebase that needs admin screens with minimal new code.

4. PocketBase

61,597 stars on its GitHub mirror · active, developed on its own git host

Here the admin is the product. One Go binary contains SQLite, the API, auth, file storage and a dashboard where you define collections, and it alters the real tables underneath. Nothing else on this page is as fast to a working admin.

Strengths

  • Download one file and you have an admin, an API and auth
  • The dashboard is genuinely well made
  • Realtime subscriptions and file handling included

Trade-offs

  • SQLite only
  • Your schema lives in the database rather than your repository
  • Adopting it is adopting the whole backend, not just an admin

Best for: New internal tools where one binary on one server is the right deployment.

5. Retool, Forest Admin and similar

Commercial · hosted or self-hosted · per-seat pricing

Point a hosted tool at your Postgres and assemble screens by dragging. No Go involved. For operations teams this is frequently the correct answer, and it is the fastest path to a usable internal screen that exists.

Strengths

  • Usable screens in an afternoon with no backend work
  • Non-engineers can maintain them
  • Connects to the database and your API alike

Trade-offs

  • Business rules end up duplicated outside your codebase
  • Per-seat cost grows with the operations team
  • Not reviewable in a pull request, and not in your repository

Best for: Operations tooling that changes weekly and is not part of the product.

6. Grit

Active November 2026 · MIT · this site

Ours. grit generate resource Order writes the Go model and the admin screen together: a React table with search, filters, sorting, pagination, bulk actions, CSV and Excel export, and a form built from the same field definitions. The output is TypeScript in your repository, reviewed in a pull request and edited like any other file.

Strengths

  • The admin is generated from the Go model, so the two cannot drift
  • The output is yours: readable, editable, in version control
  • Postgres, MySQL or SQLite rather than one database

Trade-offs

  • React and Next.js or Vite, not server-rendered Go
  • Regeneration is a command somebody has to run
  • You adopt a project layout along with the admin

Best for: Product teams who need an admin that keeps up with a schema that is still moving.

How to choose

Ask who changes the admin, and how often

If an operations team changes screens weekly and engineers are not involved, a hosted tool wins and the duplication is worth it. If the admin is part of the product and moves with the schema, you want it in the repository where a pull request can catch a mistake.

Ask where the schema is allowed to live

This is the question that bites later. If the admin keeps its own description of your tables, you now maintain two, and they drift silently. Reflection and generation both avoid that, in opposite ways: reflection reads your structs at runtime, generation writes code from them at build time. Generation is the one you can read, review and step through in a debugger.

Be honest about the month

A table with server-side search, filters that combine, sorting, pagination that survives a deep page, row selection, bulk actions, an export that matches the filters, and a form that handles relations and file uploads is not a week. Every team that has built one knows this and every estimate forgets it.

Where Grit fits

Grit exists largely because of this gap. The admin panel is generated from the same Go model that defines the table, so adding a column and re-running the generator puts it in the list, the filters and the form.

What you get per resource: a data table with search, combinable filters, sorting, pagination, row selection and bulk actions; create, edit and detail screens built from the field types; CSV and Excel import and export; role and permission checks on every route; and an audit trail of who changed what.

It is the wrong choice if you want server-rendered Go with no JavaScript build, or if a hosted tool pointed at Postgres would genuinely do.

Frequently asked questions

Is there a Filament for Go?

Nothing with Filament's standing. The nearest in spirit are GoAdmin for server-rendered screens, PocketBase if its dashboard can be your backend, and Grit if you want Filament's resource-definition model producing a React admin in your own repository.

Can I use Retool with a Go backend?

Yes. Retool connects to Postgres or to your REST API and does not care what wrote it. The trade is that query logic and permissions then live in Retool rather than in your codebase, which is fine for operations tooling and awkward for product behaviour.

How long does it take to build an admin panel from scratch?

For one resource with search, filters, sorting, pagination, bulk actions, export and a form that handles relations and uploads, plan on weeks rather than days, and multiply by the number of resources unless you build a generic table first, which is itself the month.

Should the admin be a separate application?

It depends on who signs in. A separate deployment keeps staff screens off the customer-facing surface and lets you lock it to an internal network. One application with a route group is simpler to run. Grit supports both, and the shapes are described here.

Keep reading