Software Production

Part 1: Duplicated Contracts — When a One-Field Change Touches Six Places June 4, 2026

Adding one field to a document page touches six places at once. Where duplicated contracts and dual rendering come from, and how to judge what the synchronization costs.

Part 2: The Target Architecture — Who Owns Which Decision on One Request June 7, 2026

One request for one document page, followed through Nuxt, an in-process GraphQL gateway and a .NET backend, naming which component owns each decision along the way.

Part 3: GraphQL Schema Stitching — Composing One Schema and Owning the Consequences June 8, 2026

Composing CMS content and application records into a single GraphQL schema, and owning what composition makes your problem: cache identity, invalidation, and partial failure.

Part 4: The @delegate Directive Deep Dive — One Field, Two Subgraphs June 9, 2026

A custom delegation directive built on graphql-tools: how one field resolves across two subgraphs, and what happens when the same field appears on a list of fifty documents.

Part 5: GraphQL-Based Code Generation — Moving Contract Errors Into the Build August 1, 2026

Deriving client types and operations from the GraphQL schema so a renamed or newly nullable field fails the build instead of the browser, and what generation still cannot check.

Part 6: Nuxt Module Boundaries — What They Enforce and How Modules Communicate August 4, 2026

What a Nuxt module actually enforces, how to declare its public interface and SSR-safe state, and how modules communicate without recreating the coupling the migration removed.

Part 7: Two Toolkit Modules — Generating Composables for Queries and Typed Translations August 11, 2026

Two Nuxt modules that generate the entry points developers would otherwise wire by hand: a composable per GraphQL query and a typed object for parameterized translations.

Part 8: The Compose Pattern — Mapping Variant Props to Class Names Outside the Template August 13, 2026

Moving variant styling out of the template: a pure function maps typed props to class names per component region, which makes reuse simpler and the mapping unit-testable.

Part 9: Nuxt and a Headless CMS — Serving Pages the Router Has Never Heard Of August 17, 2026

Server-rendering editorial pages that no file-based route describes, using a catch-all route, generated component dispatch and stub-and-load fetching, with the trade-offs named.

Part 10: Visibility Rules and Editor Preview — Explaining Why a Section Is Not There August 20, 2026

An editor cannot tell whether a missing section is a draft, a cached result, an unsupported type or a visibility rule. Connecting rule evaluation and live preview so it can be explained.

Part 11: A/B Testing at the SSR Level — One Assignment per Request August 25, 2026

Server and browser can disagree about which variant a visitor sees. Assigning once per request, reusing the assignment during hydration, and keeping cache identity and evaluation honest.

Part 12: Hydration Mismatches — Finding and Fixing What the Server and Browser Disagree On August 28, 2026

A page that is correct when it arrives and wrong a moment later. Hydration mismatches as a category: state initialization, event replay, and a cookbook for fixing rather than hiding them.

Part 13: Kinds of Waiting — Measuring Before Choosing a Performance Fix September 1, 2026

A page can look fast and still feel slow. Telling the kinds of waiting apart and measuring at the same boundary before and after, instead of guessing at a performance fix.

Part 14: Deferred Hydration — Deciding What Is Allowed to Wait September 3, 2026

Deciding which components may hydrate late and which must not, what an idle callback actually promises, and why deferred work is moved work rather than work removed.

Part 15: Security in a Nuxt SSR App — Following One Write Through the Boundaries September 5, 2026

Following one write operation through every boundary of a Nuxt SSR app: who the request is from, whether the user intended it, whether they may do it, and where server code is not a safeguard.

Part 16: Multi-Environment Infrastructure — One Setting, Three Environments, No Divergence September 1, 2026

One build artefact, three environments, and the release that deploys successfully with a setting nobody intended. Configuration, deployment revisions, probes and rollback.

Part 17: Memory, Stability, and PM2 — Why a Heap Limit Did Not Prevent the Restart September 10, 2026

A container killed for memory while the V8 heap looked fine. Separating heap, RSS and container limits, and a sizing procedure for worker counts, reloads and probes.

Part 18: From a Latency Alert to a Root Cause — Traces, Logs, and Metrics in Practice September 12, 2026

From a latency alert to a root cause with traces, logs and metrics: which component produces which signal, what each one proves, and why a correlation ID is not a trace ID.

Part 19: Load Testing an SSR Migration — Making the Numbers Comparable September 14, 2026

Comparing an SSR migration with the stack it replaced, when the two were measured by different tools at different boundaries. Defining the statistic before claiming an improvement.

Part 20: The Full Picture — Was the Machinery Worth Owning? September 16, 2026

Eighteen months later: did the one-field change actually get cheaper? What the machinery was worth owning, which lessons transfer, and where I would not build this again.

Nuxt in Production