TK
Back home

Writing

Notes on building things that ship.

Deep dives on frontend performance, architecture and putting AI into real products — written from what actually worked in production, with the code to back it up.

Frontend

A mental model for React Server Components that finally sticks

RSCs confuse people because the old client/server line moved. Here is the model that makes them click: where each component runs, what crosses the boundary, and the rules that keep you out of trouble.

9 min read
Accessibility

WCAG 2.1 AA in practice: a developer's field guide

Accessibility is not a checklist you bolt on at the end — it is a set of engineering decisions. A practical walk through the WCAG requirements that actually bite in real components: focus management, semantics, contrast, and screen-reader behaviour.

12 min read
Backend

Building fast, type-safe APIs with Fastify

Fastify is the Node framework I reach for when throughput and schema validation both matter. A tour of the patterns that make it shine: JSON-schema validation, the plugin/encapsulation model, typed routes, and hooks.

10 min read
Performance

Cutting a Next.js bundle by 89% without losing a feature

A disciplined, measurement-first approach to shrinking a bloated Next.js app — route-level code splitting, dynamic imports, barrel-file surgery and bundle analysis — that took first-load JS from ~1.1 MB to ~120 KB.

9 min read
Backend

Production-grade APIs with FastAPI

FastAPI gives you Pydantic validation, automatic OpenAPI docs and async performance in one coherent package. The patterns I use to take it from a toy endpoint to a production service: dependency injection, settings, and clean error handling.

10 min read
Architecture

Designing a 150-block page builder that doesn't collapse under its own weight

How I architected a drag-and-drop page builder with 150+ block types — a discriminated-union schema, a block registry, runtime validation, and a render path that stays fast as the catalog grows.

11 min read
Backend

Structuring a Django backend that scales

Django's batteries-included design is a gift and a trap. The patterns that keep a growing Django + DRF codebase maintainable: app boundaries, fat models vs service layers, query optimisation, and serializer discipline.

11 min read
AI

Designing a clean AI → human handoff in a booking platform

Shipping an AI assistant into a live booking product means designing the moment it steps aside. Here is the state machine, the streaming architecture, and the guardrails that make an AI agent safe to put in front of paying guests.

10 min read
Backend

Express.js patterns that survive past the first 10 routes

Express gives you almost no structure, which is why most Express codebases rot. The conventions I impose from day one: a layered architecture, async error handling that actually works, typed middleware, and centralised errors.

9 min read
Backend

SQL joins, finally visualized

INNER, LEFT, RIGHT and FULL joins explained with plain language and real queries. What each returns, the NULL behaviour that trips people up, and how to use LEFT JOIN to find missing rows.

9 min read
Engineering

package.json scripts you should be using

Your package.json scripts are an underused automation surface. Pre/post hooks, running scripts in series and parallel, passing args, and the conventions that make a repo easy for anyone to run.

7 min read
Backend

Docker for people who've been avoiding it

A gentle, practical intro to Docker. What a container actually is, images vs containers, a real Dockerfile explained line by line, and the handful of commands you need to be productive.

10 min read
Frontend

Debounce vs throttle (with real code)

Two techniques everyone confuses. What each does, the difference in one sentence, when to use which (search inputs vs scroll handlers), and copy-paste implementations.

7 min read
Backend

JWT authentication explained simply

What a JWT actually is, how token-based auth flows end to end, access vs refresh tokens, where to store them (and why localStorage is risky), and the mistakes that make JWT auth insecure.

10 min read
Frontend

Centering in CSS: every method, and when to use which

The eternal question answered for good. Centering horizontally, vertically, and both — with Flexbox, Grid, margin auto, and absolute positioning — plus which to reach for in each situation.

8 min read
Frontend

useEffect: the mistakes everyone makes

React's useEffect is the hook people misuse most. Missing dependencies, infinite loops, the cleanup function, race conditions in data fetching, and when you shouldn't use an effect at all.

10 min read
Frontend

async/await in JavaScript, finally explained

Promises, async, await and the pitfalls that trip everyone up — sequential vs parallel awaits, error handling with try/catch, and the forgotten-await bug that causes silent failures.

10 min read
Frontend

Zustand: a beginner's guide to React state without the boilerplate

A practical introduction to Zustand — the tiny, unopinionated state manager for React. Creating a store, reading and updating state, selectors to avoid re-renders, async actions, persistence, and when to reach for it over Context or Redux.

9 min read
Engineering

How to fix a Git merge conflict without panicking

Merge conflicts look scary and aren't. What a conflict actually is, how to read the <<<<<<< markers, resolving it step by step, and how to abort and start over if you get lost.

8 min read
Engineering

The 15 Git commands you'll actually use every day

A no-fluff reference for the Git commands that make up 95% of real work — staging, committing, branching, syncing, inspecting history — with the exact command for each everyday task.

9 min read
Engineering

The Complete Git Guide for Developers & DevOps Engineers

Everything you need to master Git — from your first commit to production-grade workflows, GitOps, CI/CD, security, internals and recovery. A beginner-to-advanced reference for developers, DevOps, platform and SRE engineers.

42 min read