Vaibhav Somani

In any event-driven system, the consumer will eventually receive the same event twice.

Every data pipeline is a chain of producers and consumers operating at different, time-varying speeds.

“Exactly-once” is the most misunderstood phrase in distributed systems.

Feature flags decouple deployment from release.

Mental model: one screen, two snapshots Tearing happens when different parts of the UI render from different versions of shared state at the same time.

The problem service discovery solves In a static world, service A calls service B at a hardcoded IP and port.

Two answers to one question Every deployment strategy is an answer to the same question: how do you replace running version N with version N+1 without breaking the users hitting your service right now?

The abstraction every process lives inside Every process on a modern OS runs inside a private virtual address space.

Containers are not a security boundary by default A container is not a virtual machine.

Why naive hashing breaks under scaling The simplest way to distribute keys across a set of N backend nodes is modulo hashing: pick a node with hash(key) % N.

What the sidecar promises The sidecar pattern attaches a helper container to a primary application container, sharing the same lifecycle, network namespace, and often storage.

What lock-free actually means “Lock-free” is one of the most abused terms in concurrent programming.

Layers are an implementation strategy A browser compositing layer is a rendered surface that can be moved, clipped, transformed, blended, and assembled with other surfaces.

The hidden tax on every system call A system call looks like an ordinary function call in your code, but it is anything but.

Trading exactness for scale Some questions are cheap to answer approximately and ruinously expensive to answer exactly.

Mental model: not all UI work deserves the same lane Scheduler priorities let a renderer decide which work should run now, which work can wait, and which work should be interrupted.

The problem they solve A server that handles thousands of concurrent connections faces a deceptively simple question: which sockets are ready for I/O right now?

When the hardware lies to you You write code that stores to one variable and then another.

Why copies are the enemy When a server streams a file to a socket, the naive approach involves a surprising amount of data movement.

Tree shaking is dead-code elimination for module graphs.

Picking a Serialization Format Is an Architectural Decision Every distributed system has to turn in-memory objects into bytes and back — for network calls, queues, caches, and persistence.

Offline conflict resolution is the set of rules that decides what happens when users make changes without a live connection and those changes meet other changes later.

The Integration Testing Gap You have two services: a consumer (say, a web BFF) and a provider (an orders API).

Virtual DOM diffing compares a previous tree of UI descriptions with a next tree and computes the host operations needed to update the real UI.

Rendering work has different prices When a page changes, the browser does not perform one generic “render” step.

When Text Is Not Enough Most application developers spend their careers parsing text: JSON bodies, HTTP headers, CSV files.

The Problem With Logs in a Microservice World In a monolith, a single request executes inside one process.

Mental model: sequential work hiding in a tree A render waterfall happens when work that could have run in parallel is discovered sequentially during rendering.

Code splitting is a budgeting tool.

Why Failover Is Harder Than It Looks A database failover sounds simple: the primary dies, a replica takes over, traffic resumes.

Why Schema Change Is the Hard Part of Backend Work Writing the first version of a schema is easy.

A distributed system that has never been deliberately broken is a system whose failure behavior is purely theoretical.

Consensus is the problem of getting a group of unreliable machines to agree on a single value — and to keep agreeing even as some of them crash, restart, and rejoin.

First Input Delay measures the delay between a user’s first interaction and the browser’s ability to start running the corresponding event handler.

Structural sharing is the technique of creating a new version of a data structure by copying only the parts that changed and reusing the rest.

CRDTs are data structures designed so replicas can accept local changes independently, exchange updates later, and converge without a central conflict resolver.

Most distributed systems assume failures are honest: a node either works correctly or it crashes and stops.

The GPU is not a magic fast path “Use GPU acceleration” usually means “make the browser animate by compositing existing layers instead of repainting pixels on the CPU.”

Mental model: make server HTML interactive without replacing it Hydration is the client-side process that takes server-rendered HTML and attaches the JavaScript component model to it.

Networks fail in the most inconvenient way possible: not by losing the request, but by losing the response.

Mental model: a boundary is a latency contract A Suspense boundary defines what part of the UI may wait and what the user sees while it waits.

Dynamic import() is both a language feature and a bundler signal.

Mental model Cache invalidation is the discipline of making cached data stop being used when it no longer matches the source of truth.

A cache exists to answer a read faster than the source of truth can.

Two users open the same record, both edit it, both save.

Interaction to Next Paint measures page responsiveness across real user interactions.

There are only two hard things in computer science, the joke goes, and cache invalidation is one of them.

Immutable data patterns update state by creating new values instead of modifying existing values in place.

Mental model stale-while-revalidate serves a cached response immediately while a refresh happens in the background.

An API gateway is the front door to your backend, and the two responsibilities that most determine whether that door holds up under load are throttling and caching.