Tracks

Types, collections, LINQ, async and the language features .NET interviewers probe first.

Core language, collections, generics, streams, concurrency primitives and the JVM basics.

The Python interviewers expect: data model, comprehensions, generators, typing and the standard library.

Closures, the event loop, prototypes, promises and the quirks that trip people up in front-end loops.

The type system beyond annotations: narrowing, generics, utility types, and how to model real domains.

Goroutines, channels, interfaces, error handling and the idioms Go reviewers care about.

Modern PHP: types, OOP, Composer, error handling and the runtime model.

Blocks, modules, metaprogramming basics and idiomatic Ruby.

Ownership, borrowing, lifetimes, traits and error handling without a garbage collector.

Memory, RAII, templates, the STL and modern C++ features.

Null safety, coroutines, data classes and Kotlin idioms on the JVM and Android.

Optionals, value types, protocols and concurrency in Swift.

Engine-agnostic SQL: the joins, aggregates, subqueries and set logic every data interview starts with.

Dependency injection, the middleware pipeline, EF Core, auth and the questions every .NET backend loop asks.

Beans, auto-configuration, Spring MVC, Data JPA, security and testing.

ORM, migrations, views, middleware, forms and Django REST Framework.

Pydantic models, dependency injection, async endpoints and OpenAPI.

The runtime: event loop, streams, modules, process model and performance.

Routing, middleware, error handling and structuring an Express API.

Modules, providers, DI, pipes, guards, interceptors and testing in Nest.

Rendering, hooks, state, effects, performance and the mental model behind them.

App Router, server components, rendering modes, caching and data fetching.

Reactivity, the Composition API, components, routing and state.

Components, DI, RxJS, change detection, forms and routing.

Eloquent, routing, middleware, queues and the service container.

ActiveRecord, conventions, controllers, callbacks and background jobs.

Widgets, state management, layout, navigation and platform channels.

The bridge, native modules, navigation, styling and performance on mobile.

T-SQL, indexing, execution plans, isolation and the tuning questions SQL Server shops ask.

Joins, window functions, EXPLAIN, MVCC, indexes and PostgreSQL-specific features.

InnoDB, indexing, EXPLAIN, isolation levels and MySQL specifics.

PL/SQL, packages, cursors, optimizer hints and Oracle-specific SQL.

The embedded database: typing, transactions, indexes, WAL and its limits.

Document modelling, the aggregation pipeline, indexes, transactions and replication.

Data structures, caching patterns, persistence, pub/sub and cluster.

Inverted indexes, mappings, analyzers, queries, aggregations and cluster basics.

Partitioning, consistency levels, query-first modelling and compaction.

Complexity, arrays, hashing, trees, graphs, sorting and the patterns behind coding rounds.

Scaling, caching, queues, consistency, storage choices and the trade-offs behind them.

The stories interviewers ask for: ownership, conflict, failure, ambiguity and impact, told in STAR.

Resources, verbs, status codes, versioning, pagination, idempotency and errors.

Branching, merging, rebasing, history surgery and collaboration workflows.

Images, layers, networking, volumes, then pods, services, deployments and scaling.

The test pyramid, TDD, mocks vs fakes, flaky tests and what to test at each layer.

Injection, auth failures, XSS, CSRF, secrets, crypto basics and secure defaults.

Threads vs async, races, locks, deadlocks, memory models and safe patterns.

Brokers, delivery guarantees, ordering, idempotency, dead letters and event-driven design.

Compute, storage, networking, IAM, managed databases, serverless and cost.