Articles
Browse by series or pick an article to read.
190 articles across 22 topics
Critical Rendering Path
The browser rendering pipeline from DOM to pixels.
- Critical Rendering Path: Rendering Pipeline OverviewAn end-to-end walkthrough of Chromium's RenderingNG pipeline — from DOM and CSSOM construction through style, layout, paint, commit, raster, composite, and draw — showing how each stage's inputs and outputs enable 60fps rendering.
- Critical Rendering Path: DOM ConstructionHow the HTML parser's state machine builds the DOM tree, including error recovery, the preload scanner's ~20% performance boost, and the blocking chain between scripts, stylesheets, and DOM construction.
- Critical Rendering Path: CSSOM ConstructionHow browsers tokenize and parse CSS into the CSSOM tree, why stylesheets are render-blocking, and how the cascade's dependency on the full rule set creates the CSS-JS-DOM blocking chain that shapes page load performance.
- Critical Rendering Path: Style RecalculationHow browsers resolve final CSS values for every element through rule indexing, right-to-left selector matching with Bloom filters, the CSS Cascade Level 5 algorithm, and value computation — plus optimization strategies to reduce recalc cost.
- Critical Rendering Path: Layout StageHow Chromium's LayoutNG turns styled elements into pixel-accurate boxes — Fragment Tree output, constraint propagation, formatting contexts, the box model, and the `contain` / `content-visibility` levers that bound layout cost.
- Critical Rendering Path: PrepaintHow Chromium's Prepaint stage walks the LayoutObject tree to build the four property trees (transform, clip, effect, scroll) and compute paint invalidations — the foundation that makes compositor-driven scrolling and animations O(affected nodes) instead of O(layers).
- Critical Rendering Path: Paint StageHow the Paint stage records drawing instructions into display lists rather than producing pixels, covering display items, paint chunks, the stacking context algorithm, and the CompositeAfterPaint architecture shift in Chromium M94.
- Critical Rendering Path: CommitHow Chromium's compositor commit performs a blocking handoff of property trees and display lists from the main thread to the compositor thread, enabling the dual-tree architecture that decouples rasterization from JavaScript.
- Critical Rendering Path: LayerizeHow PaintArtifactCompositor groups paint chunks into compositor layers, balancing GPU memory against rasterization cost through merge heuristics, overlap testing, and direct compositing reasons like will-change and animations.
- Critical Rendering Path: RasterizationHow Chromium turns recorded paint commands into GPU textures through tiling, the pending/active/recycle three-tree compositor, priority-binned rastering, out-of-process rasterization, and Skia's Ganesh-to-Graphite migration.
- Critical Rendering Path: CompositingHow Chromium's compositor thread assembles rasterized layers into compositor frames using the three-tree architecture, property trees, and async input routing — enabling smooth scrolling and animations even when JavaScript blocks.
- Critical Rendering Path: DrawThe final rendering pipeline stage where Chromium's Viz process aggregates compositor frames from multiple renderer processes, translates draw quads into GPU commands via Skia, and presents pixels to the display.
JavaScript Runtime Internals
V8, Node.js, event loops, and browser runtime architecture.
- V8 Engine Architecture: Parsing, Optimization, and JITV8's four-tier compilation pipeline from Ignition interpreter to TurboFan optimizer — how hidden classes, inline caches, and speculative optimization achieve near-native JavaScript performance, plus Orinoco's concurrent garbage collection strategy.
- Browser Architecture: Processes, Caching, and ExtensionsChromium's multi-process architecture mapped end-to-end: renderer sandboxing, site isolation, GPU process separation, the DNS-to-disk caching hierarchy, speculative loading, and extension content script injection.
- Browser Event Loop: Tasks, Microtasks, Rendering, and Idle TimeA spec-accurate breakdown of the browser event loop covering task queue selection, microtask checkpoints, rendering opportunities, and Chromium's Blink scheduler — focused on latency and frame-budget trade-offs.
- Node.js Runtime Architecture: Event Loop, Streams, and APIsUnderstand the runtime boundaries that matter at scale in Node.js — V8's JIT tiers and GC, libuv's event loop and thread pool, stream backpressure, Buffers, and ABI-stable native addon interfaces.
- libuv Internals: Event Loop and Async I/OA deep dive into libuv's event loop phases, kernel polling vs. thread pool I/O, handle and request abstractions, and the io_uring integration that underpins Node.js's non-blocking architecture.
- Node.js Event Loop: Phases, Queues, and Process ExitHow Node.js schedules work across libuv's six phases, microtask and nextTick queues, and the thread pool — with precise ordering rules for timers, setImmediate, Promises, and process exit conditions.
- JavaScript Event Loop: A Foundational OverviewA foundational map of how JavaScript runtimes schedule async work — the ECMA-262 contract (Jobs, agents, the four host hooks), the universal mental model (stack drains then microtasks drain then next task), where the browser (WHATWG HTML 8.1.6) and Node.js (libuv phases + nextTick) diverge, and the patterns and footguns that fall out.
Web Security & Authentication
Auth foundations, browser defenses, OAuth/OIDC, and security telemetry.
- Authentication Foundations: Sessions, Tokens, and TrustSessions vs. JWTs, password hashing with Argon2id, refresh-token rotation, WebAuthn passkeys, and RBAC vs. ABAC — the core authentication and authorization trade-offs a senior engineer needs to design a real system.
- Web Application Security ArchitectureDefense-in-depth for web apps in 2026 — strict CSP, Trusted Types, passkeys, Argon2id, SSRF defenses, and the OWASP Top 10:2025, with concrete patterns at each boundary.
- CSRF and CORS Defense for Modern Web ApplicationsThreat models, specification mechanics, and defense-in-depth implementation for CSRF and CORS — SameSite cookies (RFC 6265bis), CSRF tokens, origin verification, Fetch Metadata, and CORS preflight, with the misconfigurations attackers actually exploit.
- OAuth 2.0 and OIDC Flows: Authorization Code to PKCEWalk through OAuth 2.0 authorization flows and OpenID Connect from first principles — covering PKCE, token lifecycle, client types, and why the implicit flow is deprecated in OAuth 2.1.
- CSP Violation Reporting Pipeline at ScaleHow browsers emit CSP violation reports, what each transport (report-uri, report-to, Reporting-Endpoints, SecurityPolicyViolationEvent) actually does, and a fire-and-forget WebFlux + Kafka + Valkey + Snowflake reference design that absorbs 50k baseline and 500k+ burst RPS.
- OWASP Top 10: Web Application Security RisksA practical walkthrough of the OWASP Top 10:2025 — each risk category explained with vulnerability patterns, code-level prevention techniques, and the defense-in-depth controls that matter most.
Networking Protocols
DNS, TLS, HTTP/2, and HTTP/3 deep dives.
- DNS Resolution Path: Stub to Recursive to AuthoritativeTracing a DNS query from stub resolver through recursive resolver to the authoritative chain — with packet-level detail on iterative resolution, caching decisions, glue records, and common failure modes like SERVFAIL.
- DNS Records, TTL Strategy, and Cache BehaviorEvery DNS record type explained with its constraints and design rationale, plus TTL strategies for migrations, failover, and caching — and why "DNS propagation" is really just cache expiry across resolver layers.
- DNS Security and Privacy: DNSSEC, DoH, and DoTTwo orthogonal layers of DNS security explained — DNSSEC for cryptographic authenticity (chain of trust, keys, NSEC vs NSEC3) and DoH/DoT/DoQ plus ECH for confidentiality, with deployment trade-offs, current adoption numbers, and enterprise patterns.
- DNS Troubleshooting PlaybookSymptom-driven decision trees for diagnosing SERVFAIL, NXDOMAIN, timeouts, and propagation delays — with dig/delv/kdig command recipes, DNSSEC debugging workflows, and layer-by-layer isolation techniques.
- TLS 1.3 Handshake and HTTPS HardeningHow TLS 1.3 achieves 1-RTT handshakes through speculative key shares, mandates forward secrecy via ephemeral (EC)DHE, and what production HTTPS hardening requires — from HSTS preload and certificate transparency to 0-RTT replay risks.
- HTTP/1.1 to HTTP/2: Bottlenecks, Multiplexing, and What Stayed BrokenWhy HTTP/1.1's head-of-line blocking and header redundancy forced six connections per origin, how HTTP/2's binary framing, HPACK, and stream multiplexing fixed the application layer, and which TCP-layer constraints still motivate HTTP/3.
- HTTP/3 and QUIC: Transport Layer RevolutionHow QUIC keeps per-stream loss recovery from blocking unrelated streams, fuses TLS 1.3 into the transport handshake for 1-RTT (and risky 0-RTT) data, survives network changes via Connection IDs, and how browsers actually discover HTTP/3 in production.
Browser APIs & Accessibility
DOM, custom elements, observers, workers, storage, fetch, and accessibility.
- DOM API Essentials: Structure, Events, Observers, CancellationWhy querySelector lives on Element, what live versus static collections cost, how events propagate (and retarget across shadow boundaries), where every observer fires in the rendering pipeline, and why AbortSignal has quietly become the unified cancellation primitive for the whole DOM.
- Web Components: Custom Elements, Shadow DOM, and practical boundariesA senior-level tour of Custom Elements, Shadow DOM, templates and slots, lifecycle semantics, styling and accessibility at the encapsulation boundary, form association, and framework interoperability — with clear criteria for when standards-native components earn their complexity.
- Intersection Observer API: visibility without scroll listenersHow Intersection Observer defers visibility work to the browser, what root, rootMargin, scrollMargin, and thresholds actually mean, when callbacks fire in the rendering pipeline, the cross-origin and V2 (trackVisibility) caveats, and when to reach for a different API instead.
- Web Workers and Worklets for Off-Main-Thread WorkDedicated, Shared, and Service Workers move general-purpose JavaScript off the main thread via message passing. Paint, Animation, and Audio Worklets hook directly into the browser's rendering pipeline. This article covers worker lifecycle, structured clone vs transferable objects, SharedArrayBuffer with cross-origin isolation, the current production reality of each worklet, and a decision tree for picking the right primitive.
- Fetch, Streams, and AbortControllerHow the Fetch, Streams, and AbortController standards compose into a single network-data system in modern browsers — request lifecycle, automatic backpressure, and cancellation that propagates through entire pipelines.
- Browser Storage APIs: localStorage, IndexedDB, and BeyondBrowser-side persistence from localStorage through IndexedDB, OPFS, and the Cache API — comparing quota models, transaction semantics, threading guarantees, and eviction behavior under the unified WHATWG Storage Standard.
- Service Workers and Cache APIOffline-first web architecture using the Service Worker lifecycle, Cache API storage strategies, and fetch interception patterns — from precaching and stale-while-revalidate to safe version updates and background sync.
- Accessibility Testing and Tooling WorkflowA layered accessibility-testing workflow for senior engineers — what eslint-plugin-jsx-a11y, axe-core, Pa11y, Lighthouse, and screen-reader passes each catch, how to gate CI on them without flakes, and where human judgement is irreducible.
- WCAG 2.2: A Practical Guide for Senior EngineersWCAG 2.2's nine new success criteria, the practical implementation patterns that satisfy them (semantic HTML, ARIA, focus management, accessible authentication), the testing strategy that actually works (automation + manual + screen readers), and the 2026/2030 enforcement timeline under ADA Title II and the European Accessibility Act.
Frontend Architecture Patterns
Micro-frontends, rendering strategies, state management.
- Frontend Architecture at Scale: Boundaries, Ownership, and Platform GovernanceHow senior teams structure large UI systems: explicit domain boundaries, contract-first integration, release models, monorepo versus polyrepo tradeoffs, and the governance patterns that keep autonomy from turning into chaos.
- Micro-Frontends Architecture: Composition, Isolation, and DeliveryWhen micro-frontends pay off, how composition and isolation actually work at runtime — Module Federation, Web Components, edge fragments — and the failure modes you have to plan for before splitting your frontend.
- Rendering Strategies: CSR, SSR, SSG, and ISRA thorough comparison of CSR, SSR, SSG, and ISR — their mechanics, performance profiles, failure modes, and design trade-offs — plus modern hybrids like streaming SSR, islands architecture, and Partial Prerendering.
- State Management Patterns: Boundaries, Ownership, and ConsistencyA staff-level guide to frontend state: where truth lives, how to split local, global, and server-backed concerns, cache invalidation and optimistic updates, synchronization costs, and pragmatic tool-selection heuristics without framework debates.
- Frontend Data Fetching Patterns and CachingServer-state patterns for the browser — transport choice (REST / GraphQL / gRPC-Web / Connect / tRPC), request deduplication, stale-while-revalidate, normalized vs per-query caches, Suspense + use(), RSC streaming, optimistic updates with rollback, real-time channels (SSE / WebSocket / WebTransport), prefetch and idempotent retry — grounded in RFC 9110 / 9111 / 9113 / 9114 and the current defaults of TanStack Query, SWR, Apollo, Relay, and RTK Query.
- CSS Architecture Strategies: BEM, Utility-First, and CSS-in-JSComparing BEM, utility-first (Tailwind v4), CSS-in-JS, and CSS Modules as scaling strategies — analyzing their trade-offs around specificity, dead code, coupling, and how modern CSS features like @layer, @scope, and :has() are shifting the landscape.
- Component Architecture Blueprint for Scalable UIA layered React component architecture — SDK abstractions, Primitives/Blocks/Widgets boundaries, dependency injection via Context, and lint-enforced layering — for testability and framework migration.
Web Performance Optimization
Core Web Vitals, JS/CSS/image optimization.
- Web Performance Infrastructure: DNS, HTTP/3, CDN, Compression, OriginHow DNS service binding, HTTP/3 + QUIC, CDN edge caching, compression, and origin caching combine to put TTFB under 200 ms and keep 80%+ of bytes off origin — with the trade-offs that decide each lever.
- JavaScript Performance Optimization for the WebCovers the browser's script loading pipeline, long-task management with scheduler.yield(), code splitting and tree shaking, and Web Workers — all focused on keeping the main thread responsive and improving INP.
- CSS and Typography Performance OptimizationA deep dive into CSS delivery optimization, critical CSS extraction, containment properties, and font loading strategies — covering WOFF2, subsetting, variable fonts, and metric overrides to eliminate layout shifts and improve Core Web Vitals.
- Image Performance Optimization for the WebDeep guide to web image optimization: AVIF/WebP/JPEG XL trade-offs, the srcset+sizes selection algorithm, LCP-aware loading attributes (fetchpriority, decoding, loading), and build-time vs CDN delivery.
- Core Web Vitals Measurement: Lab vs Field DataA practical guide to measuring Core Web Vitals with lab tools, field data (RUM), and the web-vitals library, including metric-specific diagnostics for LCP, INP, and CLS and patterns for production RUM pipelines.
- Web Performance Optimization: Overview and PlaybookA playbook-style overview of web performance optimization across infrastructure, JavaScript, CSS, images, and fonts — with quick reference tables, Core Web Vitals thresholds, and links to each detailed article in the series.
Design Systems & React
Design system adoption, tokens, governance, scaling, and React architecture patterns.
- Design System Adoption: Foundations and GovernanceA practical framework for launching, governing, and scaling design systems — business case, sponsorship, team and governance models, tokens-first foundations, accessibility baseline, contribution and deprecation playbooks, and the adoption metrics that prove the system is working.
- Design Tokens and Theming ArchitectureEverything about design tokens — the three-tier taxonomy (primitive, semantic, component), the W3C DTCG format, naming conventions, multi-platform transformation pipelines with Style Dictionary, and theming architecture for dark mode and multi-brand.
- Component Library Architecture and GovernanceCompound component APIs, controlled/uncontrolled patterns, SemVer governance, federated contribution models, and quality gates for building React component libraries that teams actually adopt.
- Design System Implementation and ScalingEngineering patterns for enterprise design systems — hybrid architecture with platform-agnostic tokens, codemod-driven migrations, tree-shakeable distribution, usage analytics, and version compatibility strategies.
- React Hooks Fundamentals: Rules, Core Hooks, and Custom HooksA ground-up guide to React Hooks covering the call-order linked list model, core hooks like useState, useEffect, useRef, useMemo, and useCallback, plus patterns for building composable custom hooks.
- React Rendering Architecture: Fiber, Lanes, Streaming SSR, and RSCHow React renders under the hood — the Fiber reconciliation engine, lane-based priority scheduling, streaming SSR with Suspense, React Server Components stabilized in React 19, and the React Compiler released as v1.0 in late 2025.
- React Hooks Advanced Patterns: Specialized Hooks and CompositionDeep dive into React's specialized hooks — useTransition, useDeferredValue, useLayoutEffect, useSyncExternalStore, useInsertionEffect, useId, and the React 19 use API — explaining the specific architectural problems each one solves.
- React Performance Patterns: Rendering, Memoization, and SchedulingPractical patterns for keeping React apps fast — understanding the render pipeline, applying memo / useMemo / useCallback correctly, leveraging concurrent features like useTransition, virtualizing large lists with react-window v2, and profiling with React DevTools.
Frontend System Design
Rendering, client performance, state, and frontend system design exercises.
- Modern Rendering Architectures: RSC, Streaming, Islands, and ResumabilityHow modern frameworks compose static, server-streamed, and client-only rendering inside one page — React Server Components, Suspense streaming, islands architecture, Partial Prerendering, and Qwik resumability — with a decision framework grounded in INP and bundle cost.
- Image Loading OptimizationHow to deliver images on the web without trading LCP for CLS or bandwidth for fidelity — native lazy loading, responsive images, AVIF/WebP negotiation, fetchpriority, preload, and the layout-shift mechanics behind width/height.
- Bundle Splitting StrategiesRoute-based, component-level, vendor, and module-federation splitting for shrinking initial JavaScript payloads, with Webpack, Vite, and esbuild configurations, resource-hint sequencing, and HTTP/2 chunk-count trade-offs.
- Virtualization and WindowingRender large lists efficiently by drawing only visible items — fixed-height, variable-height, and DOM recycling approaches, GPU-accelerated positioning, accessibility constraints, and the CSS content-visibility alternative that preserves find-in-page.
- Client Performance MonitoringCapture real user performance with Core Web Vitals (LCP, INP, CLS), browser Performance APIs, and Real User Monitoring — including sampling strategies, attribution debugging, and reliable beacon transmission.
- Client State ManagementMatch the tool to the state category: TanStack Query for server state, useState/Zustand for UI state, React Hook Form for forms, and URL parameters for shareable state — with trade-offs for each.
- Real-Time Sync ClientClient-side architecture for real-time sync covering WebSocket, SSE, and long polling transports, connection resilience with exponential backoff, conflict resolution via OT and CRDTs, and state reconciliation patterns drawn from Figma, Notion, and Linear.
- Offline-First ArchitectureBuild apps that work without a network — covering IndexedDB, OPFS, Service Workers, sync queues, and conflict resolution via CRDTs and OT, with lessons from Figma, Notion, and Linear.
- Multi-Tenant Pluggable Widget FrameworkArchitectural decisions behind multi-tenant pluggable widget systems like VS Code extensions and Figma plugins — covering module loading (Module Federation 2.0, SystemJS), sandboxing (iframe, Shadow DOM, WASM), registry design, and tenant-aware orchestration.
- Design a Rich Text EditorHow modern rich text editors actually work — document models (ProseMirror, Slate, Lexical, Quill), contentEditable trade-offs, IME-safe input handling, and real-time collaboration via OT and CRDTs, with the production patterns used by Google Docs, Figma, Notion, Linear, and Meta.
- Design an Infinite FeedDesigning an infinite feed: keyset pagination, IntersectionObserver-driven loading, virtualization for bounded DOM, memory management, and the ARIA feed pattern — with concrete trade-offs and citations.
- Design a Drag and Drop SystemBrowser APIs, architectural patterns, and accessibility requirements behind production drag-and-drop systems. Covers HTML5 DnD quirks, Pointer Events unification, keyboard alternatives, and how libraries like dnd-kit and react-dnd differ.
- Design a Form BuilderSchema-driven form generation with JSON Schema and TypeScript-first validators, the state, validation, conditional, and persistence patterns behind production form builders, and how Typeform, Form.io, JSON Forms, and the React Hook Form + Zod stack actually compose.
- Design a Data GridArchitectural patterns for high-performance data grids: virtualization strategies, column pinning, the headless vs full-featured trade-off, and what production grids do to render millions of rows at 60 fps.
- Design a File UploaderHow to design a production-grade web file uploader: chunked uploads, the tus resumable protocol, presigned direct-to-storage flows, browser memory limits, XHR vs fetch progress, magic-byte validation, and the architectures behind Dropbox, Google Drive, S3 multipart, and Slack.
Distributed Systems Core
CAP, consensus, time, failure modes, rate limiting, circuit breakers.
- Consistency Models and the CAP TheoremThe CAP theorem demystified, PACELC's latency–consistency trade-off, and the full consistency spectrum from linearizability to eventual consistency — with guidance on choosing per-operation guarantees.
- Distributed ConsensusA practitioner's tour of Paxos, Raft, Zab, PBFT, and HotStuff — why consensus is provably hard (FLP), how each protocol navigates the safety-vs-liveness trade-off, and how etcd, ZooKeeper, Consul, and CockroachDB realise these ideas in production.
- Time and Ordering in Distributed SystemsHow distributed systems establish event ordering without a global clock — physical synchronisation (NTP, PTP, TrueTime), logical and hybrid clocks (Lamport, vector, HLC), broadcast ordering, and ID schemes (Snowflake, UUIDv7), grounded in the Spanner, CockroachDB, Dynamo, and Discord papers.
- Failure Modes and Resilience PatternsA taxonomy of distributed system failures — from fail-stop crashes to insidious gray failures — paired with layered resilience patterns like circuit breakers, bulkheads, and load shedding, including their own failure modes.
- Rate Limiting Strategies: Token Bucket, Leaky Bucket, and Sliding WindowFive rate limiting algorithms compared — token bucket, leaky bucket, fixed window, sliding window log, and sliding window counter — with how AWS API Gateway, Stripe, Cloudflare, GitHub, and NGINX deploy them, plus distributed coordination patterns using Redis and Lua.
- Circuit Breaker Patterns for Resilient SystemsState machines, count vs time-based detection, thread-pool vs semaphore isolation, half-open recovery, the Hystrix → Resilience4j → adaptive-concurrency arc, and the cell-based-architecture critique that makes the whole pattern controversial.
- Capacity Planning and Back-of-the-Envelope EstimatesReference latency numbers, powers of two, and estimation techniques for QPS, storage, bandwidth, and server counts — turning vague requirements into concrete infrastructure math.
Data Storage & Indexing
SQL/NoSQL, sharding, indexing, transactions, caching.
- Storage Choices: SQL vs NoSQLA decision framework for picking SQL, NoSQL, or NewSQL — driven by data model, access patterns, consistency budget, and the operational reality your team can actually carry. Covers relational, document, key-value, wide-column, and graph stores with cited production case studies.
- Sharding and ReplicationTwo orthogonal axes of database scaling — sharding (hash, range, consistent hash, directory) for write throughput and replication (single-leader, multi-leader, leaderless) for availability — with production patterns from CockroachDB, Cassandra, DynamoDB, and Vitess.
- Indexing and Query OptimizationB-trees, hash indexes, LSM trees, composite index design, and query planner cost models — covering how databases choose between index scans and sequential scans, plus maintenance strategies for production systems.
- Transactions and ACID PropertiesACID properties from implementation to practice — covering WAL, MVCC, and locking for single-node transactions, isolation level semantics across major databases, distributed protocols (2PC, Spanner's TrueTime), and alternatives like sagas and the outbox pattern.
- Caching Fundamentals and StrategiesRead patterns, write policies, invalidation strategies, eviction algorithms, and cache topologies — explained from CPU L1 through globally distributed CDNs, with primary-source numbers from Netflix, Salesforce, and Facebook.
Infrastructure Components
Load balancers, CDN, API gateway, service discovery, DNS, queues, RPC.
- Load Balancer Architecture: L4 vs L7, Algorithms, and TLSL4 vs L7 load balancing, algorithm selection (round robin, least connections, consistent hash, P2C, Maglev), TLS termination strategies, health checking and graceful drain, and two-tier patterns from Envoy, HAProxy, AWS, Netflix, Google, and Cloudflare.
- CDN Architecture and Edge CachingCDN request routing via DNS and Anycast, cache key design, TTL and invalidation trade-offs, tiered caching with origin shields, and edge compute — with examples from Cloudflare and CloudFront.
- API Gateway Patterns: Routing, Auth, and PoliciesDesign choices for API gateways covering routing strategies, JWT and API key authentication, rate limiting algorithms, BFF and service-mesh interplay, with cited production data from Netflix, Stripe, Canva, AWS, and Kong.
- Service Discovery and Registry PatternsHow services find each other when instance locations change continuously — client-side, server-side, and service mesh discovery patterns, registry technologies like ZooKeeper, etcd, Consul, and Eureka, and the freshness-vs-stability trade-offs behind each approach.
- DNS Deep DiveAn infrastructure-level survey of DNS — resolution mechanics, record types, TTL and caching, DNS-based load balancing, DNSSEC and DoH/DoT/DoQ, and failover patterns. The starting point for the broader DNS series.
- Queues and Pub/Sub: Decoupling and BackpressureQueues distribute work, topics broadcast events. Compare point-to-point, pub/sub, and hybrid consumer-group patterns — with delivery semantics, ordering, backpressure, and production lessons from Kafka, RabbitMQ, SQS, Pulsar, and NATS.
- Event-Driven ArchitectureWhen events beat synchronous calls, and how to get the patterns right — saga orchestration vs. choreography, the transactional outbox, schema evolution, eventual-consistency UX, and the hidden operational bill, with production numbers from LinkedIn, Uber, and Netflix.
- RPC and API DesignREST, gRPC, and GraphQL compared at the wire — design constraints, streaming, and load-balancing behavior — plus production-grade guidance on versioning, pagination, rate limiting, and machine-readable contracts.
Core Distributed Patterns
CRDT, OT, locking, exactly-once, event sourcing, CDC, migrations, multi-region.
- CRDTs for Collaborative SystemsDeep dive into Conflict-free Replicated Data Types — state-based, op-based, and delta-state variants — covering the join-semilattice math behind guaranteed convergence, sequence CRDTs for collaborative text, production deployments at Figma, Yjs, Automerge, and Riak, and how to choose between CRDTs, OT, and the newer event-graph approach (Eg-walker).
- Operational TransformationHow Operational Transformation enables real-time collaborative editing — TP1/TP2 correctness, why client-server beats peer-to-peer in practice, and why most published OT algorithms were later proven incorrect.
- Distributed LockingHow distributed locks actually work across Redis, ZooKeeper, etcd, and Chubby — covering lease-based expiration, the Redlock controversy, fencing tokens, and when you need correctness locks versus efficiency locks.
- Exactly-Once DeliveryWhy true exactly-once delivery is impossible and how production systems approximate it — at-least-once delivery composed with idempotency keys, broker dedup windows, transactional consumers, and the outbox pattern.
- Event SourcingStoring state as immutable events instead of mutable rows — covering stream design, snapshot strategies, projection patterns, schema evolution via upcasting, and the practical trade-offs that determine when event sourcing fits.
- Change Data CaptureLog-based, trigger-based, and polling-based CDC approaches compared, with Debezium implementation details, Kafka integration patterns, and the trade-offs that make log-based CDC the production standard.
- Database Migrations at ScaleHow to change database schemas without downtime using shadow-table tools (pt-osc, gh-ost, Spirit), the expand-contract pattern, and instant DDL — with decision frameworks for choosing the right approach based on table size and write volume.
- Multi-Region ArchitectureNavigate the trade-offs of active-passive, active-active, and cell-based multi-region architectures — covering data replication strategies, conflict resolution, and lessons from Netflix, Slack, and Uber.
System Design Building Blocks
Reusable component designs for system design.
- LRU Cache Design: Eviction Strategies and Trade-offsFrom the classic hash map + doubly linked list LRU to modern eviction strategies like 2Q, ARC, SIEVE, and W-TinyLFU — understand the trade-offs between recency, frequency, memory overhead, and concurrency in cache design.
- Unique ID Generation in Distributed SystemsHow UUID v4, UUID v7, Snowflake, ULID, and KSUID trade off coordination, sortability, collision probability, and B-tree locality — with the RFC 9562 standardisation of UUID v7 (May 2024) and PostgreSQL 18's native uuidv7() support (September 2025) as the new defaults.
- Distributed Cache DesignA deep guide to distributed caching — topologies, consistent hashing, invalidation, hot-key mitigation, and the operational patterns Meta, Uber, Twitter, and Discord publish about their production caches.
- Blob Storage DesignHow object storage systems are actually built — chunking, content-defined deduplication, metadata-data separation, replication vs erasure coding (and LRC), tiering, garbage collection, and multipart uploads — with the trade-offs and failure modes that shape every layer.
- Distributed Search EngineInverted index internals, Lucene's segment architecture, BM25 ranking, document-vs-term partitioning, NRT refresh / flush / commit, and scatter-gather query execution — everything behind sub-second full-text search over billions of documents.
- Distributed Logging SystemDesigning a centralized logging pipeline from collection agents to tiered storage — covering data models, indexing trade-offs (Elasticsearch vs Loki vs ClickHouse), stream processing, and scaling lessons from Netflix's 5 PB/day deployment.
- Distributed Monitoring SystemsBuilding observability infrastructure that scales — metric types and the cardinality problem, push vs. pull collection, time-series storage engines, trace sampling strategies, and SLO-based alerting with real-world numbers.
- Task Scheduler DesignDesigning distributed task schedulers — coordination via database row locks vs. consensus, cron / interval / delay / event-triggered models, at-least-once + idempotency for effectively-once execution, heartbeat-based recovery, and how Airflow, Temporal, Celery, and Google's distributed cron actually solve these problems.
- Sharded CountersScaling counters past single-key write bottlenecks using sharding (random, hash-based, time-based), aggregation strategies for O(1) reads, probabilistic structures (HyperLogLog, Count-Min Sketch), and CRDT counters (G-Counter, PN-Counter) for active-active replication — with production patterns from Firestore, DynamoDB, Netflix, Meta TAO, Twitter Manhattan, and Redis Active-Active.
- Leaderboard DesignDesign real-time leaderboards on Redis sorted sets - skiplist + hash table internals, ranking semantics, tie-breaking, score-range partitioning, and the hybrid exact / approximate path used at hyperscale.
System Design Scenarios
End-to-end system design interview problems.
- Design a Distributed Key-Value StoreDistributed key-value store design exploring the Dynamo/Cassandra AP model with consistent hashing, quorum replication, vector clocks, gossip protocols, and LSM-tree storage -- contrasted against CP alternatives like etcd for strong consistency.
- Design a Distributed File SystemSystem design for a GFS/HDFS-style distributed file system covering single-master metadata management, large-chunk storage, rack-aware replication, and relaxed consistency models for petabyte-scale batch processing on commodity hardware.
- Design a Time Series DatabaseDesigning a time-series database for metrics and monitoring — LSM-style block storage, Gorilla compression at ~1.37 bytes/sample, inverted-index label lookup, cardinality control, tiered retention, and distributed query fanout.
- Design a YouTube-Style Video PlatformDesigning a YouTube-scale video platform — resumable chunked uploads, chunk-parallel and per-shot transcoding, CMAF-packaged HLS/DASH delivery, hybrid ABR, multi-tier CDN caching, and metadata + view-count systems for billions of daily watch hours.
- Design Netflix Video StreamingA deep dive into Netflix's streaming architecture — Open Connect CDN, per-title and shot-based encoding, AV1 rollout, adaptive bitrate playback, multi-DRM, and the personalization stack that drives most viewing hours.
- Design Instagram: Photo Sharing at ScalePhoto-sharing platform design at Instagram scale covering hybrid fan-out feed generation, multi-resolution image processing pipelines, 24-hour TTL Stories architecture, and ML-powered Explore recommendations serving billions of users.
- Design Spotify Music StreamingHow Spotify is architected at 696M+ MAU — multi-CDN audio delivery, Ogg Vorbis with a 2025 lossless tier, a hybrid recommendation pipeline (collaborative filtering + content-based + NLP), DRM-protected offline sync, and a proxyless gRPC service mesh built on the Backstage developer platform.
- Design Real-Time Chat and MessagingA WhatsApp/Discord-scale chat design — WebSocket connection management, per-conversation ordering, hybrid fan-out, presence, multi-device sync, and the failure modes you actually have to plan for.
- Design a Social Feed (Facebook/Instagram)Designing a social feed system at Facebook/Instagram scale — hybrid push/pull fan-out, multi-stage ML ranking, TAO-style graph storage, cache leasing for consistency, and the celebrity problem where one post fans out to millions.
- Design a Notification SystemA staff-level reference for designing a multi-channel notification platform — event ingestion, priority routing, user preferences and quiet hours, rate limiting, aggregation, retries, and at-least-once delivery across push, email, SMS, and in-app for billions of messages per day.
- Design an Email SystemSystem design for a Gmail-scale email service covering SMTP delivery pipelines, SPF/DKIM/DMARC authentication, Bayesian + ML spam filtering, conversation threading, and full-text search across billions of daily messages.
- Design Uber-Style Ride HailingDesigning a ride-hailing platform like Uber — H3 hexagonal geospatial indexing, batch-optimized driver dispatch, ETA prediction, surge pricing, and real-time location tracking at million-update-per-second scale.
- Design Google MapsSystem design for a mapping and navigation platform: quadtree vector tiles (MVT), Contraction Hierarchies for sub-millisecond routing on continental road networks, HMM map matching, and graph-neural-network ETA prediction.
- Design Yelp: Location-Based Business Discovery PlatformDesigning a Yelp-like proximity service — geospatial indexing strategies (geohash, quadtree/S2, BKD/R-tree), multi-signal ranking that blends distance with relevance, review ingestion with the transactional outbox pattern, and sub-100ms search at a 100:1 read/write ratio.
- Design Search Autocomplete: Prefix Matching at ScaleBuilding a search autocomplete that returns ranked suggestions inside the typing cadence — trie-based prefix matching with pre-computed top-K, dual-path indexing for trending queries, layered caching, and the ARIA combobox contract on the client.
- Design a Web CrawlerWeb-scale crawler design — Mercator-style URL frontier with priority and politeness, Bloom-filter URL dedup, SimHash near-duplicate detection, consistent-hashing partitioning by host, and RFC 9309 robots.txt handling.
- Design Google SearchWeb-scale search engine design — crawling hundreds of billions of pages with priority + politeness, building inverted indexes incrementally on Bigtable via Caffeine/Percolator, ranking with PageRank + BERT/MUM + RankBrain, and serving sub-second queries through document-partitioned shards with hedged fan-out.
- Design Collaborative Document Editing (Google Docs)Real-time collaborative document editing covering Operational Transformation vs. CRDTs, WebSocket-based synchronization, presence broadcasting, event-sourced revision history, and offline editing with reconciliation for tens of simultaneous editors.
- Design Dropbox File SyncSystem design for cross-device file sync at Dropbox scale — content-defined chunking, the three-tree planner that detects conflicts without coordination, content-addressed blocks for cross-user dedup, and the Magic Pocket storage layer behind 700M+ users and multi-exabyte data.
- Design Google CalendarSystem design for a calendar application — RRULE-based recurrence, IANA timezone handling across DST boundaries, free/busy aggregation, and sync-token-based multi-client synchronization at planet scale.
- Design an Issue Tracker (Jira/Linear)System design for an issue tracker like Jira or Linear, covering fractional indexing (LexoRank) for drag-and-drop ordering, project-specific workflow definitions, per-column cursor pagination, and WebSocket-based real-time board sync.
- Design a Payment SystemArchitecting a payment platform: edge tokenization for PCI scope, idempotent authorization, sub-100ms fraud scoring, double-entry ledgering, smart routing, 3D Secure 2, and idempotent webhook consumption — grounded in published Stripe, Adyen, Visa, Nacha, and PCI SSC sources.
- Design a Flash Sale SystemDesigning a flash sale system that handles millions of concurrent buyers and limited inventory: CDN-hosted virtual waiting rooms, token-gated admission, Redis atomic inventory deduction, asynchronous order processing, and layered bot defence under 10-100x traffic spikes.
- Design Amazon Shopping CartSystem design for an e-commerce shopping cart: two-tier Redis/RDBMS storage, soft inventory reservations with TTL, an idempotent saga for checkout, and guest-to-user cart merging at flash-sale scale.
- Design a URL Shortener: IDs, Storage, and ScaleStaff-level system design for a URL shortener — ID generation, multi-tier caching for sub-50 ms redirects, sharding, async analytics with ClickHouse, abuse prevention, and the failure modes that actually hit production.
- Design Pastebin: Text Sharing, Expiration, and Abuse PreventionDesigning a Pastebin-like text sharing service with collision-free URL generation, multi-tier storage with content deduplication, expiration strategies, and abuse prevention — all at sub-100ms read latency.
- Design an API Rate Limiter: Distributed Throttling, Multi-Tenant Quotas, and Graceful DegradationDistributed API rate limiting with sliding window counters, Redis-backed atomic counting, multi-tenant hierarchical quotas, and fail-open resilience. Covers sub-millisecond decision latency at 500K+ checks per second.
- Design a Cookie Consent ServiceMulti-tenant consent management platform handling GDPR, CCPA, and LGPD obligations at scale. Covers edge-cached consent delivery, identity migration on login, immutable audit logs, sub-50ms consent checks, and the regulatory limits that shape every architectural choice.
Case Studies: Outages & Reliability
Post-mortems and reliability case studies.
- Facebook 2021 Outage: BGP Withdrawal, DNS Collapse, and the Backbone That DisappearedAnatomy of the October 2021 Meta outage — how a backbone maintenance command triggered global BGP withdrawal, collapsed DNS for 3.5 billion users, and exposed fatal shared-fate dependencies in every recovery path.
- AWS Kinesis 2020 Outage: Thread Limits, Thundering Herds, and Hidden DependenciesA deep-dive into the 2020 AWS Kinesis outage where a routine capacity addition hit an OS thread limit, cascading through CloudWatch, Lambda, and Cognito for 17 hours due to O(N^2) scaling and hidden dependencies.
- Stripe: Idempotency for Payment ReliabilityHow Stripe makes payment APIs safe to retry — Idempotency-Key, atomic phases, recovery points, transactionally-staged job drains, and what changed in API v2.
- Discord: Rewriting Read States from Go to RustWhy Discord rewrote their Read States service from Go to Rust — Go's garbage collector caused unavoidable 2-minute latency spikes by scanning millions of live cache entries, and Rust's ownership model eliminated them entirely.
- Graceful DegradationDesigning distributed systems to maintain partial functionality under failure through degradation hierarchies, circuit breakers, bulkheads, load shedding, and coordinated recovery — with explicit trade-offs between availability and correctness.
Case Studies: Architecture
Architecture transformation case studies.
- Shopify: Pod Architecture for Multi-Tenant Isolation at ScaleHow Shopify evolved from a sharded Rails monolith to pod-based isolation — containing blast radius per failure domain, enabling sub-minute pod failover, and surviving 489 million edge requests per minute on Black Friday 2025.
- Netflix: From Monolith to Microservices — A 7-Year Architecture EvolutionTrace Netflix's 7-year migration from a monolithic Oracle backend to hundreds of microservices on AWS — the phased approach, the OSS tools born from production pain (Eureka, Hystrix, Zuul, Simian Army), and the cultural shifts that made it possible.
- Twitter/X: Timeline Architecture and the Recommendation AlgorithmTwitter's timeline architecture across three eras — fanout-on-write with Redis, the multi-service ML recommendation pipeline (SimClusters, MaskNet), and X's Grok-based Phoenix/Thunder system — tracing the trade-offs between read latency, ranking quality, and system complexity.
- Facebook TAO: The Social Graph's Distributed CacheA deep dive into TAO, Facebook's graph-aware caching layer that replaced lookaside memcache with a two-tier write-through architecture. The 2013 paper described 1B reads/sec at 96.4% hit rate; by 2021 it served 10B+ reads/sec on petabytes of data.
- Uber: From Monolith to Domain-Oriented MicroservicesUber's three-phase architecture evolution — from a Python/Node.js monolith to 4,000+ microservices to Domain-Oriented Microservice Architecture (DOMA) — showing how each phase solved scaling bottlenecks while creating new organizational challenges.
- Uber Schemaless: Building a Scalable Datastore on MySQLHow Uber built Schemaless — a horizontally scalable, append-only datastore layered on sharded MySQL — to escape a single-PostgreSQL bottleneck. Covers the immutable cell model, fixed 4,096-shard layout, two-cluster buffered writes, eventually consistent indexes, and the trigger framework.
- Slack: Scaling a Real-Time Messaging Platform from Monolith to Distributed ArchitectureHow Slack scaled from a PHP monolith to a distributed architecture — migrating to Vitess for flexible sharding, building Flannel for edge caching, and adopting cellular infrastructure for 99.99% availability — all without a big-bang rewrite.
- LinkedIn and the Birth of Apache Kafka: Solving the O(N²) Data Integration ProblemHow LinkedIn's O(N squared) data pipeline problem led to the creation of Apache Kafka — a distributed commit log that replaced fragile point-to-point integrations with a unified, scalable data bus.
Case Studies: Data & Migrations
Database and storage migration case studies.
- Dropbox Magic Pocket: Building Exabyte-Scale Blob StorageHow Dropbox built Magic Pocket — a content-addressable, exabyte-scale block store — to migrate 500+ PB off S3, save $74.6M net, and achieve 12+ nines of durability with SMR drives, erasure coding, and continuous integrity verification.
- Instagram: From Redis to Cassandra and the Rocksandra Storage EngineHow Instagram migrated activity feed and fraud detection from Redis to Cassandra for ≈75% cost savings, then built Rocksandra (a RocksDB-based pluggable storage engine) to drop P99 reads from 60 ms to 20 ms and GC stalls by ~10x — a seven-year evolution from 12 nodes to 1,000+ across six data centres.
- YouTube: Scaling MySQL to Serve Billions with VitessHow YouTube built Vitess to scale MySQL from 4 shards to 256 across tens of thousands of nodes, solving cascading connection storms, enabling zero-downtime resharding, and serving millions of queries per second — and why they eventually migrated to Spanner anyway.
- GitHub: Scaling MySQL from One Database to 1,200+ HostsHow GitHub scaled MySQL from a single database to 1,200+ hosts and 5.5M QPS through vertical partitioning, custom tooling (gh-ost, orchestrator, freno), Vitess adoption, and a rolling MySQL 8.0 upgrade — without a big rewrite.
- Pinterest: MySQL Sharding from Zero to Billions of ObjectsHow Pinterest replaced three failing NoSQL stores with sharded MySQL — a 64-bit ID scheme that embeds routing, virtual shards for painless growth, and a "boring technology" philosophy still running a decade later.
- Discord: From Billions to Trillions of Messages — A Three-Database JourneyHow Discord evolved message storage from MongoDB to Cassandra to ScyllaDB across trillions of messages — solving JVM GC pauses, hot partitions, and tombstone storms with Rust data services and request coalescing.
- Figma: Building Multiplayer Infrastructure for Real-Time Design CollaborationHow Figma built real-time multiplayer editing for 200 concurrent users by rejecting both OT and pure CRDTs in favor of server-authoritative last-writer-wins at the property level, backed by Rust and DynamoDB.
- WhatsApp: 2 Million Connections Per Server with ErlangHow WhatsApp pushed Erlang/BEAM and FreeBSD to 2 million concurrent connections per server, served 465 million users with ~32 engineers, and patched the VM (timer wheels, GC throttling, pg2) to keep a small fleet ahead of growth — a case study in vertical density and runtime co-design.
Platform Delivery & Reliability
CI/CD, deployment, observability, and platform migrations.
- Edge Delivery and Cache InvalidationCache key design, TTL strategies, invalidation approaches (versioned URLs, surrogate-key purge, stale-while-revalidate), edge compute patterns, and the operational failure modes — thundering herd, fragmentation, propagation lag — that decide whether a CDN deployment is a load shield or a liability.
- Deployment Strategies: Blue-Green, Canary, and RollingArchitectural trade-offs between blue-green, canary, and rolling deployments, covering traffic shifting mechanics, database migration coordination, automated rollback criteria, and operational failure modes encountered during incident response.
- SSG Performance on AWS: Atomic Deploys, Edge Functions, and Pre-CompressionProduction static site delivery on S3 + CloudFront — atomic versioned deploys, CloudFront Functions vs Lambda@Edge, Continuous Deployment for blue/green, Brotli pre-compression with edge content negotiation, and CLS budget mechanics.
- Build Pipelines and CI/CD ArchitectureHow to design commit-to-production pipelines: stage ordering, caching and reproducibility, test and security gates, deployment models, observability, and the failure modes that matter in real systems.
- E-commerce SSG to SSR Migration: Strategy and PitfallsA staff-engineer playbook for migrating an e-commerce platform from SSG to SSR with a Strangler Fig rollout — covering the cache-header capability gap, edge-bucketing on CloudFront, ISR as a sometimes-better midpoint, and the operational realities of real-time content updates.
- Zero-Downtime Data Migrations: Backfills, Dual Writes, and Safe CutoversA production-oriented playbook for overlapping migrations: invariants during dual writes, idempotent backfills and lag control, reconciliation, cutover gates, rollback triggers, and decommissioning the old path.
- SLOs, SLIs, and Error BudgetsThe SLO reliability framework from Google's SRE practice — defining user-centric SLIs, setting meaningful targets, calculating error budgets, implementing multi-window multi-burn-rate alerting, and using budget policies to balance feature velocity with reliability investment.
- Logging, Metrics, and Tracing FundamentalsUnderstand the three pillars of observability — structured logging, metrics, and distributed tracing — including cardinality trade-offs, sampling strategies, and OpenTelemetry's unified data model.
Media Systems & Testing
Media processing pipelines and experimentation frameworks.
- DRM Fundamentals for Streaming MediaHow CENC encryption, Widevine/FairPlay/PlayReady, and EME work together to protect streaming content — covering AES modes, security levels, license server design, key rotation, and the real threat model DRM addresses.
- Video Transcoding Pipeline DesignPipeline architecture for scalable video transcoding — covering codec selection, rate control strategies, chunked parallel encoding, per-title bitrate ladders, VMAF quality validation, and the compute/storage/egress cost trade-offs behind production video platforms.
- Web Video Playback Architecture: HLS, DASH, and Low LatencyThe complete video delivery pipeline from codecs (H.264, HEVC, AV1) and containers to adaptive streaming with HLS and DASH, DRM fragmentation, and ultra-low latency techniques — including protocol internals, design trade-offs, and production failure modes.
- Image Processing Service Design: CDN, Transforms, and APIsArchitecture for a cloud-agnostic, multi-tenant image processing platform with on-the-fly transforms, content-addressed caching, signed URLs, and a CDN-first delivery strategy achieving sub-second response times.
- Load Testing Strategy and Capacity PlanningHypothesis-driven load test design, realistic traffic modeling, saturation signals and bottleneck classes, and turning measurements into capacity envelopes with explicit headroom—without mistaking a tool run for an engineering answer.
- k6 Load Testing: Architecture, Workload Models, and CI GatingHow k6 turns load testing into code: the Go + Sobek runtime, open vs closed workload modelling, the seven built-in executors, the metrics-and-thresholds CI gate, and where it sits next to JMeter, Gatling, and Locust.
- Statsig Experimentation Platform: SDK Architecture and RolloutsHow Statsig's SDKs evaluate feature flags and experiments — deterministic SHA-256 bucketing, the server vs. client evaluation split, bootstrap initialization, data adapters, and the cloud-vs-warehouse-native deployment trade-off.
Data Structures & Algorithms
Core data structures, algorithms, and interview foundations.
- Arrays and Hash Maps: Engine Internals and Performance RealityHow V8 internally represents arrays and objects through elements kinds, hidden classes, and deterministic hash tables — and why certain patterns permanently degrade performance.
- Trees and Graphs: Traversals and ApplicationsTree variants (BST, AVL, Red-Black, B-trees, tries) and graph algorithms (DFS, BFS, topological sort, shortest paths) with design trade-offs — when to choose each structure and why, from database indexes to dependency resolution.
- Heaps and Priority Queues: Internals, Trade-offs, and When Theory Breaks DownBinary heap internals, array representation, core operations, and the gap between textbook complexity and real-world cache performance — plus when d-ary heaps, pairing heaps, or Fibonacci heaps actually win.
- Sorting Algorithms: Complexity, Stability, and Use CasesSorting algorithms from bubble sort through merge sort, quicksort, and radix sort — with TypeScript implementations, stability and complexity analysis, and the production hybrids (TimSort, pdqsort) that power real-world runtimes.
- Search Algorithms: Linear, Binary, and Graph TraversalSearch algorithms from linear and binary search through BFS, DFS, Dijkstra, and A* — with TypeScript implementations, complexity analysis, and guidance on choosing the right algorithm based on data structure and search goal.
- K-Crystal Balls Problem: Drops, Floors, and the Optimal DPHow to find a breaking-floor threshold with k consumable test resources. Full derivation of the optimal egg-drop strategy: the k=2 closed form T = ⌈(√(8N+1)−1)/2⌉, the floors-covered DP recurrence f(k, m) = f(k-1, m-1) + f(k, m-1) + 1, its binomial closed form, and the O(k log N) algorithm.
JavaScript Patterns
Practical JavaScript design patterns and utilities.
- Publish-Subscribe Pattern in JavaScriptImplement the Pub/Sub pattern in JavaScript from scratch — covering the three decoupling dimensions, error isolation, async dispatch, topic-based routing, and when the Observer pattern is a better fit.
- Exponential Backoff and Retry StrategyExponential backoff with jitter, decorrelated and full-jitter algorithms, retry budgets, circuit breakers, and request hedging — the math behind why deterministic retries melt servers, and the production patterns that prevent it.
- Async Queue Pattern in JavaScriptFrom in-memory concurrency control with p-queue and fastq to distributed job processing with BullMQ and Redis, covering backpressure, retry strategies, and dead letter queues in Node.js.
- JavaScript Error Handling PatternsA staff-level tour of JavaScript error handling — Error subclasses, async propagation, top-level handlers in browsers and Node, React Error Boundaries, worker / structured-clone transmission, and the exception-vs-Result trade-off with neverthrow / fp-ts.
- JavaScript String Length: Graphemes, UTF-16, and UnicodeWhy string.length returns 11 for a family emoji and how to handle it — covering UTF-16 surrogate pairs, Unicode code points vs. grapheme clusters, and using Intl.Segmenter for correct character counting and truncation.