Programming Languages & Core Development Topics
Programming languages, development fundamentals, coding concepts, and core data structures. Includes syntax, algorithms, memory management at a programming level, asynchronous patterns, and concurrency primitives. Also covers core data manipulation concepts like hashing, collections, error handling, and DOM manipulation for web development. Excludes tool-specific proficiency (see 'Tools, Frameworks & Implementation Proficiency').
Asynchronous and Event-Driven Programming
Non-blocking execution models: callbacks, promises and futures, async/await, event loops, and event-driven and reactive architectures. Covers reasoning about ordering, back-pressure, and error propagation in asynchronous flows, including data-fetching patterns. Central to modern frontend, backend, and mobile runtimes.
Java Programming
The Java language and platform: type system, collections framework, generics, exceptions, the memory and JVM model, and idiomatic object-oriented Java. Covers writing correct Java and reasoning about its runtime and language semantics. A staple server-side and test-automation language surface.
Programming Fundamentals
Language-agnostic building blocks of writing code: variables, primitive and composite data types, scope and lifetime, functions and callbacks, control flow, and expressions versus statements. Covers the mental model a candidate needs before any language-specific or algorithmic depth. The baseline literacy layer of a technical screen.
Error Handling and Defensive Programming
Making code robust against bad input and failure: exceptions versus error returns, input validation, guard clauses, graceful degradation, and designing for the unhappy path. Covers where to handle versus propagate errors and how to fail safely without hiding bugs. A recurring probe of production maturity.
JavaScript and TypeScript Fundamentals
The JavaScript and TypeScript language surface: scope, closures, the this binding, prototypes and inheritance, the type system, modern ES features, and common language patterns. Covers the deep language-mechanics questions frontend and full-stack interviews lean on, independent of any framework. TypeScript's static typing is treated as an extension of the same core.
Programming for Test Automation
General Java and Python language proficiency questions where the test-engineering framing is load-bearing: it changes what is actually being assessed, not just the flavor text. Covers designing for testability (polymorphism and interchangeable implementations so a test harness can substitute a fake), how exception-handling choices change what a test for that failure path looks like, choosing the right collection for test-result processing, methodology for testing concurrency correctness (writing a test that can actually reveal a race or a visibility bug, not just fixing one), serialization and diffing trade-offs for test fixtures and CI artifacts, detecting a hash/equality-contract violation through testing, memory-bounded generator and streaming I/O patterns for test data, and small test-engineering utilities (CI-config diffing, checksum-verified data sharding). Excludes writing or debugging the code inside a single automated test script (control flow, parameterization, translating a manual case, locator, wait, and retry mechanics), which belongs to test automation scripting. Excludes suite-wide or framework-wide structural and strategy decisions (Page Object Model, layering, tool or driver choice, CI wiring, governance, flaky-test-detection systems, scalable test infrastructure), which belongs to test automation framework architecture and design. Excludes classic array/string/graph technique problems with no real test-engineering judgment required, which belong to arrays, strings, and hashing. Also excludes generic OOP-principles surveys, generic concurrency-primitive implementation (singletons, thread pools, producer-consumer queues, lock-free structures) with no distinct testing angle, generic garbage-collection and memory-leak content, generic functional-programming surveys, and generic hash-function or hash-table design: each of these already has a dedicated, larger topic in the catalog (Object-Oriented Programming and Design, Concurrency Synchronization and Deadlock, Memory Management and Garbage Collection, Functional Programming, Hashing and Hash Tables), and a test-flavored costume on otherwise-identical content is not a reason to duplicate it here.
Shell Scripting and Automation
Automating tasks with the command line: Bash and shell scripting, pipes and redirection, text processing, and writing custom tooling and monitoring scripts to glue systems together. Covers the scripting fundamentals infrastructure and platform engineers use daily, including automation-oriented use of general-purpose scripting. Distinct from application programming in its throwaway-to-durable tooling mindset.
Clean Code, Refactoring, and Maintainability
Writing code that other people can read, change, and keep alive over time: naming, function and module decomposition, avoiding duplication, readability, disciplined use of language idioms and design patterns, and recognizing code smells, extending into working effectively in large, aging, or unfamiliar codebases through safe incremental change, refactoring under test coverage, and managing technical debt. Covers both authoring professional-grade code beyond mere correctness and improving code you cannot rewrite without breaking it. Spans the coding-round quality signal and the seniority signal of leaving a codebase healthier than you found it.
Debugging and Performance Optimization
Finding and fixing what is wrong or slow: systematic debugging strategies, reading stack traces, profiling to locate hotspots, and optimizing execution time and memory. Covers reasoning from symptom to root cause and measuring before optimizing, including runtime, memory, and profiling analysis. Tests how a candidate operates on code they did not write.