topics & resources

Four subjects, covered to the bottom.

Everything published here belongs to one of four tracks. Each track has a canonical series, a reference repository, and a set of follow-up articles for the awkward edge cases.

track 01

Clean & hexagonal architecture

Use cases, ports and adapters, aggregates that enforce their own invariants, and the dependency rule applied to real TypeScript — including the compromises that monorepos force on you.

Ports that don't leak your ORM
Result types over thrown exceptions
Module boundaries with project references

Browse 42 articles

track 02

Automated testing

A test pyramid that earns its keep: fast Vitest units around the domain, Mocha integration against real containers, Playwright end-to-end flows that stay stable for years.

Fixtures as architectural boundaries
Killing flake at the source, not with retries
Coverage that measures behaviour, not lines

Browse 38 articles

track 03

DevOps, Kubernetes & GitOps

AWS-hosted clusters run the way a small team can actually maintain: declarative manifests, Argo CD promotion, Terraform for the perimeter, and observability wired in from day one.

Multi-environment promotion without branch spaghetti
Zero-downtime rollouts and honest health checks
Secrets, IRSA and least privilege

Browse 34 articles

track 04

AI-assisted development

Where agents genuinely accelerate typed work — scaffolding adapters, generating test tables, migrating APIs — and the guardrails that keep the diff reviewable.

Test-first prompting loops
Refactors gated by CI, not vibes
Reviewing generated code like a junior's PR

Browse 26 articles

how i write & curate

Every article goes through the same four gates

STEP 01

Build it for real

The pattern gets used in a working system first — usually a client codebase or a full sample app, never a snippet invented for the post.

STEP 02

Cover it in tests

Unit, integration and end-to-end suites go green before a word is written. The tests define what the article is allowed to claim.

STEP 03

Write the trade-offs

Draft names the alternatives, the cost of each, and the conditions where my choice stops being the right one.

STEP 04

Publish the repo

Article ships with a public repository, pinned versions, and a CI badge you can check yourself. Corrections get folded in publicly.

reference snippet

What "tested" means here

Domain tests never touch I/O. Adapters get their own contract tests. End-to-end covers the flows a user would complain about. That split is what keeps a suite fast enough to run on every save.

Read the testing track

TypeScriptcreate-order.spec.ts

import { describe, it, expect } from 'vitest';

describe('CreateOrder', () => {
  it('rejects a line with zero quantity', async () => {
    const orders = new InMemoryOrderRepository();
    const useCase = new CreateOrder(orders, fixedClock('2026-07-31'));

    const result = await useCase.execute({
      customerId: 'cus_1024',
      lines: [{ sku: 'SKU-9', quantity: 0 }],
    });

    expect(result.isFailure()).toBe(true);
    expect(orders.saved).toHaveLength(0);
  });
});

faq

Questions readers ask

Is everything free?

Yes. Every article, every repository, every diagram. The newsletter is free too — there is no paid tier and no gated PDF.

Which versions do the examples target?

TypeScript 5.x with strict mode on, Node 22 LTS, Vitest 2, Playwright 1.4x, Kubernetes 1.30+ and Argo CD 2.11+. Repositories pin exact versions and CI re-runs them monthly so you can see when something rots.

Can I use the code at work?

All sample repositories are MIT licensed. Copy them, fork them, ship them. Attribution is welcome but not required.

Do you take requests?

Often. If a topic keeps coming up in the inbox it goes on the list — send it through the contact form.

Do you write about front-end architecture too?

Some, when the typing story is the interesting part — shared domain packages, typed API clients, and end-to-end type safety across the boundary. Pure styling and component-library posts are out of scope.

How often do you publish?

One long-form article every other Thursday, plus shorter follow-ups when a reader finds a hole in an existing piece.