Vaibhav Somani

Mental model Rate limiting answers a deceptively simple question: should this request be allowed right now?

Web Workers and Service Workers both run off the main thread, but they solve different problems.

Mental model: multiple possible futures Concurrent rendering lets React prepare a future UI without immediately committing it.

ResizeObserver closes a feedback loop ResizeObserver reports element size changes.

Mental model When a resource server receives an OAuth2 access token, it must answer one question before doing anything else: is this token valid, and what does it authorize?

Mental model: composition is the product Micro-frontends are not primarily about splitting code.

Mental model SameSite controls when the browser sends a cookie on cross-site requests.

Mental model GraphQL’s execution model is a tree walk.

Deterministic rendering means the same inputs produce the same UI output, independent of timing, machine, locale, random numbers, request order, and hydration path.

Browser memory leak detection is less about finding one magic number and more about proving that memory grows after repeated workflows when it should return to a stable baseline.

Mental model gRPC is RPC semantics layered on top of HTTP/2.

Task starvation is what happens when important browser work cannot get a turn on the main thread.

Mental model CSRF and XSS are both browser security problems, but they abuse different trust relationships.

Two of the most misunderstood parts of running Apache Kafka in production are how consumer group rebalancing works and what “exactly-once” actually guarantees.

SharedArrayBuffer gives multiple JavaScript agents access to the same memory.

When two replicas of the same data accept writes independently and then sync, something has to decide what the merged result is.

MutationObserver is a batch feed, not a free hook MutationObserver reports DOM changes after they happen.

Mental model: share the main thread with the user Time slicing is the renderer’s ability to split render work into smaller chunks so the browser can handle input, paint, and higher-priority tasks between chunks.

RabbitMQ gives you two capabilities that look simple on the surface and turn out to have a lot of depth: dead-letter queues for handling messages that cannot be processed, and message ordering for workloads that depend on sequence.

A detached DOM node is a node that is no longer connected to the document tree but is still retained by JavaScript or browser internals.

Almost everyone who works with distributed databases has heard the CAP theorem reduced to a slogan: “pick two of consistency, availability, and partition tolerance.”

Mental model: make impossible states unrepresentable Finite-state modeling is the practice of describing UI behavior as a set of named states and allowed transitions.

An idempotent UI action can be invoked more than once and still leave the application in the same intended state.

Layout thrashing happens when JavaScript repeatedly alternates between writing DOM or style changes and reading layout-dependent values.

Mental model Content Security Policy is a browser-enforced allowlist for what a page may load, execute, embed, connect to, and submit to.

Eventual consistency is a deal: you give up the guarantee that a read immediately reflects the latest write, and in exchange you get availability, lower latency, and horizontal scale.

Distributed locks are one of those primitives that look trivial until you deploy them.

Transferable objects are the difference between “send this data to a Worker” and “move ownership of this memory to a Worker.”

Garbage collection timing is one of the least deterministic parts of frontend performance.

Mental model Trusted Types is a browser enforcement layer that moves DOM XSS prevention from “remember to sanitize every string” to “dangerous DOM sinks reject plain strings.”

The problem of distributed atomicity A single database gives you atomic transactions for free: a transfer that debits one account and credits another either fully commits or fully rolls back.

The shape of a deadlock A deadlock is the concurrency equivalent of two people in a hallway, each stepping the same direction to let the other pass, forever.

The accessibility tree is the browser’s semantic projection of the page.

Mental model: preserve identity where the shape matches Reconciliation is the process of turning a previous UI tree and a next UI tree into the minimal set of renderer operations React cares to compute.

From declarative to executable SQL is declarative: you state what you want, not how to get it.

IndexedDB is a transactional object store IndexedDB is the browser’s built-in durable database for structured client data.

The critical rendering path is the sequence of browser work required to turn bytes into pixels.

Two answers to the same question Every storage engine has to answer one question: given a key, how do I find its value on disk quickly, and how do I keep that structure efficient as data changes?

Mental model DOM clobbering is a browser legacy behavior where elements with certain id or name attributes become properties on global objects like window, document, or forms.

Mental model: state is a projection Event sourcing on the frontend means the primary record of change is an append-only event stream, and the UI state is a projection derived from that stream.

OffscreenCanvas moves canvas rendering away from the main thread.

Two philosophies of data When a system stores data that multiple clients read and write, it must make promises about what they will see.

PerformanceObserver is the browser’s streaming interface for performance timeline entries.

ARIA live regions are a bridge between DOM mutation and assistive technology announcement queues.

Why isolation levels exist A database that ran every transaction one at a time would be trivially correct and uselessly slow.

Render-blocking resources are files the browser must fetch, parse, or execute before it can safely paint useful pixels.

What “zero downtime” actually requires Zero-downtime deployment means rolling out a new version of a service without any request failing because of the deployment itself.

Mental model Prototype pollution is a JavaScript object graph bug where attacker-controlled input writes properties onto Object.prototype or another shared prototype.

Why QUIC reinvented loss recovery HTTP/3 runs over QUIC, and QUIC runs over UDP.

The lifecycle is a deployment protocol A service worker is not just a background script.