Guides
In-depth references that go beyond the tool UI — concepts, structure, common pitfalls, and safe usage patterns.
- What is JWT? Token Structure and Secure Use
JSON Web Token (JWT) explained from header/payload/signature to verification, secret rotation, and common security pitfalls.
~9 min
- Base64 Encoding — How It Works and When to Use It
Base64 is binary-to-text encoding, not encryption. Understand padding, URL-safe variants, common pitfalls, and the encoded size overhead.
~7 min
- UUID vs ULID — Which Identifier Should You Use?
UUID v4, UUID v7, ULID, and Snowflake compared on sortability, database performance, URL friendliness, and collision risk.
~8 min
- Regex Tutorial — From Basics to Lookarounds and Catastrophic Backtracking
Hands-on regex tutorial covering character classes, quantifiers, groups, lookaround, and the catastrophic backtracking patterns to avoid.
~10 min
- Cron Expression Guide — Syntax, Timezones, and Common Mistakes
Cron field-by-field syntax, special tokens, timezone behavior across Unix cron, Kubernetes, and AWS, and the patterns that cause silent failures.
~8 min
- HMAC Webhook Verification — How Stripe, GitHub, and Slack Sign Requests
Why webhooks need HMAC signatures, how providers like Stripe and GitHub sign payloads, constant-time comparison, replay protection, and a step-by-step verifier.
~8 min
- HTTP Status Codes — When to Use 401, 403, 422, 500 and the Rest
Definitive reference for HTTP status codes — class meanings, the most common codes in REST APIs, frequently confused pairs (401 vs 403, 400 vs 422), and how to pick the right one.
~9 min
- Password Hashing Done Right — bcrypt, Argon2, and What Not to Do
Why you can't store passwords with SHA-256, what makes bcrypt and Argon2 different, how to pick cost parameters, peppering, and migrating between algorithms.
~10 min
- WCAG Color Contrast — AA, AAA, and What the 4.5:1 Ratio Means
How WCAG contrast ratios are calculated, the difference between AA and AAA, what 'large text' means, common UI failures, and APCA (the next-gen formula).
~8 min
- Markdown Cheat Sheet — Every Common Syntax with Examples
A complete Markdown reference — headings, lists, links, images, tables, code blocks, footnotes, task lists, and the GitHub Flavored Markdown extras.
~7 min
- CORS Explained — What Triggers Preflight, Common Errors, and How to Fix Them
Cross-Origin Resource Sharing in plain language — same-origin policy, simple vs preflight requests, the right Access-Control-* headers, credentials, and the most common debugging traps.
~9 min
- OAuth 2.0 Explained — Authorization Code, PKCE, Client Credentials, and When to Use Which
OAuth 2.0 in plain language — the four flows, why PKCE replaced implicit, refresh tokens, scopes, and how it relates to OpenID Connect.
~10 min
- Timezone Pitfalls in JavaScript — UTC, IANA, DST, and Storing Dates Right
Why JS Date is dangerous, why you should always store UTC, the difference between offset and IANA name, daylight saving traps, and the right way to format for users.
~9 min
- URL Encoding Deep Dive — Why %20 Not + and When encodeURIComponent Beats encodeURI
Percent-encoding character sets, the difference between encodeURI and encodeURIComponent, when + means space, IDN/Punycode, and the right way to build URLs.
~8 min
- JSON Schema vs TypeScript Types — When to Generate Which from the Other
What JSON Schema can do that TypeScript can't (and vice versa), generation strategies in both directions, runtime validation with Ajv/Zod, and the right boundary patterns.
~9 min
- Web Crypto API — SHA, HMAC, AES, and JWT in the Browser Without Libraries
Native crypto.subtle in browsers — digest, sign/verify, encrypt/decrypt, key import/export, and why getRandomValues replaces Math.random for security.
~9 min
- Image Optimization for the Web — WebP, AVIF, srcset, and the Right Compression
Modern image formats compared, when to pick JPEG vs WebP vs AVIF, responsive images with srcset, lazy loading, and how compression actually works.
~8 min
- Idempotency Keys — How Stripe Makes Retries Safe and How to Implement Them
Why retries cause duplicate charges, how Stripe and PayPal use idempotency keys, the server-side state machine, key generation strategies, and storage TTL.
~8 min
- Content Security Policy — Stop XSS with the Right CSP Header
How CSP defends against XSS, the directives you actually need, nonces vs hashes vs strict-dynamic, the report-only rollout pattern, and AdSense/GA compatibility.
~9 min
- HTTP Caching — Cache-Control, ETag, and the Right Headers for Every Asset
max-age vs s-maxage, immutable, stale-while-revalidate, ETag vs Last-Modified, CDN vs browser cache, and the headers your static assets, HTML, and API responses each need.
~9 min
- Webhooks vs Polling vs SSE vs WebSocket — Picking the Right Real-Time Pattern
Four real-time integration patterns compared on latency, cost, complexity, and failure modes. When to use webhooks, when to fall back to polling, and where SSE/WebSocket fit.
~9 min
- SVG Optimization — From 50KB Editor Export to 5KB Production-Ready
Why editor exports balloon, what SVGO removes, when to inline vs reference, sprite sheets, and the security checklist for user-uploaded SVGs.
~7 min
- SameSite Cookies and CSRF — What Lax, Strict, and None Actually Mean
How SameSite changed CSRF defense in 2020, the differences between Lax/Strict/None, when you need Secure, third-party cookie deprecation, and what's still required beyond SameSite.
~8 min
- Rate Limiting Strategies — Token Bucket, Sliding Window, and the 429 Retry-After Contract
Why rate limit, the four classic algorithms (fixed window, sliding window, token bucket, leaky bucket), how to scope by IP/user/API key, and the headers clients expect.
~9 min
- Kubernetes YAML Explained — Manifest Structure, Resource Kinds, and How They Connect
What every Kubernetes manifest shares (apiVersion / kind / metadata / spec), the resource kinds you'll actually use, how Services find Pods via labels, and the manifest gotchas that bite teams new to K8s.
~11 min
- Docker Compose Explained — Services, Networks, Volumes, and the Practical Setup
How docker-compose.yml is structured, what each top-level key (services / networks / volumes / configs / secrets) does, depends_on vs healthcheck, named volumes vs bind mounts, and the gotchas that break dev environments.
~10 min
- The Pomodoro Technique — History, Method, and Why It Works
Where the Pomodoro Technique came from (Francesco Cirillo and a tomato-shaped kitchen timer), the exact method (25-minute focus + 5-minute break, long break after four), why time-boxing fights distraction and burnout, popular variations, and the myths worth dropping.
~8 min
- How QR Codes Are Made
A practical tour through QR code structure: the finder / alignment / timing patterns, four data encoding modes, Reed-Solomon error correction levels (L/M/Q/H), and the 8 mask patterns that keep scanners reliable. Backed by the ISO/IEC 18004 spec.
~9 min
- How SHA Hashes Are Built
A guided tour through cryptographic hashes — what makes a function one-way, the Merkle-Damgård and sponge constructions behind SHA-2 and SHA-3, why MD5/SHA-1 are broken, and why fast hashes are wrong for passwords.
~9 min
- How Computers Represent Color (RGB, HSL, OKLCH)
What sRGB, P3, RGB, HSL, OKLCH actually mean. Why HSL feels intuitive but breaks visual consistency, why OKLCH is the new default in design systems, and how to read gamut and luminance like a pro.
~9 min
- How Diff Algorithms Find Changes
From LCS to Myers' O(ND) algorithm — how Git, GitHub PRs, and your IDE compute the smallest set of changes between two texts, why moves look like delete+insert, and the unified vs context patch formats.
~9 min
- How UTF-8 Encodes Text
Why a Korean character takes 3 bytes, what a Unicode codepoint is, how UTF-8's variable-length scheme stays ASCII-compatible, the BOM, surrogate pairs, and the bugs that come from byte-vs-character confusion.
~9 min
- How JSON Parsing Works
Inside the JSON parser — lexer states, why JSON forbids trailing commas, why large integers lose precision (IEEE 754), how streaming JSON works, and the parser quirks that surprise senior engineers.
~9 min
- How Image Compression Actually Works (PNG, JPG, WebP, AVIF)
What's inside a JPEG, why PNG is lossless, how WebP and AVIF squeeze further without visible loss. Discrete cosine transform, Huffman coding, palette indexing, and the trade-offs each format makes.
~9 min
- How SQL Parsing Works (and Why Injection Is Dangerous)
Inside the SQL pipeline — lexer, parser, AST, query planner, executor. Why concatenated SQL is dangerous, how prepared statements actually neutralize injection, and the parser quirks that distinguish PostgreSQL, MySQL, SQLite.
~9 min
- Why Every User-Agent Starts With "Mozilla"
A short history of the most-lied-to HTTP header — why Chrome pretends to be Netscape, why Safari pretends to be Chrome, and where User-Agent is heading next (Client Hints / Sec-CH-UA / privacy budgets).
~8 min
- YAML vs JSON vs TOML vs XML — Picking a Config Format
Five config formats compared head-to-head — YAML's seven booleans, TOML's typed datetimes, JSON's lack of comments, XML's namespace power, INI's anything-goes. Pick the right format for the job.
~9 min
- How Numbers Are Stored (Binary, Hex, Two's Complement, Floats)
Why developers see hex everywhere, how two's complement makes addition and subtraction the same circuit, why 0.1 + 0.2 ≠ 0.3, and the bit patterns hiding inside every integer and float.
~8 min
- How HTML Parsing Works
The HTML5 parser is famously forgiving — it recovers from missing tags, lets <br/> and <br> coexist, and never throws on malformed input. Here's the state machine behind that magic, why void elements exist, and how XML strictness compares.
~8 min
- How Unix Time Actually Works
Why 1970, why Unix time isn't actually monotonic, the Y2038 problem on 32-bit systems, the leap-second mess, monotonic vs wall clocks, and why "now()" can go backwards.
~8 min
- Why CSV Always Breaks (And How to Fix It)
CSV looks like the simplest format alive — commas and rows. In practice, quotes inside fields, embedded newlines, BOM bytes, Excel's encoding choices, and dialect drift turn it into the most-broken format in production.
~8 min
- What's Actually Inside an HTTP Request
Open the wire — request line, headers, body, and the conversation patterns that hide behind GET and POST. Content negotiation, conditional requests, cookies, preflight, and the underrated headers everyone forgets.
~9 min
- How IP Addresses and CIDR Actually Work
Why an IP address is just a 32-bit number, what /24 means, the private ranges every backend touches, NAT, and why IPv6 came along — explained as bit patterns, not networking jargon.
~8 min
- How JavaScript Is Parsed and Executed
From source bytes to V8 hidden classes — lexer, parser, AST, hoisting, the event loop, ASI gotchas, and the optimizations that make JavaScript fast despite being a dynamic language.
~9 min
- How TLS Handshake Actually Works
What happens between ClientHello and the first encrypted byte — certificates, cipher suites, key exchange, SNI, and why TLS 1.3 dropped the handshake from two round trips to one.
~9 min
- How DNS Actually Works
Walk through a DNS query — root server, TLD, authoritative resolver, recursive resolver, TTL caching, the A/AAAA/CNAME/MX record zoo, and why DNS-over-HTTPS exists.
~9 min
- How File Magic Numbers Work
How operating systems and browsers identify file types from their first few bytes — PNG, JPG, PDF, ZIP signatures, the gotchas of trusting filename extensions, and why content-sniffing is both useful and dangerous.
~8 min
- Why URL Slugs Matter for SEO
What makes a good URL slug — search-friendly characters, the Romanization vs Punycode question for Korean, hyphen vs underscore, slug stability, and the 301 redirect rules every site eventually needs.
~7 min
- How Git Actually Works (Objects, Refs, Pack Files)
Inside .git — four object types (blob, tree, commit, tag), how refs point at commits, why every commit gets a SHA-1, pack files, garbage collection, and what merge vs rebase actually moves around.
~9 min
- Why Regex Sometimes Hangs (ReDoS Explained)
Regex engines that backtrack can take exponential time on innocent-looking patterns like (a+)+. Learn the NFA/backtracking model, the ReDoS attack vector, and the linear-time engines (RE2) that prevent it.
~8 min
- WebSocket vs SSE — How Real-Time Web Actually Works
Bidirectional WebSocket vs one-way Server-Sent Events — handshake details, frame formats, reconnection, heartbeats, and which one to pick for chat, notifications, or live dashboards.
~8 min
- How CSS Selectors and Specificity Work
Why one rule wins over another — selector matching, the (a-b-c) specificity calculation, the cascade order, :where() with zero specificity, !important escape hatches, and how @layer brings order back.
~8 min
- How Docker Containers Actually Work
Containers aren't lightweight VMs — they're Linux processes with namespaces and cgroups around them. Walk through namespaces, cgroups, the overlay filesystem, image layers, and what Docker the daemon actually does.
~9 min
- How Bundlers Actually Work (Webpack, Vite, esbuild, Turbopack)
What bundlers do beyond "glue files together" — module resolution, dependency graphs, tree shaking, code splitting, source maps, HMR, and why Vite is 100× faster than Webpack in dev.
~9 min
- How GraphQL Actually Works
What GraphQL does that REST doesn't — schema-first design, resolver trees, the N+1 problem and how DataLoader solves it, mutations, subscriptions, federation, and when GraphQL is overkill.
~9 min
- How Authentication Actually Works (Session, JWT, OAuth, Passkey)
Session cookies vs JWT vs OAuth flows vs passkey — what each model actually stores, where the trust lives, why refresh tokens exist, and how passkeys replace passwords entirely with WebAuthn.
~9 min
- How Database Indexes Actually Work
B-tree, hash indexes, covering indexes, why LIKE '%foo' can't use the index, why composite-index column order matters, and how EXPLAIN reveals when the planner is actually using your index.
~9 min
- How Database Transactions Actually Work
ACID, isolation levels, dirty/phantom reads, write skew, MVCC vs locking, SERIALIZABLE, deadlocks, and the retry-on-serialization-failure pattern explained.
~9 min
- How Database Storage Engines Actually Work
Pages, the buffer pool, WAL and fsync, B-tree vs LSM-tree engines, compaction, and the write/read/space amplification trade-offs that decide which engine fits.
~10 min
- How Database Connection Pooling Actually Works
Why opening a DB connection is expensive, what a pool is, pool exhaustion, sizing math, PgBouncer session vs transaction mode, and serverless connection storms.
~8 min
- How Query Planners Actually Work
How a SQL planner turns a query into an execution plan: cost model, statistics, cardinality estimation, scan and join choices, and reading EXPLAIN ANALYZE.
~10 min
- How Core Web Vitals Actually Work
LCP, CLS, and INP explained — what each Core Web Vitals metric measures, field vs lab data, what hurts each, and how to measure and fix them.
~9 min
- How Debouncing and Throttling Actually Work
Debounce vs throttle for taming high-frequency events like scroll, resize, and input — leading vs trailing edge, real JS code, React pitfalls, and INP gains.
~8 min
- How Web Fonts Actually Load
Why web fonts load late, FOIT vs FOUT vs FOFT, every font-display value, the CLS swap problem, size-adjust fallback metrics, preload, WOFF2, variable fonts.
~9 min
- How Resource Hints Actually Work
Resource hints explained: preload, preconnect, dns-prefetch, prefetch, modulepreload, fetchpriority, 103 Early Hints, and Speculation Rules — when to use each.
~8 min
- How Browsers Render Pages
From HTML bytes to pixels — parsing, DOM/CSSOM, render tree, layout, paint, composite. Why reflow is expensive, what triggers GPU layers, and how to stay inside the 16.67ms frame budget.
~8 min
- How Message Queues Actually Work (Kafka, RabbitMQ, SQS)
Pub-sub, partitions, log vs queue, at-least-once vs exactly-once, consumer groups, and which message system fits which job — Kafka, RabbitMQ, or SQS.
~8 min
- How TypeScript Types Actually Work
Structural typing, narrowing, discriminated unions, generics, conditional / mapped types — what TypeScript actually checks at compile time, why runtime values can still surprise you, and the patterns that make the type system pull its weight.
~9 min
- How Memory Allocation Actually Works
Stack vs heap, malloc/free under the hood, why fragmentation matters, RAII vs GC, and the actual machinery behind 'new Object()' in any language — explained with the cost model your code is actually paying.
~9 min
- How Garbage Collection Actually Works
Mark-and-sweep, reference counting, generational hypothesis, why 99% of objects die young, the stop-the-world pause, G1 vs ZGC vs Shenandoah, and why GC tuning is really just allocation pattern tuning.
~9 min
- How Network Programming Actually Works
Sockets, TCP vs UDP, the C10K problem and why epoll/kqueue/IOCP were invented, blocking vs non-blocking vs async, the file-descriptor abstraction, and why Node.js is single-threaded yet can serve 10,000 connections.
~10 min
- How Concurrency Primitives Actually Work
Mutex, semaphore, condvar, atomic CAS, lock-free vs wait-free, why volatile isn't a lock, memory ordering and the happens-before relation, and the actor model as a different way out — explained at the level of what the CPU actually does.
~11 min
- How Filesystems Actually Work
Inodes, blocks, VFS, the open() file descriptor lifecycle, journaling vs copy-on-write, ext4 vs btrfs vs ZFS, why 'rm' is fast but secure delete is slow, and what 'fsync' actually does — the layer between your code and the disk.
~10 min
- How CPU Caches Actually Work
L1 vs L2 vs L3, cache lines (64 bytes), why row-major iteration is 10× faster than column-major, false sharing in multi-threaded code, the prefetcher, NUMA, and why the same algorithm has wildly different real performance.
~9 min
- How Compilers Actually Work
Lexing, parsing, AST, IR (LLVM, Go SSA), optimization passes that actually run, codegen and register allocation, why -O2 makes your code 3× faster but harder to debug, and how Rust, Go, and Swift compilers differ.
~10 min
- How Linkers Actually Work
Static vs dynamic linking, ELF symbol tables, what 'undefined reference to foo' really means, GOT/PLT and how libc.so resolves at runtime, ld.so the program that runs before your main(), and why DLL hell happens.
~10 min
- How System Calls Actually Work
User mode vs kernel mode, the syscall instruction (x86 syscall, ARM svc), what strace shows, why syscalls cost 100 ns minimum, vDSO (clock_gettime without a syscall), and io_uring as the future of syscall amortization.
~9 min
- How Consensus Algorithms Actually Work
Paxos vs Raft, leader election, quorum (N/2+1), split-brain, the FLP impossibility result, why Raft beat Paxos in practice, and how etcd / Consul / ZooKeeper actually decide what's true.
~10 min
- How Database Replication Actually Works
Sync vs async, leader-follower vs multi-leader vs leaderless, replication lag, read-your-writes consistency, the surprising failure modes when you scale reads, and why eventual consistency is rarely what you actually want.
~10 min
- How Sharding Actually Works
Hash-based vs range-based partitioning, consistent hashing (why 1995's invention is still ubiquitous), hot shards, rebalancing without downtime, why cross-shard joins are the dragon, and how DynamoDB / Cassandra / Vitess actually split data.
~10 min
- How the CAP Theorem Actually Works
What Brewer actually proved (and what marketing pretends he proved), partition tolerance is non-negotiable, the CP vs AP false dichotomy, PACELC as the more honest framework, and which trade-off each real database (DynamoDB / Cassandra / Spanner / etcd) actually picks.
~9 min
- How Event Sourcing Actually Works
Event log as source of truth, projections, snapshots, CQRS, replay for time-travel debugging, why outbox is necessary, the schema-evolution dragon, and when event sourcing is the right answer (and when it's accidental complexity).
~10 min
- How Observability Actually Works
The three pillars (logs, metrics, traces), what each is good at, cardinality as the cost ceiling, why you can't just 'log everything', and how observability differs from monitoring.
~9 min
- How Distributed Tracing Actually Works
Spans, parent-child, trace context propagation (W3C Trace Context), OpenTelemetry, head vs tail sampling, why 1% sampling can still miss your slowest request, and Jaeger / Tempo / Honeycomb / Lightstep trade-offs.
~10 min
- How Metrics Actually Work
Counter / gauge / histogram / summary — what each measures, why histograms beat averages, Prometheus pull vs StatsD push, exemplars, cardinality explosions, and the difference between p50 / p99 / max.
~9 min
- How Structured Logging Actually Works
Why JSON logs beat printf, levels (DEBUG / INFO / WARN / ERROR / FATAL), correlation IDs that connect a request across services, log aggregation (Loki / Elasticsearch / CloudWatch), and sampling without losing the bugs.
~9 min
- How SLIs and SLOs Actually Work
What an SLI actually measures, how to write SLOs that mean something, error budgets as a feature-velocity contract, multi-window multi-burn-rate alerts that don't page you at 3 AM for noise, and why availability % is harder than it looks.
~10 min
- How XSS Actually Works
Reflected vs stored vs DOM-based XSS, why innerHTML is the dragon, why escaping the wrong context fails (HTML attribute vs URL vs JS), DOMPurify, Trusted Types, and the actual CSP rules that block the most attacks.
~10 min
- How SQL Injection Actually Works
Classic UNION-based vs blind vs time-based injection, why string concatenation always loses, how prepared statements actually work at the wire level, why ORMs don't fully save you, and second-order injection through stored data.
~9 min
- How Secrets Management Actually Works
Why .env in git is the #1 leak source, Vault / KMS / cloud Secrets Manager, envelope encryption, rotation without downtime, short-lived dynamic credentials, and secret scanning (gitleaks, truffleHog) — the patterns that actually scale.
~9 min
- How Supply Chain Attacks Actually Work
npm typosquatting, dependency confusion, SolarWinds and Log4Shell as the modern playbook, the xz-utils backdoor, lockfile vs unpinned versions, SBOM (Software Bill of Materials), and the actual defenses (sigstore, npm provenance, dependabot).
~10 min
- How Encryption Actually Works
Symmetric (AES) vs asymmetric (RSA / ECC), why you never see RSA encrypting a file (hybrid encryption), block cipher modes (ECB pitfall vs GCM), key derivation (PBKDF2 / Argon2), at-rest vs in-transit, and the never-roll-your-own-crypto rule.
~10 min
- How the Testing Pyramid Actually Works
Unit / integration / E2E — why 70/20/10 isn't a law but a starting point, the ice cream cone anti-pattern, the testing trophy as a modern alternative, and how to pick the right shape for your codebase.
~9 min
- How Mocking Actually Works
Stub vs mock vs spy vs fake (Gerard Meszaros's four), why over-mocking gives you 100% coverage of nothing real, when to fake the network vs the DB, and how test doubles become coupling to internal implementation.
~9 min
- How Property-Based Testing Actually Works
Example-based vs property-based, generators + shrinkers (why the failing input becomes [] not [42, 17, 88]), QuickCheck / Hypothesis / fast-check, and the kinds of bugs only property tests find.
~9 min
- How Contract Testing Actually Works
Why microservice integration tests don't scale, consumer-driven contracts (Pact), provider verification, contract as a Git-versioned spec, and how it replaces the 'spin up 20 services for one test' nightmare.
~9 min
- How Flaky Tests Actually Work
The 5 root causes (race conditions, order dependency, time, network, shared state), why retrying a flaky test is the wrong fix, the cost to CI signal-to-noise ratio, and the systematic ways to find and kill them.
~9 min
- How Caching Actually Works
The two hard problems (invalidation + naming), cache hierarchy (CPU → browser → CDN → Redis → DB), cache-aside vs write-through vs write-behind, stampede / thundering herd, and why TTL alone won't save you.
~9 min
- How CDNs Actually Work
Edge POPs and BGP anycast, the actual flow on a cache miss, Cache-Control headers that matter (s-maxage / stale-while-revalidate), origin shield, purge by tag vs URL, and why your CDN is also your DDoS defense.
~9 min
- How Lazy Loading Actually Works
Code splitting (route-based + dynamic import), the IntersectionObserver API for images, prefetch vs preload vs lazy, why over-splitting hurts (TCP round-trips), and the patterns React Suspense / Next dynamic actually use.
~9 min
- How N+1 Queries Actually Work
The lazy-loading trap that produces 101 SQL queries from one user list, eager loading (JOIN, IN), DataLoader (Facebook's batching pattern), the GraphQL N+1 explosion, and why ORMs make this hidden by default.
~9 min
- How the Event Loop Actually Works
Call stack + task queue + microtask queue, why setTimeout(fn, 0) isn't actually 0, microtask starvation, libuv's thread pool in Node, the difference between browser and Node event loops, and how 'async' is just a sugar for the queue.
~9 min
- How React Server Components Actually Work
Server vs client component boundary, the 'use client' directive, RSC payload (not HTML, not JSON), streaming render, why props serialize but functions don't, and the bundle reduction RSC actually delivers.
~10 min
- How State Management Actually Works
Local vs global state, why Context API isn't a Redux replacement (re-render performance), Zustand vs Jotai vs Redux differences, server state vs client state (TanStack Query / SWR), and when 'no library' is the right answer.
~9 min
- How Hydration Actually Works
React attaching event handlers onto SSR HTML, the hydration mismatch error and what really triggers it, progressive / selective / partial hydration, island architecture (Astro / Qwik resumability), and why hydration is the cost of SSR's win.
~9 min
- How SSR, SSG, SPA, and RSC Actually Differ
Where the HTML is built (server / build / client), TTFB vs LCP vs interactivity trade-offs, the bundle size each model ships, when to pick what, and why 'Next.js App Router' is hybrid not pure RSC.
~10 min
- How the Virtual DOM Actually Works
VDOM as a snapshot, reconciliation diff (O(n) not O(n³)), React Fiber's interruptible scheduler, why the key prop matters, Vue's tracked-dep patch, and Svelte / Solid's no-VDOM signal approach.
~9 min
- How ETL and ELT Actually Differ
Extract-Transform-Load (the legacy) vs Extract-Load-Transform (the modern default), why cloud warehouses (BigQuery / Snowflake / Redshift) flipped the order, the cost shift from compute to storage, schema-on-write vs schema-on-read, and when ETL still wins.
~9 min
- How Data Streaming Actually Works
Batch vs streaming, Kafka / Kinesis / Pub-Sub, windowing (tumbling / sliding / session), watermarks for late events, exactly-once semantics — why it's hard, and the stream-table duality at the heart of Flink / Kafka Streams.
~10 min
- How Change Data Capture Actually Works
Log-based (MySQL binlog, Postgres WAL) vs trigger-based vs polling, Debezium as the de-facto open-source CDC, why CDC beats dual writes (consistency), the outbox pattern relationship, and downstream patterns (search index sync, cache invalidate, analytics).
~9 min
- How Data Lakes Actually Work
Data warehouse vs data lake vs lakehouse, S3 / GCS + Parquet columnar format, open table formats (Iceberg / Delta / Hudi) that bring ACID to a lake, schema-on-read flexibility and its swamp risk, and how Trino / Spark / DuckDB query it.
~10 min
- How Dimensional Modeling Actually Works
Kimball star schema, fact vs dimension tables, grain (the most important decision), slowly changing dimensions (SCD types 1-6), snowflake vs star, and why dbt + ELT made dimensional modeling popular again in 2020+.
~9 min
- How ML Training Pipelines Actually Work
Data ingestion → feature engineering → train → evaluate → register → deploy, why notebooks don't scale to production, MLflow / Kubeflow / SageMaker / Vertex AI, reproducibility (seeds, deterministic ops), the experiment-tracking problem.
~10 min
- How Feature Stores Actually Work
Online (low-latency) vs offline (batch) feature serving, point-in-time correctness (the time-travel problem at training time), Feast / Tecton / Databricks Feature Store, training-serving skew, and why feature stores are infrastructure, not a library.
~9 min
- How Model Serving Actually Works
TF Serving / TorchServe / Triton / vLLM, dynamic batching for throughput, GPU vs CPU trade-offs, quantization (FP16 / INT8) and what it costs in accuracy, blue-green / canary / shadow deploys, and why LLM serving is its own beast.
~10 min
- How A/B Testing Actually Works
Randomization (the magic), why 'peeking' invalidates p-values, sample size planning, sequential testing for early stopping, multi-armed bandits as the explore/exploit alternative, and the network effect / cross-experiment contamination traps.
~10 min
- How RAG Actually Works
Embeddings + vector DB (Pinecone / Weaviate / pgvector), chunking strategies and why naive splits fail, hybrid search (BM25 + vector), re-ranking, evaluation (the eval problem), and why RAG beats fine-tuning for most knowledge tasks.
~11 min
- How Load Balancers Actually Work
L4 vs L7 load balancing, the real differences between round-robin / least-connections / IP hash / weighted, health checks, sticky sessions (session affinity), and how the load balancer itself stays highly available with active-passive and anycast.
~10 min
- How Distributed Locks Actually Work
Why you need them (the race condition), Redis Redlock, ZooKeeper / etcd locks via leases and ephemeral nodes, fencing tokens, and the traps that break every naive implementation: clock skew, GC pauses, and network partitions.
~10 min
- How Pagination Actually Works
Offset/limit vs cursor (keyset) pagination, why deep offsets get catastrophically slow, the consistency problems of shifting and duplicate rows, and how to design a clean API with opaque cursors.
~10 min
- How Multi-Region Architecture Actually Works
Active-passive vs active-active, synchronous vs asynchronous replication and write conflicts, geographic latency, failover with DNS and health checks, split-brain, and data residency — the real trade-offs of running across regions.
~10 min
- How Feature Flags Actually Work
Flag types (release, ops/kill-switch, experiment, permission), gradual rollout (percentage and rings), how flags wire into A/B tests, flag debt and cleanup, and server- vs client-side evaluation with its consistency traps.
~10 min
- How REST Actually Works
Roy Fielding's actual REST — resources, representations, statelessness, the uniform interface, Richardson Maturity levels 0-3, HATEOAS, and why most APIs called 'REST' are really just JSON over HTTP.
~9 min
- How gRPC Actually Works
gRPC under the hood — HTTP/2 multiplexing, protobuf wire format, the four RPC modes (unary, server / client / bidirectional streaming), code generation, why it beats REST for internal services, and why browsers still need gRPC-Web.
~9 min
- How Server-Sent Events Actually Work
The text/event-stream protocol, the EventSource API, automatic reconnection with Last-Event-ID, when SSE beats WebSocket, and the real-world limits (one-way only, browser connection caps, proxy buffering).
~9 min
- How API Versioning Actually Works
Where to put the version (URL / header / Accept media type / query), SemVer and compatibility policy, deprecation procedure with the Sunset header, how to avoid breaking changes, and how Stripe / GitHub / AWS actually run versioning in production.
~10 min