#architecture
24 pieces filed under “architecture”.
Experiments that don't shift the layout
A/B testing without layout shift: server-side assignment, experiment flags that never leak into the DOM, metric integrity, and the true cost of visual editors.
Monorepo or not? A studio's decision framework
Monorepos solve code-sharing and coordination problems most studios don't have, at tooling costs they don't predict. When we say yes, and what we do when we say no.
Local-first sync engines: what we learned shipping one
Field notes from building a real sync engine: CRDT vs last-write-wins in practice, conflict UX that doesn't panic users, and when to skip it all.
Queuing writes for a flaky world
Offline writes done honestly: outbox queues, idempotency keys, optimistic state that admits it's pending, conflict surfacing, and deciding which features truly need them.
WebSockets vs SSE: a realtime guide without religion
An honest guide to realtime transport: WebSockets vs SSE vs polite polling. Lifecycle, reconnection with backoff, presence, scaling and mobile battery realities.
Rolling your own search in 2026: cheaper and better than you think
Search is a product, not a plugin. When we self-host Meilisearch or Typesense instead of renting the big names, how we tune typo tolerance, and the UX that forgives.
Web workers for real work: what we move off the main thread
Web workers aren't a WebGL party trick. CSV parsing, fuzzy search, image pipelines, zipping exports — how we move real work off the main thread without the plumbing pain.
Web Components vs React in 2026: a studio's scorecard
We build with both. An honest scorecard across portability, SSR, theming, a11y and hiring — plus where each earns its place on real projects.
Headless commerce: the honest trade-offs
When headless earns its complexity: team topology, total cost of ownership, performance ceilings, and the scenarios where a tuned theme wins. A decision scorecard.
Choosing a framework without the fashion show
How to choose a web framework honestly in 2026: content site vs app, team skills, hiring, SSR needs, ecosystem gravity, exit costs — plus our decision memo.
Headless commerce: when it's worth it and when it's theatre
Headless earns its complexity only in specific conditions. A decision framework: team requirements, real TCO, and the architecture sweet spots for mid-market brands.
Background jobs: boring patterns that save your weekend
Queues vs cron, idempotency, dead-letter queues and backpressure — the boring background-job patterns that keep small teams asleep at 3am.
GraphQL vs REST, eight years in: a pragmatic retelling
GraphQL vs REST in 2026, without the zealotry: where GraphQL earned its keep, where it added cost, and the plain-REST setups we'd pick again tomorrow.
Streaming SSR: practical notes from shipping it
Streaming SSR in practice: what actually streams, where Suspense boundaries help or hurt TTFB, hydration ordering, mid-stream errors, and how to measure it.
One schema everywhere: shared validation contracts
One Zod schema shared across client forms, API handlers and generated types. The architecture, error mapping and versioning that end validation drift for good.
Undo beats confirm: designing reversible software
Confirmation dialogs train users to click through danger. Undo-first design: timing, reversible architecture, soft deletes, and the trust dividend of forgiving software.
Realtime collaboration tech: CRDT, OT, or a polite refresh
Choosing a collaboration stack honestly: OT versus CRDTs, Yjs in production, presence as a feature, and when a polite refresh beats a sync engine.
The headless CMS migration runbook
A field-tested runbook for migrating to a headless CMS: content inventory, model mapping, redirect strategy, preview parity, and the cutover weekend checklist.
The caching layers cake: HTTP, ISR and the discipline of invalidation
A layered caching model for content-heavy sites — CDN, full-page, data and application caches — plus the purge-on-publish pattern that ends 3am incidents.
Local-first on the web: sync engines, honestly
What local-first architecture actually costs and buys: IndexedDB patterns, CRDT trade-offs, schema migrations, sync-status UX, and when server-first is simply right.
Islands architecture: sprinkle, don't soak
When islands beat a full SPA: hydration costs, interaction latency budgets, the pragmatic hybrid pattern we use on content-heavy sites, and the traps.
Generating PDFs from web tech without tears
Invoices, statements and reports generated from web tech: print CSS vs headless Chrome vs canvas composition, scored honestly — plus when PDF is the wrong answer.
Edge rendering: an honest guide for content sites
What edge rendering actually buys a content site, what it quietly costs, and the decision framework we run before moving a single route to the edge.
React Server Components: the trade-offs nobody puts in the talk
A sober field account of React Server Components: where they genuinely help, where the mental-model and caching costs bite, and how we decide per project.