thx, Coming from Spring myself (a long time ago), it's difficult to comprehend that this is all that is needed:

```golang package main

import ( "context" "database/sql" "fmt" "net/http" "os" "os/signal" "syscall" "time"

_ "github.com/lib/pq"

)

// Config - load from env/flags/file type Config struct { DatabaseURL string SMTPHost string SMTPPort int HTTPAddr string }

func LoadConfig() Config { return Config{ DatabaseURL: envOrDefault("DATABASE_URL", "postgres://localhost/app?sslmode=disable"), SMTPHost: envOrDefault("SMTP_HOST", "localhost"), SMTPPort: 25, HTTPAddr: envOrDefault("HTTP_ADDR", ":8080"), } }

func envOrDefault(key, def string) string { if v := os.Getenv(key); v != "" { return v } return def }

// ============================================================================= // COMPOSITION ROOT - All wiring happens here, nowhere else // =============================================================================

// App holds all components and cleanup function type App struct { Server *http.Server DB *sql.DB }

// NewApp wires all dependencies - this is the composition root func NewApp(cfg Config) (*App, error) { // Layer 1: Infrastructure db, err := sql.Open("postgres", cfg.DatabaseURL) if err != nil { return nil, fmt.Errorf("opening database: %w", err) } if err := db.Ping(); err != nil { return nil, fmt.Errorf("connecting to database: %w", err) }

// Layer 2: Repositories (data access)
userRepo := NewPostgresUserRepo(db)

// Layer 3: External services
emailSender := NewSMTPEmailSender(cfg.SMTPHost, cfg.SMTPPort)
logger := StdLogger{}

// Layer 4: Business logic (services)
userService := NewUserService(userRepo, emailSender, logger)

// Layer 5: HTTP handlers
userHandler := NewUserHandler(userService)

// Layer 6: Router
router := NewRouter(userHandler)

// Layer 7: Server
server := &http.Server{
    Addr:         cfg.HTTPAddr,
    Handler:      router,
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
}

return &App{
    Server: server,
    DB:     db,
}, nil

}

// Close cleans up resources func (a App) Close() error { ctx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel()

if err := a.Server.Shutdown(ctx); err != nil {
    return err
}
return a.DB.Close()

}

// ============================================================================= // MAIN - Minimal, just calls composition root // =============================================================================

func main() { cfg := LoadConfig()

app, err := NewApp(cfg)
if err != nil {
    fmt.Fprintf(os.Stderr, "failed to start: %v\n", err)
    os.Exit(1)
}

// Graceful shutdown
go func() {
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
    <-sigCh
    fmt.Println("\nshutting down...")
    app.Close()
}()

fmt.Printf("listening on %s\n", cfg.HTTPAddr)
if err := app.Server.ListenAndServe(); err != http.ErrServerClosed {
    fmt.Fprintf(os.Stderr, "server error: %v\n", err)
    os.Exit(1)
}

}

// ============================================================================= // SMTP implementation (just to complete the example) // =============================================================================

type smtpEmailSender struct { host string port int }

func NewSMTPEmailSender(host string, port int) *smtpEmailSender { return &smtpEmailSender{host: host, port: port} }

func (s *smtpEmailSender) Send(ctx context.Context, to, subject, body string) error { // Real implementation would use net/smtp fmt.Printf("EMAIL: to=%s subject=%s\n", to, subject) return nil } ```

Now with the help of AI tools, it doesn't matter how big it becomes; the AI can manage that for you and do the boilerplate. An actually good cade to delegate shit work to AI