Learn before you board.

Contiguous, index-addressable collections — the most common interview substrate. Master in-place manipulation, the two-pointer and sliding-window patterns, and the cost of resizing.

Nodes connected by pointers. O(1) insert/delete given a node, but O(n) access. Interview favourites: reversal, cycle detection, and merging — all done with careful pointer bookkeeping.

LIFO (stack) and FIFO (queue) access disciplines. They power expression parsing, backtracking, BFS, and the call stack itself. Know when each ordering is the right tool.

Hierarchical structures. Binary search trees give O(log n) search when balanced; self-balancing trees (AVL, red-black) guarantee it. Master the four traversals and recursion on trees.

Nodes connected by edges — the most general structure. Know adjacency representations, BFS vs DFS, and the classic algorithms: topological sort, shortest paths, and cycle detection.

Solve problems by combining solutions to overlapping subproblems. Identify the state, the recurrence, and the base cases; then choose memoization (top-down) or tabulation (bottom-up).

Systematic, depth-first exploration of all candidate solutions, abandoning a path the moment it can't lead to a valid answer. Powers permutations, combinations, N-Queens, Sudoku, and word search.

Know the trade-offs: comparison sorts bottom out at O(n log n); merge sort is stable, quicksort is in-place and fast in practice, and non-comparison sorts (counting/radix) beat O(n log n) under constraints.

Binary search is the workhorse: O(log n) on sorted data, and a pattern far beyond plain lookup — 'binary search on the answer' solves many optimization problems.

Average O(1) insert/lookup/delete by mapping keys to buckets via a hash function. Understand collisions, load factor, and why worst-case is O(n) — the structure behind most 'do it in one pass' tricks.

How to reason about large systems: scalability, latency vs throughput, caching, load balancing, and the trade-offs captured by CAP. Learn a repeatable framework for the design interview.

Model data well: normalization vs denormalization, indexing, transactions and ACID, and choosing SQL vs NoSQL. Good schema decisions prevent the worst production scaling pain.

Design clear, consistent, evolvable HTTP APIs: resource modelling, correct status codes and verbs, idempotency, pagination, versioning, and where REST fits versus GraphQL/gRPC.

The language of the web. Master closures, prototypes and `this`, the event loop and async/await, and how TypeScript's static types catch bugs before runtime.

Readable, batteries-included, dynamically typed. Know data types and comprehensions, mutability gotchas, generators, decorators, and the GIL's effect on concurrency.

Statically typed, object-oriented, runs on the JVM. Know the collections framework, JVM memory and garbage collection, concurrency primitives, and generics with type erasure.

The query language for relational data. Master joins, aggregation with GROUP BY/HAVING, subqueries and window functions, and how indexes shape query performance.

How the OS manages processes, threads, memory and I/O. Understand scheduling, concurrency hazards (deadlock, races), virtual memory and paging, and the process/thread distinction.

How data moves across the internet: the layered model, TCP vs UDP, what really happens in an HTTP request, DNS, TLS, and why latency and reliability are designed-for, not assumed.

Object-oriented design: encapsulation, inheritance, polymorphism, and abstraction — plus the SOLID principles and when composition beats inheritance.

The 'tell me about a time…' round. Learn the STAR method, build a story bank mapped to common competencies, and communicate impact with metrics — not vague generalities.