Hello, Gofasta!

The first week of a new Go backend is always the same week. Pick a router. Wire up logging. Choose a database client, then find a migration tool that gets along with it. Write the CRUD layers you wrote last time. Argue about where the handlers go. Copy the Dockerfile from the last project and hope nothing rotted in the meantime.

None of that is your product. It is a toll, and most teams pay it in full on every new project.

Gofasta is what we built so we could stop paying it.

Two pieces, both MIT#

The CLI lives at github.com/gofastadev/cli:

go install github.com/gofastadev/cli/cmd/gofasta@latest

It scaffolds projects, generates full CRUD layers from one command, runs migrations, regenerates dependency injection, and tells you when your tree has drifted. At runtime it never imports the library. It only writes files.

The library lives at github.com/gofastadev/gofasta. Independent packages under pkg/*, each one a thing backends keep needing: config loading, JWT auth with RBAC, caching, structured errors, HTTP middleware, mailer, notifications, WebSockets, scheduled jobs, task queues, observability, feature flags, file storage, sessions, i18n, encryption.

Every package imports on its own. There is no umbrella that drags the rest in behind it. Where two packages do touch, it is because the job requires it. pkg/health pings the database and the cache, which is precisely what a health probe is for.

The code is yours#

gofasta new myapp writes about 80 files of plain, idiomatic Go. The server is a stdlib http.Server with chi in front of it. The commands you run, serve and migrate and seed, are ordinary Cobra subcommands. Models are GORM structs. Dependency injection resolves at compile time through Google Wire, so there is no reflection and no container magic waiting to be debugged at 2am. You can read the whole project in an afternoon.

That is also the honest answer to whether this is a framework. It is not. Nothing owns your code. There is no application object to register handlers into, no lifecycle wrapped around your program, no runtime that has to be present for the rest to make sense. go build, go test, golangci-lint, Delve and your IDE all behave exactly as they do in any other Go repo, because nothing here is custom.

It is not lock-in either. The scaffold imports pkg/* packages as opt-out defaults, the same way any Go service imports chi or gorm. Want a different JWT library? Delete the pkg/auth import and go get the one you prefer. Nothing else in the project has an opinion about it.

A day with it#

gofasta new myapp hands you the whole project: HTTP server, database layer, migration tooling, JWT auth with Casbin RBAC, slog logging, Swagger generation, Docker setup, and CI workflows ready to drop into .github/workflows/. Postgres is the default. --driver also takes mysql, sqlite, sqlserver, or clickhouse. Add --graphql and gqlgen comes wired up next to REST. Choose --layout layered or --layout feature to match how you like to organize code. If you change your mind six months later, gofasta refactor converts an existing project between the two.

gofasta g scaffold Article title:string body:text produces a model, a migration, a repository, a service, DTOs, a controller, route registration, a Wire provider, and tests for each layer. One resource, one command. What comes out is the code a careful Go engineer would have written by hand, and once it exists the CLI does not watch it, sync it, or reconcile it. It is yours to edit.

gofasta dev brings the local stack up. Docker services, migrations applied, Air hot reload, and a debug dashboard if you want one. One terminal, no orchestration scripts.

The pattern holds everywhere. The CLI runs, writes files, and gets out of the way. No daemon, no hidden state.

Built for your agent too#

Most backend tooling treats AI coding agents as an afterthought. We treat your agent as a first-class consumer of the CLI, which means giving it structured output, stable identifiers, and documentation that reflects the current build.

Every command takes a global --json flag. Errors carry a stable machine-readable code, a one-line message, a remediation hint, and usually a link into the docs. gofasta inspect describes any resource in your project as structured data, so an agent does not have to grep for it. gofasta ai <agent> installs tuned configuration, including permission allowlists, hooks and agent briefings, for Claude Code, Cursor, OpenAI Codex, Aider, or Windsurf. Projects that use none of those stay uncluttered.

The docs site publishes /llms.txt and /llms-full.txt, so an agent can reason about what gofasta does today rather than what its training data remembers.

Here is the bar we hold ourselves to. An agent working in a gofasta project should be measurably faster and more accurate than one working in a hand-rolled Go backend. That is a constraint on every feature we ship, not a product bolted on afterwards.

What is in the box on day one#

• HTTP routing via chi
• PostgreSQL, MySQL, SQLite, SQL Server, or ClickHouse, picked with --driver at scaffold time
• Migrations via golang-migrate
• JWT authentication plus Casbin RBAC
• Structured logging via slog
• Caching (in-memory or Redis) and file storage (local or S3-compatible)
• Mailer with SMTP, SendGrid, and Brevo drivers
• WebSocket hub for real-time channels
• Scheduled jobs (pkg/scheduler) and async tasks (pkg/queue, backed by asynq)
• Circuit breaker and retry with exponential backoff
• Prometheus metrics and OpenTelemetry tracing
• Feature flags via the OpenFeature Go SDK
• Swagger/OpenAPI generation from code comments
• Docker setup plus gofasta deploy for VPS-over-SSH deployment, with health checks and automatic rollback
• A debug dashboard, build-tag-gated so it costs nothing in production

Use what you need. Delete the rest.

Kick the tires#

The Quick Start takes about five minutes. The white paper walks through the reasoning behind every design choice at length, if you want to know why before you trust it. Everything happens in the open on GitHub. Issues, ideas and pull requests are all welcome, and we read them.