Go boilerplate generator — complete production Go API from your requirements

Archiet generates a complete Go Chi application from your product requirements. Every entity in your PRD becomes a PostgreSQL table with a goose migration, a set of chi handlers, a service layer, and a test suite. Auth, rate limiting, and infrastructure are included and wired together from day one.

What the generated Go app contains

Application structure (clean architecture)

cmd/
  api/
    main.go               # chi.NewRouter, server setup
internal/
  config/
    config.go             # reads from os.Getenv, raises on missing vars
  database/
    db.go                 # pgxpool connection pool
    migrate.go            # goose migration runner
  handlers/
    auth.go               # POST /auth/login, /auth/refresh, /auth/logout
    user.go
    {entity}.go           # one file per entity (GET, POST, PUT, DELETE)
  middleware/
    auth.go               # JWT validation, sets userID in context
    ratelimit.go          # per-IP token bucket
    cors.go
    tenant.go             # multi-tenant workspace scoping
  models/
    user.go               # pgx row structs + domain types
    {entity}.go
  services/
    auth_service.go
    email_service.go
    {entity}_service.go
  router/
    router.go             # all routes registered with middleware chains
migrations/
  001_initial_schema.sql
  002_create_{entity}.sql  # one migration per entity
go.mod
go.sum
Makefile                  # make dev, make test, make migrate, make lint
Dockerfile
docker-compose.yml        # app + PostgreSQL + Redis
openapi.yaml

Database layer

• pgx/v5 — PostgreSQL driver with connection pool, no ORM magic
• goose migrations — one .sql file per entity, version-controlled
• All foreign key columns indexed
• Multi-tenant filter on every protected query: WHERE workspace_id = $1
• Named parameters via pgx pgxscan — no raw string concat
• PostgreSQL — never SQLite

Auth and security

• JWT issued as httpOnly, Secure, SameSite=Lax cookies
• middleware.Auth validates token and injects userID into request context
• bcrypt password hashing via golang.org/x/crypto
• All secrets from os.Getenv() — nothing hardcoded
• Per-IP rate limiting on auth endpoints

API design

• go-chi/chi router with clean route groups per entity
• Routes match the generated OpenAPI 3.1 spec
• Consistent error format: {"error": "snake_case_code", "message": "Human readable description."}
• Pagination: page, per_page, total in list responses
• 201 for creation, 422 for validation errors, 403 for auth/permission, 404 for not found

Tests

• testify test suite with table-driven tests
• Integration tests spin up a test PostgreSQL database via testcontainers-go
• Auth tests: login, logout, token refresh, password reset
• Handler tests: correct HTTP status codes, error responses, auth enforcement, tenant isolation
• Coverage target: every handler and service function

Infrastructure

• Multi-stage Dockerfile (golang:alpine build → distroless production — binary under 20MB)
• docker-compose.yml: Go API + PostgreSQL + Redis (when rate limiting or job queues used)
• Makefile for common dev tasks: make dev, make test, make migrate, make lint
• GitHub Actions: golangci-lint → go test ./... → docker build → deploy

Go Chi vs Gin vs Echo — which to pick

Choose Go Chi when:

• You want minimal magic — chi is just a router, the rest is standard library
• You want maximum compatibility with net/http middleware
• You value composition over conventions (chi middleware chains are composable)
• Long-term maintainability matters more than initial scaffold speed

Choose Gin when:

• Your team already uses Gin and knows its binding layer
• You need the large Gin ecosystem of existing middleware

Choose Echo when:

• You prefer built-in data binding and validation helpers
• You're building an API gateway pattern

Archiet generates Go Chi. It's the choice that ages best: no framework churn, idiomatic Go, full compatibility with the standard library.

vs other Go starters

Generic Go starters like golang-standards/project-layout, evrone/go-clean-template, or repository-level go new commands give you a project skeleton.

What they don't give you: your entities, your handlers, your business logic, your migrations, your tests — the 85% of the application that is specific to your product.

Archiet starts where those starters end. Paste in your requirements, get back a production-grade Go API with your domain fully implemented.

EU AI Act Annex IV (high-risk AI, deadline August 2026)

Building an AI system with EU market exposure? Start with the free EU AI Act risk classifier, then generate Annex IV technical documentation, risk tier assessment, and post-market monitoring plan from the same Go Chi + Next.js blueprint that produces your app. Same genome → code + compliance artifacts.

• EU AI Act compliance use case
• Annex IV from architecture (GitHub)
• Compliance frameworks hub

CTA

Generate a complete Go Chi + Next.js application from your requirements — free plan, no credit card.

Describe your product, pick Go Chi, download a production-ready codebase in 90 seconds.

Start free at archiet.com.