Why I started writing things down

Every engineer I admire keeps some kind of notebook. Not a polished one — a working one, full of half-finished diagrams and "this is why the migration failed at 2am" entries.

This is mine, made public.

What lands here

Three things, mostly:

• Systems that had to hold up. Backend services, schema design, the boring reliability work that decides whether a launch is calm or not.
• Infrastructure that stopped being scary. Pipelines, containers, observability — and the specific moment each one clicked.
• Books worth the hours. Technical and otherwise. Reviews, not summaries.

A note on format

Posts here are written in markdown, which means code is a first-class citizen:

// A worker pool that respects cancellation — the version I keep reaching for.
func Pool[T any](ctx context.Context, n int, in <-chan T, work func(context.Context, T) error) error {
	g, ctx := errgroup.WithContext(ctx)
	for i := 0; i < n; i++ {
		g.Go(func() error {
			for {
				select {
				case <-ctx.Done():
					return ctx.Err()
				case item, ok := <-in:
					if !ok {
						return nil
					}
					if err := work(ctx, item); err != nil {
						return err
					}
				}
			}
		})
	}
	return g.Wait()
}

And so are tables:

The best architecture decision I ever made was the one I wrote down badly, argued about, and then rewrote six months later with the scar tissue included.

If something here saves you an afternoon, that's the whole point.