Tracks

Every language, framework, database and cross-cutting skill we grade, and how much of each is ready.

Languages

  • C#Live

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

    120 questions
  • JavaBeta

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

    80 questions
  • PythonBeta

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

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

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

    80 questions
  • GoComing soon

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

    0 questions
  • PHPComing soon

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

    0 questions
  • RubyComing soon

    Blocks, modules, metaprogramming basics and idiomatic Ruby.

    0 questions
  • RustComing soon

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

    0 questions
  • C++Coming soon

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

    0 questions
  • KotlinComing soon

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

    0 questions
  • SwiftComing soon

    Optionals, value types, protocols and concurrency in Swift.

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

    120 questions

Frameworks

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

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

    80 questions
  • DjangoComing soon

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

    0 questions
  • FastAPIComing soon

    Pydantic models, dependency injection, async endpoints and OpenAPI.

    0 questions
  • Node.jsComing soon

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

    0 questions
  • ExpressComing soon

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

    0 questions
  • NestJSComing soon

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

    0 questions
  • ReactBeta

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

    80 questions
  • Next.jsComing soon

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

    0 questions
  • VueComing soon

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

    0 questions
  • AngularComing soon

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

    0 questions
  • LaravelComing soon

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

    0 questions
  • Ruby on RailsComing soon

    ActiveRecord, conventions, controllers, callbacks and background jobs.

    0 questions
  • FlutterComing soon

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

    0 questions
  • React NativeComing soon

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

    0 questions

Databases

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

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

    120 questions
  • MySQLBeta

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

    80 questions
  • Oracle (PL/SQL)Coming soon

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

    0 questions
  • SQLiteComing soon

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

    0 questions
  • MongoDBComing soon

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

    0 questions
  • RedisComing soon

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

    0 questions
  • ElasticsearchComing soon

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

    0 questions
  • CassandraComing soon

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

    0 questions

Cross-cutting

  • Data structures & algorithmsComing soon

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

    0 questions
  • System designComing soon

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

    0 questions
  • REST & API designComing soon

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

    0 questions
  • GitComing soon

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

    0 questions
  • Docker & KubernetesComing soon

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

    0 questions
  • Testing & TDDComing soon

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

    0 questions
  • Security / OWASP Top 10Coming soon

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

    0 questions
  • Concurrency & threadingComing soon

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

    0 questions
  • Message queuesComing soon

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

    0 questions
  • Cloud fundamentals (AWS/Azure)Coming soon

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

    0 questions