Interview preparation
UNDERSTAND. EXPLAIN. REPEAT.

Question library

Explained questions for the decisions developers make.

Browse the complete question directory

Answer technique

Scope & execution

Functions & objects

Async JavaScript

Runtime & modules

TypeScript

Output prediction

Node internals

Express lifecycle

HTTP & APIs

Authentication & security

Production engineering

Modules & dependency injection

Request lifecycle

Validation & authorization

Database integration

Background work & deployment

Data modeling

Indexes & query plans

Aggregation

Transactions & scaling

Mongoose

Query performance

SQL & joins

Window functions

Transactions & locking

Indexes & optimization

PostgreSQL & ORMs

Rendering & state

Hooks

State & performance

Next.js architecture

Security & deployment

Architecture & API design

Scaling & distributed systems

Messaging & reliability

Design scenarios

Performance

Security

Observability

Production incidents

Testing

Git

Docker

CI/CD

Cloud

Troubleshooting

Project discussion

Technical deep dives

Review reasoning

Code review exercises

Behavioral

Coding

Start here

AI and LLM fundamentals

Python for AI engineers

Embeddings

Vector databases and search

RAG, beginner to advanced

Agents and agent patterns

LangChain

LangGraph, in depth

Modern agent frameworks

Deterministic and agentic workflows

Workflow orchestration

Model Context Protocol (MCP)

AI memory

AI security

Guardrails

AI evaluation

AI observability

Cost and performance

AI gateways

Multimodal AI

Local AI

Fine-tuning

Cloud AI

MERN and AI

MongoDB and AI

AI system design

Insurance AI reference project

Practical project roadmap

Interview preparation

LLMs

Prompt engineering

RAG

Vector databases

LangGraph

AI agents

MCP

Microsoft Agent Framework

Workflows

Memory

Evaluation

Cost optimization

Python

FastAPI

Senior engineer decision framework

Interview revision cheat sheet

Foundations & core patterns

Linear data structures

Trees, heaps & graphs

Algorithms & problem-solving patterns

Advanced patterns & priorities

Interview practice & revision

Java implementations

JavaScript implementations

C# / .NET implementations

Python implementations

Foundations & responsibility boundaries

State, rules & graph execution

Scope, safety & external actions

Testing, reuse & architecture choices

Production lessons & implementation

Foundations & architecture

Protocol & lifecycle

Capabilities & transports

TypeScript implementation

Reliability & advanced features

Production, projects & interviews

Filters
660 questions

How should I explain a technical concept?

Interview skills·Answer technique

A good interview explanation gives the listener a usable understanding of a concept, not just a memorized definition. Start with what it is, why it exists and how it works at a basic level. Then connect the idea to an example, a mistake or a trade-off so the interviewer can follow your reasoning.

Foundation2 min read

What should I study first?

Interview skills·Answer technique

Preparation works best when later topics build on earlier ones. JavaScript scope and async behavior support Node and React; database rules support backend correctness and system design. Follow the sequence, but spend extra time where you cannot yet explain a concept without reading the answer.

Foundation2 min read

How do I answer a debugging question?

Interview skills·Answer technique

A debugging answer is an investigation plan that narrows a symptom to a cause using evidence. It should explain what you would measure, what the result would mean and what you would do next. Separate reducing user impact now from proving and preventing the underlying defect.

Foundation2 min read

What if I do not know an answer?

Interview skills·Answer technique

An honest answer can still show strong engineering judgment when part of a topic is unfamiliar. Clearly separate facts you know, assumptions you are making and details you would verify. This lets the interviewer assess your reasoning without being misled by confident guesses.

Foundation2 min read

How do I explain my own work?

Interview skills·Answer technique

A project answer should connect a real business problem with your specific contribution and its outcome. The problem → responsibility → action → result structure keeps the story clear without hiding technical details. Add the reason for an important decision and the trade-off you accepted.

Foundation2 min read

How can I reduce dependence on AI?

Interview skills·Answer technique

