Intervues · Changelog
We do not maintain a separate semver changelog with invented release notes. This index lists journal posts where we document what shipped, what changed, and what we decided not to build.
The N+1 Query Problem: Why One API Request Can Trigger Hundreds of Database Queries
— One API request that returns 100 products can quietly fire 301+ database queries — one for the list, then one each for sellers, inventory, reviews and categories. That's the N+1 query problem. This covers what causes it, how ORM lazy loading triggers it, how to detect it in production by counting queries per request, and how to fix it with eager loading, JOINs, batching and DataLoader — with the trade-offs of each.
Redis Is Single-Threaded. So Why Is It So Fast?
— Redis runs your commands on one main thread — and still serves huge request volumes with low latency. This explains why: in-memory data access, an event-driven I/O loop that multiplexes thousands of connections, and lightweight sequential command execution that needs no locks. Plus the catch — how one expensive command stalls everyone — and how to explain Redis's single-threaded architecture in a backend interview.
— A queue doesn't make work faster — it makes work survivable. Sync vs async by user expectation, decoupling and burst absorption, queue depth as a latency metric, consumer scaling and backpressure, retries with exponential backoff and jitter, at-least-once delivery and idempotency, poison messages and the DLQ, lost ordering, and the eventual consistency you're signing up for.
Caching Isn't Just About Speed — Cache-Aside, TTL, Invalidation, Stampedes and Hot Keys Explained
— Caching isn't a latency trick — it's a load-shedding mechanism that removes work from your constrained layer. Hit ratios and why 95%→99% matters, cache-aside, TTL and invalidation, the caching layers, LRU eviction and warming, stampedes and the thundering herd, hot keys, and the cache-miss storm that turns an optimization into an outage.
— The bottleneck almost always migrates to the database, because it's the one layer you can't make stateless. Read/write ratios, the five things that saturate a database, query plans and N+1s, read replicas and replication lag, partitioning, sharding, and the cost ladder to climb in order.
Adding More Servers Won't Save You: Understanding Horizontal Scaling, Load Balancing & Bottlenecks
— Adding servers raises capacity at one layer — the bottleneck just migrates. A first-principles walk through horizontal scaling, load balancing, stateless design, shared dependencies, and finding the component that actually limits throughput.
— Scalability isn't Kubernetes or more servers. It's how your system behaves when the work increases — load, RPS, concurrency, throughput, latency, bottlenecks, saturation, and capacity planning, built up from first principles.
AI Interview Practice: Why Speaking Your Answer Matters More Than Just Knowing It
— You can know the answer and still give a bad interview. The gap that costs candidates offers isn't knowledge — it's saying what they know, out loud, under pressure.
Beating the hidden scorecard — a drill for each of the six rows
— Interviewers grade you on six rows you never see — depth, consistency, coverage, structure, recovery, presence. Here is one concrete drill for each, from someone who filled out two hundred of those cards.
The psychology of an interviewer
— What's actually going through their head while you talk — from someone who's sat in that chair 50+ times.
Cracking the interview: tactics that actually work
— Real techniques that move the needle — none of which involve gaming the system.
Structured screening without the phone-screen treadmill
— CSV in, ranked shortlist out — one identical interview for every candidate, every score cited to evidence.
— I optimized for what candidates think they need — question banks and scores — when the real gap was voice. Here's what changed when I corrected the assumption.
— Knowing the answer and saying it out loud under pressure are different skills. Most candidates fail on the second, not the first.
Six months teaching AI to interview
— Five hard lessons from building a voice interviewer — accent, silence, memory, feedback, and the gap that isn't technical at all.
If you need a copilot to pass, you'll need one on the job
— Live interview copilots feed you answers during the real call. If you need one to pass, you'll need one to do the job.
— The gap that costs candidates the most isn't technical knowledge — it's translating knowing into saying out loud under pressure.
Why a patient interviewer matters
— Most AI interviewers treat silence as failure. We built the opposite — a five-tier silence ladder calibrated for Indian English.
Why interview copilots are the wrong answer
— Interview tools split into two camps — live copilots that feed you answers during the interview, and honest practice that helps you earn them before it.