Node.js runtime internals, API design, databases, auth, and running services in production.
How Node executes JS: V8, libuv, the event loop phases, and the thread pool — the #1 Node interview topic.
CJS/ESM in Node, package.json anatomy, and dependency management.
Study this topicWorking with files, environment, arguments, signals, and child processes.
Study this topicProcessing data larger than memory — streams, backpressure, and binary data.
Study this topicThe observer pattern at Node's core and its error semantics.
Study this topicThe protocol under everything: methods, status codes, headers, and connection behavior.
Building servers with the two dominant Node frameworks and their design differences.
Resource modeling, URI design, and the constraints that make an API RESTful.
Study this topicEvolving APIs without breaking clients, and handling large collections.
Querying relational data confidently — joins, aggregation, and subqueries.
Schema design: normalization, keys, relationships, and when to denormalize.
Study this topicAuthN vs AuthZ, and the session-vs-token decision every system makes.
Structure, signing, refresh flows, and the well-known JWT pitfalls.
Study this topicStateful connections at scale: rooms, auth, and horizontal scaling.
Study this topicOne-way streaming over HTTP — the underrated real-time option (and how AI apps stream tokens).
Study this topicStructured logs, metrics, and health checks that make 3am debugging possible.
Study this topicUnit, integration, and contract tests for APIs with real databases.
Study this topicRequest lifecycle from socket to response: processes, threads, and async IO models. (Networking and Linux fundamentals live in the DevOps subject.)
Study this topictsconfig, ESM, and runners for Node services that build fast and run reliably.
Study this topicValidate at the edges, trust the inside: zod, branded types, and DTOs.
Study this topicWhat's now built in: native TS, test runner, fetch, and the permission model.
Study this topicRequest/Response-standard handlers that run on Node, edge, and workers alike.
Study this topicJSONB, arrays, full-text search, and row-level security — Postgres as more than tables.
Study this topicRankings, running totals, and the queries that separate SQL users from SQL writers.
Study this topicPassword-less auth: the ceremony flow, credential storage, and fallback UX.
Study this topicWhat changed from 2.0: PKCE everywhere, dead grants, and cleaner flows.
Study this topicS3 presigned URLs, multipart uploads, and media processing pipelines.
Study this topicStripe-style payments done safely: idempotency, webhooks, and reconciliation.
Study this topicPostgres FTS vs Elasticsearch vs Typesense — adding real search to a product.
Study this topicGetting data out of your OLTP database without dual-write bugs.
Study this topicThe standard for traces, metrics, and logs — instrumenting a real service.
Study this topicHeap snapshots, CPU profiles, and event-loop lag when it's on fire.
Study this topicPorts and adapters: keeping the core testable and frameworks replaceable.
Study this topicMonolith deployment, microservice discipline: boundaries without the network tax.
Study this topicStreaming pass-through, key isolation, and provider fallbacks.
Study this topicLong-running AI work: queues, checkpoints, and human-approval gates.
Study this topicCovers the basic shape of Rust programs: variables, mutability, control flow, functions, structs, enums, and pattern matching. This matters in interviews because you need to read and reason about Rust code quickly before discussing ownership or backend architecture.
The pipeline model: composing cross-cutting concerns cleanly.
Study this topicNever trust input: schema validation and a consistent error contract.
Study this topicA complete resource API: routes, service layer, persistence, and tests.
Study this topicContract-first development with OpenAPI and generated clients.
Study this topicFull-stack TypeScript contracts without codegen — router design, client usage, and honest limits.
Study this topicWhen GraphQL beats REST, and its costs — schema, resolvers, N+1.
Study this topicService-to-service RPC and push-style integrations.
Study this topicCorrectness under concurrency: isolation levels and their anomalies.
Why queries are slow and how indexes actually work.
Study this topicDocument databases: embedding vs referencing, aggregation, and indexes in Mongo.
Study this topicPrisma/Drizzle/Mongoose — productivity vs control, and ORM pitfalls.
Study this topicIn-memory data structures for caching, sessions, and rate limiting.
Study this topicDelegated authorization and social login flows.
Study this topicStoring credentials properly and account-security features.
Study this topicThe OWASP API Top 10 applied to real Node services.
Study this topicImplementing abuse protection and cross-origin access in Node services. (Scale-level algorithms and load shedding live in System Design.)
Study this topicMoving slow work out of the request path with queues and workers.
From one process to many: clustering, statelessness, and graceful operations.
Study this topicStreams end-to-end and what happens when consumers are slower than producers.
Study this topicOne codebase, many customers: isolation models and noisy-neighbor control.
Study this topicFunctions as your API tier: cold starts, connection limits, and queue glue.
Study this topicTyped errors that force handling: Result patterns vs exception hierarchies.
Study this topicThe alternative runtimes: what they change and when they matter.
Study this topicChanging schemas without downtime: expand/contract and migration discipline.
Study this topicPools, pgBouncer, and the serverless connection problem.
Study this topicSQL-first vs schema-first: choosing and using the two dominant TS ORMs.
Study this topicRBAC, ABAC, and relationship-based access — designing who-can-do-what at scale.
Study this topicSAML, OIDC, and SCIM — what B2B customers demand.
Study this topicTransactional email and multi-channel notifications that actually arrive.
Study this topicResilient integration clients: retries, circuit breakers, and sandbox testing.
Study this topicDomain-driven design pragmatically: aggregates, events, and shared language.
Study this topicThe checklist applied to modern Node deployments.
Study this topicMetering, budgets, and caching so the AI feature doesn't bankrupt you.
Study this topicExplains Rust's core memory model: moves, references, borrowing rules, and the basics of lifetimes. This is the most interview-relevant Rust topic because it directly explains why Rust prevents data races and many common memory bugs at compile time.
Focuses on Rust's approach to recoverable and unrecoverable errors using Result, Option, panic, and the ? operator. Interviewers often expect you to explain how Rust encourages explicit error handling in service code and how that improves reliability.
Covers how Rust expresses reusable behavior with traits and how generics enable flexible, high-performance code. This matters in backend interviews because traits often replace interfaces or dependency abstractions you may know from other languages.
Introduces Rust's concurrency model, Send and Sync, and the async/await ecosystem used in modern services. Interviewers may ask how Rust avoids data races, how async differs from threads, and what trade-offs come with async runtimes.
Connects core Rust knowledge to backend interview scenarios by showing how a small HTTP service is structured. This helps you discuss request handling, state management, configuration, and testing in a Rust backend context.