Skip to content

Written while the work was hot.

Technical write-ups from projects in flight — the decision, what it cost, and what we would do differently. No listicles, no reposted release notes.

43 posts
  1. Staff-Level React Architecture and Modern Refactoring: A Playbook for React 19.xA senior engineer's field guide to React 19.3: useActionState, useOptimistic, the React Compiler, ViewTransition, Fragment refs, and how to review async React code the way a staff engineer would.ReactPerformance33 min
  2. The Senior Frontend Engineer's Field Guide to the DOM and JavaScript Engine InternalsA hands-on, verified tour of what actually happens between your JavaScript and the pixels on screen: the rendering pipeline, live vs static collections, the event loop's real ordering guarantees, layout thrashing, Web Components, and a working virtualized 100,000-row data grid — built and checked in a real browser.JavaScriptDOM41 min
  3. The Senior Frontend Engineer's Field Guide: Building an Enterprise Next.js 16 and React 19 Application From ScratchA hands-on, command-by-command build of an enterprise Next.js 16 and React 19 application, with every config flag, cache directive, security boundary and TypeScript pattern explained and empirically verified against the real 16.3.6 build — for a senior frontend interview with a week to prepare.ArchitectureReact94 min
  4. The Senior Frontend Engineer's Field Guide to Advanced CSS and Tailwind v4A verified, hands-on tour of CSS for senior engineers: the rendering pipeline, cascade layers and the counterintuitive !important inversion, subgrid, container queries, :has() as a state machine, the Popover API, scroll-driven animations, and Tailwind v4's Rust engine — with a real capstone app built, tested, and debugged in a live browser.CSSArchitecture42 min
  5. The Frontend Engineer's LeetCode Blueprint, Part 5: The Grandmaster's ToolkitSmall constraints like N ≤ 16 are a signal, not a gift. The finale covers bitmask backtracking with N-Queens, bitmask DP for shortest-path-visiting-all-nodes, and the 60-minute Toptal/Codility survival protocol.JavaScriptFrontend11 min
  6. The Frontend Engineer's LeetCode Blueprint, Part 4: The Dynamic Programming Vault & String AutomatauseMemo and Reselect are dynamic programming with different names. Part 4 covers top-down versus bottom-up DP, the 0/1 knapsack pattern, Edit Distance, and a Trie-backed Word Search II solver.JavaScriptFrontend12 min
  7. The Frontend Engineer's LeetCode Blueprint, Part 3: Trees, Graphs and Solution SpacesThe virtual DOM, AST transpilation and bundler dependency resolution are all tree and graph traversal in production. Part 3 covers post-order tree recursion, topological sort and binary search on the answer space.JavaScriptFrontend12 min
  8. The Frontend Engineer's LeetCode Blueprint, Part 2: The Pointer & Memory PlaygroundReact Fiber and the DOM tree are linked lists in disguise. Part 2 covers fast-and-slow pointers, in-place reversal, the monotonic stack and a from-scratch LRU cache built on a doubly linked list plus hash map.JavaScriptFrontend11 min
  9. The Frontend Engineer's LeetCode Blueprint, Part 1: The Linear GauntletFrontend habits like map/filter/reduce chains fail LeetCode's hidden test suites. Part 1 covers V8 array internals, two pointers and sliding windows, with worked solutions for 3Sum, Minimum Window Substring and Trapping Rain Water.JavaScriptFrontend12 min
  10. Push Notifications, Deep Linking and Device APIs in React Native: The Seams Nobody DocumentsPush notifications, deep linking and device detection each have a tidy quick-start page. In production they are one feature, and the bugs live in the seams: the cold-start race between a notification tap and a router that has not mounted yet, the channel you cannot edit after creation, and the URL you should not trust just because it arrived in a push payload.EngineeringReact Native11 min
  11. The Senior Frontend Engineering Blueprint, Part 8: Testing the App Router with Vitest, Playwright and Visual RegressionA green Vitest suite that calls render() on an async Server Component is either a compile error or a false positive. Here is the real testing pyramid for the Next.js App Router — Vitest, MSW v2, mocked Prisma, and a Playwright setup project that logs in once for the whole suite.EngineeringFrontend13 min
  12. The Senior Frontend Engineering Blueprint, Part 7: Building a Linear-Time Query Language ParserEvery product with a power-user search box eventually needs a real query language, and reaching for new RegExp(userInput) is how you end up hand-rolling a vulnerability. Here is a filter-query DSL built from a sticky-regex tokenizer, a recursive-descent parser, and a recursive Zod schema — with a ReDoS stress test to prove the O(N) claim.JavaScriptArchitecture11 min
  13. The Senior Frontend Engineering Blueprint, Part 6: Regex Engines, ReDoS and Defending Untrusted InputA validation regex that passes code review can still be an O(2^n) time bomb. Here is how V8's regex engine actually backtracks, the exact shape of pattern that wedges it, and the rest of the perimeter — Zod pipelines, parameterised SQL, DOMPurify, CSP — that a Next.js app needs around untrusted input.JavaScriptPerformance12 min
  14. The Senior Frontend Engineering Blueprint, Part 5: Edge Proxies, Auth.js Credentials and a Server-Side Data Access LayerA redirect from the edge feels like security, but an attacker can skip it entirely by calling your Server Action directly. Here is the request pipeline Next.js 16 actually runs, a Credentials-based Auth.js v5 setup with Prisma and RBAC, and the data access layer that is the only boundary that actually holds.ArchitectureEngineering13 min
  15. The Senior Frontend Engineering Blueprint, Part 4: Virtualising 50,000 Rows Without Losing AccessibilityRendering 50,000 DOM rows is a real performance problem, and virtualising them away is a real accessibility problem if you stop at the transform. Here is a generic VirtualList built from scratch, with the ARIA contract most implementations skip.ArchitectureReact10 min
  16. The Senior Frontend Engineering Blueprint, Part 3: Parallel Routes, TanStack Query and a Tailwind v4 Design SystemPart 3 of an eight-part build: the file-system pattern behind Instagram-style shareable modals, prefetching TanStack Query on the server and hydrating it on the client without a duplicate fetch, a Tailwind v4 @theme design system with a CVA button primitive, and why Core Web Vitals numbers stay aspirational until you actually reserve the layout space.ReactPerformance15 min
  17. The Senior Frontend Engineering Blueprint, Part 2: Server Components, Server Actions and Optimistic UIPart 2 of an eight-part build: where the Server/Client boundary actually goes, static pages that still regenerate themselves, the static-shell-plus-streaming-hole trade-off, and a webhook handler that verifies its own signature correctly.ArchitectureReact12 min
  18. The Senior Frontend Engineering Blueprint, Part 1: Docker, Strict TypeScript, and a Real Prisma Data LayerMost 'add a database' tutorials stop at new PrismaClient() and quietly ship a connection-pool leak the first time someone edits a file in dev. Part 1 of an eight-part series builds the foundation properly: Docker Postgres, a genuinely strict tsconfig, branded types, and a Prisma layer with cursor pagination and real transactions.ArchitectureTypeScript8 min
  19. Ads and One-Time Purchases in React Native: A Working Guide to RevenueCat, AdMob and the Failures That Cost Money SilentlyThe free app with a remove-ads purchase is the most common indie model there is, and almost every guide to it stops at the SDK calls. This is the rest: consent ordering, entitlement resolution, interstitial pacing, and the four ways an integration earns nothing while looking perfectly healthy.EngineeringReact Native16 min
  20. Automating App Store and Play Submissions: What the APIs Will Do, What They Silently Refuse, and the Guideline That Punishes SuccessShipping thirty-four apps through two stores from a terminal taught me that the build is the easy fifth of the problem. The hard parts are a write that returns 200 and stores nothing, a screenshot rejected after it uploads, and a spam guideline that gets stricter the better your automation works.AutomationDevOps13 min
  21. Self-Hosted SSO: Wiring authentik to Next.js 16 and Auth.js v5, Including the Logout That Does Not Log OutPutting an identity provider you own in front of your own applications is a weekend of work and a decade of consequences. Here is the whole mechanism — the discovery document, the id_token, the encrypted session cookie — and the single logout that Auth.js cannot perform at all.EngineeringSecurity13 min
  22. Self-Hosting Coolify: Migrating Real Apps, Wiring Cloudflare and What Build-on-Push Actually DoesCoolify gives you a Heroku-shaped button on a box you own. It is worth it — but only once you understand that you have not bought a platform, you have bought a generator for Docker and Traefik configuration, and it is Docker and Traefik that will page you.EngineeringDevOps13 min
  23. Building a Personal AI OS: File Watchers, Local IPC and Daemonised AgentsA terminal agent is a tool you visit. An AI OS is a set of small daemons that react to things happening on your machine. The difference is not the model — it is the event bus, the queue, and the discipline to keep every piece boring.AutomationAI8 min
  24. React Compiler Internals: How Auto-Memoisation Works, and Where It Gives UpThe compiler does not memoise your components by wrapping them in `memo`. It rewrites them into a cache-slot machine, and it does it only when it can prove your code follows the rules. Here is the proof it needs, and what breaks it.CompilersReact7 min
  25. Autonomous CI/CD: Letting an Agent Triage the Build Without Letting It ShipMobile release engineering is mostly the same six failures on repeat — a provisioning profile, a Gradle version, a flaky simulator. That is exactly the shape of work an agent is good at, provided you are ruthless about which half of the pipeline it can touch.AutomationCI/CD7 min
  26. Context Window Engineering: Compaction, Retrieval and Why Long Sessions DegradeA million-token window did not solve the problem, it moved it. Attention is not uniform, irrelevant context actively costs accuracy, and the skill that matters now is deciding what an agent is allowed to see.ArchitectureAI8 min
  27. Swift 6 Strict Concurrency and Kotlin Multiplatform: Two Ways to Not Have a Data RaceSwift 6.2 inverted its concurrency defaults — main actor by default, escape on purpose — and it changed migration from a slog into something tractable. Meanwhile KMP shares the logic that would otherwise be written twice. Here is how the two fit together.SwiftConcurrency6 min
  28. A green build is not a verificationSix apps passed type checking, bundling and compilation. Four had no working core feature and all six crashed before their first frame. Here is the gate we use instead.7 min
  29. Local-First Sync Engines: CRDTs, SQLite and Where the Write Boundary GoesOffline-first is not a caching problem, it is a distributed systems problem you moved onto a phone. The real decision is not which CRDT library — it is where writes become authoritative, and every sync engine answers that differently.ArchitectureEngineering8 min
  30. Next.js in 2026: The Flight Wire Format, Cache Components and Tag InvalidationReact Server Components do not send HTML and they do not send JSON. Here is what actually goes over the wire, how Cache Components replaced three separate flags, and the invalidation race that a single-argument `revalidateTag` used to hide.ArchitectureReact8 min
  31. React Native's New Architecture: JSI, Fabric and the Bridgeless TurboModuleThe bridge is gone — removed outright, not deprecated. What replaced it is a set of C++ abstractions with real performance characteristics, and a new generation of native modules that compile straight to JSI bindings.ArchitecturePerformance7 min
  32. Hardening Agent Sandboxes: MicroVMs, gVisor and WebAssembly for Untrusted CodeAn AI agent running shell commands is an arbitrary code execution primitive you installed on purpose. Here is the isolation ladder — container, gVisor, Firecracker, WebAssembly — what each one actually stops, and what it costs per sandbox.AIAgents7 min
  33. Deterministic Multi-Agent Orchestration: Escaping the Infinite ReAct LoopAutonomous coding agents fail in a predictable way: context poisoning inside a freeform reason-act loop. The fix is not a better prompt — it is a finite state machine with programmatic gates, scoped tool access per phase, and automatic rollback.AutomationArchitecture9 min
  34. Senior Frontend Interview Prep, Part 7: Specification Quirks and CoercionThe last ten questions in the JavaScript volume: ToPrimitive traced step by step, why `[] == ![]` is true, the four equality algorithms, `NaN` and `-0`, BigInt, and the ASI rule that silently eats a return value.JavaScriptFrontend9 min
  35. One Postgres container, not nineEvery application on our infrastructure shares a single Postgres instance. Here is why per-app database containers are a false economy, and the protocol that makes sharing safe.6 min
  36. Senior Frontend Interview Prep, Part 6: Async, Promises, Workers and Shared MemoryFifteen questions on concurrency: promise internals, what `await` desugars to, cancellation that actually cancels, transferables and zero-copy, `SharedArrayBuffer` under cross-origin isolation, and a task pool you can paste into production.ConcurrencyJavaScript12 min
  37. Senior Frontend Interview Prep, Part 5: The Object Model, Prototypes and MetaprogrammingFifteen questions on what an object really is: prototype chains, property descriptors, what `class` desugars to, prototype pollution with a working exploit, and why `Proxy` and private fields do not get along.JavaScriptFrontend13 min
  38. Senior Frontend Interview Prep, Part 4: Scope, Closures and the Temporal Dead ZoneFifteen questions on execution contexts and environment records: what the TDZ actually is, why `let` in a loop works, how `bind` is implemented, and why one `eval` deoptimises every identifier around it.JavaScriptFrontend11 min
  39. Senior Frontend Interview Prep, Part 3: The Event Loop, Scheduling and Paint TimingFifteen questions on what actually runs next: microtasks against macrotasks, the rendering opportunity, libuv's phases, the nextTick ordering rule that has an exception nobody mentions, and how to break up a long task without hurting INP.JavaScriptBrowser10 min
  40. Senior Frontend Interview Prep, Part 2: Memory, Garbage Collection and Leak TopologiesFifteen interview questions on the V8 heap: generational collection, the scavenger, concurrent marking and write barriers, and the five leak shapes behind almost every 'the tab is using two gigabytes' report.MemoryJavaScript12 min
  41. Senior Frontend Interview Prep, Part 1: Inside the JavaScript EngineFifteen interview questions on how V8 turns source text into machine code — tiers, hidden classes, inline caches, elements kinds and deoptimisation — with the answers verified against a live engine.JavaScriptV812 min
  42. Cracking the Staff & Architect Frontend Interview: The Battle-Tested PlaybookStaff and architect interviews are not coding tests — they are risk-assessment conversations. Here are the seven technical pillars that decide the outcome, with the mechanics underneath each one.JavaScriptArchitecture19 min
  43. Why this site has no cookie bannerNo analytics, no pixels, no session recorder. The public pages set zero cookies, which means there is nothing to ask consent for — and one fewer thing between a reader and the content.5 min