Wiring you can read at 3am.

The whole idea

Same project either way. Only main changes.

The project below is ordinary Go. Nothing imports servo, and a component joins the lifecycle by having a method rather than registering for one — so it is identical whether or not you use servo. What differs is the file that wires it together: construction in dependency order, rollback when one fails, every Run supervised, shutdown in reverse.

With servo that file is generated, from a build-tagged spec naming only the roots — servo.Root[*api.Server]() — which never reaches your binary. Everything else is read off the constructor signatures.

// config/config.go — reads the environment once;
// every package parses its own slice of it off this
func NewEnv() *Env

// logger/logger.go
type Config struct {
    Level string `env:"LEVEL" envDefault:"info"`
}
func NewConfig(config.Source) (*Config, error)
func New(cfg *Config) *Logger
func (l *Logger) Stop(context.Context) error

// postgres/postgres.go
type Config struct {
    DSN string `env:"DSN,required"`
}
func NewConfig(config.Source) (*Config, error)
func New(cfg *Config, log *logger.Logger) (*DB, error)
func (d *DB) Init(context.Context) error
func (d *DB) Stop(context.Context) error

// api/api.go
type Config struct {
    Addr string `env:"ADDR" envDefault:":8080"`
}
func NewConfig(config.Source) (*Config, error)
func New(cfg *Config, db *postgres.DB) *Server
func (s *Server) Run(context.Context) error
func (s *Server) Stop(context.Context) error

func main() {
    ctx, stop := signal.NotifyContext(
        context.Background(), os.Interrupt, syscall.SIGTERM)
    defer stop()

    env := config.NewEnv()

    logCfg, err := logger.NewConfig(env)
    if err != nil {
        log.Fatal(err)
    }
    lg := logger.New(logCfg)

    dbCfg, err := postgres.NewConfig(env)
    if err != nil {
        _ = lg.Stop(context.Background())
        log.Fatal(err)
    }
    db, err := postgres.New(dbCfg, lg)
    if err != nil {
        _ = lg.Stop(context.Background())
        log.Fatal(err)
    }
    if err := db.Init(ctx); err != nil {
        _ = db.Stop(context.Background())
        _ = lg.Stop(context.Background())
        log.Fatal(err)
    }

    apiCfg, err := api.NewConfig(env)
    if err != nil {
        _ = db.Stop(context.Background())
        _ = lg.Stop(context.Background())
        log.Fatal(err)
    }
    srv := api.New(apiCfg, db)

    errc := make(chan error, 1)
    go func() { errc <- srv.Run(ctx) }()
    select {
    case err := <-errc:
        log.Print(err)
    case <-ctx.Done():
    }

    // Reverse order, and every one still runs
    // when an earlier one fails.
    sctx, cancel := context.WithTimeout(
        context.Background(), 30*time.Second)
    defer cancel()
    for _, shutdown := range []func(context.Context) error{
        srv.Stop, db.Stop, lg.Stop,
    } {
        if err := shutdown(sctx); err != nil {
            log.Print(err)
        }
    }
}

func main() {
    ctx, stop := signal.NotifyContext(
        context.Background(), os.Interrupt, syscall.SIGTERM)
    defer stop()

    app, err := New(ctx)
    if err != nil {
        log.Fatal(err)
    }
    if err := app.Run(ctx); err != nil {
        log.Print(err)
    }

    // Not ctx: it is already cancelled, and that
    // is what started the shutdown.
    sctx, cancel := context.WithTimeout(
        context.Background(), 30*time.Second)
    defer cancel()
    if r := app.Shutdown(sctx); !r.Clean() {
        log.Print(r)
    }
}

Add a component and the left column grows in four places at once: a config, a constructor call, another Stop in every error branch below it, and another entry in the teardown list — all of it edits to code that already worked. The right column does not change, because it never names a component.

Why before you build

A missing dependency stops the build, not the deployment.

Runtime containers catch the same mistakes — later, through a reflection stack trace, in whichever environment ran the binary first. Servo reports them with a file and a line, like any other compile error.

Ambiguity, dependency cycles and unreachable providers fail the same way. Limitations is honest about what servo cannot resolve at all.

The reference

Every command, every marker, every rule

The tutorial teaches servo by building something with it. The reference answers one question at a time — what this flag does, what this method guarantees, why that function wasn't picked up as a provider. Written against the source, and complete rather than illustrative.

The tutorial

Building a microservice with servo

Twenty-one chapters that build one real order-management service from an empty directory: HTTP API, JWT auth, Postgres, Redis, NATS, metrics, tracing, a circuit breaker, four levels of tests, CI/CD and a container — plus the same API rebuilt in Gin and over gRPC. Every code block is copied from a real module you can run at every step.