A production Go backend in one command

gofasta scaffolds plain, idiomatic Go and generates the repetitive layers. Every default is swappable.

~/projects
$ go install github.com/gofastadev/cli/cmd/gofasta@latest$ gofasta new myappCreating new gofasta project: myappCreating directory myapp/Initializing Go module: myappCreating project structure...Installing gofasta library...Generating Wire DI code...Initializing git repository...ok Project myapp created successfully!
$ cd myapp && gofasta devStarting gofasta development server...Running migrations...Starting air (hot reload)...   REST API:  http://localhost:8080

Built for people who ship

From a side project to a team codebase, the workflow stays the same.

  • Solo engineers

    Skip the first two weeks of plumbing. Scaffold auth, database, jobs, and deploys in minutes, then focus on what only you can build.

  • Indie hackers

    Launch your SaaS in an afternoon, not a month. One command ships a production backend that's ready for paying customers on day one.

  • Startup CTOs

    Move at seed-stage speed on a foundation that holds at Series B. Standard Go, compile-time DI, every package independently swappable.

  • Senior engineers

    No custom runtime, no annotations, no lock-in. Read every line end-to-end. Google Wire for DI, standard net/http for transport, plain Go everywhere.

  • Agencies and consultancies

    Ship client projects in days, hand off in standard Go. No proprietary runtime to document. The code stands entirely on its own.

  • Enterprise teams

    JWT + RBAC, structured errors, security headers, Prometheus, OpenTelemetry, and audit-ready logging, wired on day one. Deploy to any VPS or CI/CD.

Standard Go. Zero lock-in.

Every file is idiomatic Go. No custom compiler, no annotations, no runtime wrapper. Every project builds with go build, tests with go test, deploys with any CI/CD. Every pkg/* package is deletable, so keep what fits and replace what doesn't.

Agent-native by default.

Every command accepts --json. Every error carries a stable code. A scaffolded AGENTS.md briefs any AI coding agent on your project's conventions. One command, gofasta ai claude, configures Claude Code, Cursor, Codex, Aider, or Windsurf. Humans and agents work the same way.

Production from minute one.

JWT + RBAC, rate limiting, CORS, security headers, Prometheus metrics, OpenTelemetry tracing, email, file storage, background jobs, and deploy-to-VPS, all scaffolded as importable packages. No stubs. No TODOs. Real production code on day one.

A Go toolkit built for humans and AI agents.

AI coding agents aren't afterthoughts; they're first-class users. Every surface of Gofasta is machine-readable so agents can scaffold, verify, inspect, and ship alongside you without losing context.

  • Universal --json flag

    Every command emits structured output. Pipe it into jq, into an agent, into CI.

  • Stable error codes

    ROUTES_DIR_MISSING, WIRE_MISSING_PROVIDER, GO_BUILD_FAILED: not opaque strings.

  • Scaffolded AGENTS.md

    A ready-to-read briefing that teaches any AI coding agent how your project is laid out.

  • One-command agent setup

    gofasta ai claude, or cursor, codex, aider, windsurf. Editor rules in seconds.

  • High-level commands

    verify, status, inspect, do: multi-step workflows collapsed into a single call with structured output.

gofasta status --jsonjson

See every request while you develop

gofasta dev --dashboard runs a self-contained debug panel on :9090 with live metrics, request logs, SQL, and trace waterfalls. No runtime agent, no cloud service.

gofasta debug watch
12:34:52GET/api/v1/users20012ms12:34:50POST/api/v1/users20145ms12:34:48PATCH/api/v1/users/4220018ms12:34:45DELETE/api/v1/tokens/abc20414ms12:34:42GET/api/v1/admin4016ms

Everything a production backend needs

Generated into your project as plain Go, backed by independent packages you can swap out.

  • new

    One-command scaffolding

    One command generates model, repository, service, controller, routes, and DTOs.

  • ai

    Agent-native tooling

    Scaffolds AGENTS.md, llms.txt, editor rules, and --json on every command.

  • auth

    Auth and RBAC

    JWT access and refresh tokens, role-based access control via Casbin, drop-in middleware.

  • db

    Multi-database

    PostgreSQL, MySQL, SQLite, SQL Server, and ClickHouse behind one GORM interface.

  • api

    REST plus optional GraphQL

    REST out of the box; add --graphql and gqlgen wires GraphQL onto the same service layer.

  • jobs

    Background jobs and tasks

    Cron scheduling via robfig/cron and async task queues backed by Redis and Asynq.

  • otel

    Observability

    Prometheus metrics, OpenTelemetry tracing, and structured slog logging as middleware.

  • sec

    Security and resilience

    Rate limiting, CORS, CSP, HSTS, panic recovery, retries, and circuit breakers.

  • deploy

    Deploy to any VPS

    Scaffolded Docker, systemd, GitHub Actions, and gofasta deploy ship to any VPS.

  • trace

    Request tracing

    Per-request spans across controller, service, repository, and SQL with stack snapshots.

  • sql

    N+1 detection

    Duplicate SQL templates firing in one trace get flagged automatically as they happen.

  • replay

    Edit and replay

    Edit a captured request's JSON body, fire it again, and watch the trace update live.

Four things Gofasta will never do to your code.

Every decision is one you can read, change, or remove. These four invariants hold across the CLI and the library, and they're the line in the sand between a toolkit and a framework.

Compile-time DI

Google Wire generates dependency wiring at build time. No reflection, no service locator, no runtime surprises.

Zero init-time side effects

Every pkg/* package has no side effects on import. Nothing starts until you start it. Nothing writes, listens, or connects without an explicit call.

Every package swappable

pkg/cache, pkg/mailer, pkg/auth. Each is a standard Go import on an interface. Delete any one, plug in an alternative, move on.

Full eject anytime

Remove github.com/gofastadev/gofasta from go.mod entirely and your project still builds. No runtime tether. No proprietary contract.

Three commands to a running backend

No cloud service, no signup, no configuration wizard. The CLI does the rest.

quick start
gofasta new myapp --driver postgres
Creating new gofasta project: myappGenerating Wire DI codeProject myapp created successfully
gofasta dev
Starting gofasta development serverRunning migrationsREST API: http://localhost:8080
gofasta g scaffold post title:string body:text
created app/models/post.model.gocreated db/migrations/000006_create_posts.up.sqlpatched app/rest/routes/index.routes.go

Try Gofasta

Install with go install. Scaffold with gofasta new. Run with gofasta dev.

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