Reducing AI dependence means being able to understand, test and change a solution without treating generated output as authority. Use AI as a source of candidate ideas, then establish correctness through your own reasoning and evidence. The goal is independent judgment, not avoiding useful tools entirely.

Foundation2 min read

What is an execution context and call stack?

JavaScript & TypeScript·Scope & execution

An execution context is the information JavaScript uses while running a piece of code, including its variables, scope and this value. The call stack tracks which function is currently running and where execution should return. Each function call adds a context, and returning removes it.

Foundation2 min read

What is scope? What does lexical mean?

JavaScript & TypeScript·Scope & execution

Scope is the part of a program where a variable can be accessed. JavaScript uses lexical scope, which means the available outer variables depend on where a function was defined, not where it is later called. The engine searches outward through surrounding scopes when a name is not found locally.

Foundation2 min read

What is the difference between var, let and const?

JavaScript & TypeScript·Scope & execution

var, let and const declare variables, but they have different scope and initialization rules. let and const are block-scoped, making it easier to keep a variable inside the code that needs it. const prevents reassignment of the binding; it does not make an object immutable.

Foundation2 min read

What are hoisting and the TDZ (Temporal Dead Zone)?

JavaScript & TypeScript·Scope & execution

Hoisting is JavaScript's behavior of processing declarations before executing the code in a scope. Because of this, a function declaration can usually be called before its line appears, while variables behave differently depending on how they are declared.

Foundation2 min read

Are objects passed by reference?

JavaScript & TypeScript·Scope & execution

JavaScript passes every argument by value. For an object, the copied value is a reference to that object, so the caller and function can still reach the same underlying object. This explains why changing a property affects the caller, but assigning a new object to the parameter does not.

Foundation2 min read

What is the difference between == and ===?

JavaScript & TypeScript·Scope & execution

== is loose equality: it may convert values to compatible types before comparing them. === is strict equality: it compares without that conversion. Strict equality usually makes application checks easier to understand because strings, numbers and booleans are not silently treated as the same value.

Foundation2 min read

What are null, undefined and NaN?

JavaScript & TypeScript·Scope & execution

undefined usually means a value has not been supplied, while null is commonly used to mark an intentionally empty value. NaN means a numeric calculation or conversion did not produce a valid number. These are different cases, so an API should not treat them as interchangeable without a clear rule.

Foundation2 min read

What is a closure?

JavaScript & TypeScript·Functions & objects

A closure is a function together with access to the variables in the scope where it was created. That access remains available even after the outer function has finished running. Closures are useful for private state, callbacks and functions configured with some remembered value.

Foundation2 min read

How does this work? How are arrow functions different?

JavaScript & TypeScript·Functions & objects

this is the receiver used when a regular function runs, and its value usually depends on how the function is called. Arrow functions do not create their own this; they use the surrounding one. This matters when a method is passed as a callback and loses its original receiver.

Intermediate2 min read

How do prototypes and classes work?

JavaScript & TypeScript·Functions & objects

A prototype is an object from which another object can inherit properties and methods. When a property is missing on an object, JavaScript follows its prototype chain until it finds the property or reaches null. Classes provide structured syntax for constructing objects and sharing methods through that mechanism.

Intermediate2 min read

How does async JavaScript run?

JavaScript & TypeScript·Async JavaScript

Asynchronous JavaScript lets a program start work that may finish later without waiting synchronously for the result. A promise represents eventual completion, and async/await provides a readable way to work with promises. The runtime queues continuations and runs them when the current synchronous work has finished and the relevant checkpoints are reached.

Intermediate2 min read

Which Promise method should I use?

JavaScript & TypeScript·Async JavaScript

Promise combinators combine several promises into one result. The correct method depends on whether you need every success, every outcome, the first outcome or the first success. They observe promises; they do not automatically cancel ongoing operations when the combined result settles.

Intermediate2 min read

Difficulty is an editorial estimate. Completion means you chose to mark a question as understood.