Intermediate everything in Backend Dev, page 5
Why package-lock.json must be committed
Lockfile pins exact versions of the whole dependency tree including transitive deps; guarantees identical installs across machines and CI.
Offloading CPU-bound work with Worker Threads
Synchronous CPU work freezes the loop and all requests; offload to a Worker, communicate via messages or SharedArrayBuffer, use a pool.
nextTick vs setImmediate vs setTimeout(fn, 0)
NextTick is a microtask that drains before the loop continues; setImmediate runs in check; setTimeout(0) in timers.
Order of the Node.js event loop phases
Timers, pending callbacks, poll, check, close phases in order; I/O completion runs in poll.
Diagnosing high Redis eviction and cache misses
Use INFO memory and stats to confirm pressure, check fragmentation ratio, pick LFU over LRU for skewed access, set sane TTLs.
Modeling IoT data with tags and fields
Tags are indexed identifying metadata, fields are unindexed measured values, and tag cardinality drives memory.
Problems the Lakehouse architecture solves
Lakehouse adds ACID transactions, schema enforcement, and time travel on cheap object storage.
Why choose Kafka over a REST endpoint for ingestion
Kafka buffers spikes, decouples producers from consumers, replays and fans out durably.
Cutting managed database costs without breaking SLOs
Pool connections, prune and tune indexes, offload reads, tier or partition cold data, right-size storage IOPS.
Designing an HA/DR strategy for an OLTP database
Sync standby in-region for zero data loss, async cross-region for DR, automated failover with a quorum.
Diagnosing and optimizing a slow production query
Read the EXPLAIN ANALYZE plan, find the costly node, then fix via indexing, rewrite, or stats.
Optimizing queries on a billion-row fact table
Partition to prune scans, index for selective lookups, materialize views to precompute aggregates; each adds write or maintenance cost.
Logical vs physical query plans and the optimizer
Logical plan says what (relational algebra, no algorithms); physical plan says how (specific operators); cost-based optimizer enumerates physical options and picks the cheapest using statistics.
How databases implement GROUP BY aggregation
Hash aggregation builds a hash table keyed by group holding running aggregates; sort aggregation orders rows then aggregates adjacent groups; optimizer picks based on data and memory.
The Volcano iterator model of query execution
Each operator exposes open/next/close, parents pull tuples from children, uniform composable interface, pipelined low memory.
Phantom reads and how serializable prevents them
New rows matching a predicate appear between reads; classic Repeatable Read locks existing rows not ranges; Serializable uses range or predicate locks.
Choosing a time-series database for metrics
High-ingest timestamped writes, time-window queries, retention and downsampling, time-optimized compression.
Diagnosing database latency layer by layer
Split total time into pool-wait, query execution, and ORM-generated query patterns; use metrics at each layer.
Sessionizing clickstream events into sessions
Order events per user, split on inactivity gap, assign session ids, pick event or session grain.
Vectorized query execution and its speedups
Process column batches per operator call, amortize per-tuple overhead, use cache locality and SIMD.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles