Systems & Production

How to separate the main thread, event loop, I/O, libuv, and worker threads without repeating a sentence that hides the real behavior.

Modern interviews still reward fundamentals, but they now lean harder on judgment, communication, debugging, system design, and responsible AI use.

A simple protocol for answering system design from start to finish with clarity under pressure.

How to do capacity estimation in system design without panicking or pretending false precision.

How to turn business rules into entities, relationships, and constraints that stay useful in real systems.

How to choose storage by looking at access patterns, consistency, data shape, and operational cost.

How to think about cache as a copy with a consistency cost, not as a magic patch for slow reads.

How to think about scale by starting with what breaks first and why.

How to design boundaries between routes, services, and responsibilities without turning the system into a pile of hidden coupling.

How to choose between retrieval and fine-tuning by looking at the actual failure mode in the system, not at hype.

When to use a queue instead of a synchronous call, what the main patterns mean, and why that changes the architecture in production.

How to understand when replication helps, when sharding enters the conversation, and why they solve different problems.

How to think about rate limiting as shared capacity protection, which strategies exist, and what actually matters in practice.

How to decide where each request goes without treating the load balancer like a magic box in the diagram.

The useful part of CAP starts when parts of the system stop seeing each other and you need to decide whether to wait or keep responding.

How to decide when stale data is acceptable and when it becomes a product error.

What idempotency is, why it matters in distributed systems, and how to implement it so unstable networks do not corrupt data.

How consistent hashing reduces the chaos of redistributing keys when a node enters or leaves the cluster.

How to investigate a real production problem with a clear process for evidence, containment, and communication.

How to write logs that actually help during an investigation instead of flooding the system with expensive text.

How to make timing failures easier to understand by making ordering, concurrency, and shared state visible.

How to investigate broken code with order, hypothesis, and a clear next step under uncertainty.

How to decide whether a new layer is helping or whether the code is still better when it stays direct.

How to share logic and structure without turning the code into a fragile web of dependencies that is expensive to understand and change.