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').
Modern JavaScript/TypeScript Fundamentals
ES6+ features (arrow functions, destructuring, spread operator, async/await, promises), closures, prototypes, and this binding. TypeScript basics including interfaces, generics, and type narrowing. Understanding of functional vs object-oriented paradigms.
Browser APIs and Web Platform
Practical knowledge of core browser platform features and their performance, security, and reliability trade offs. Topics include the Document Object Model for traversal and manipulation, event handling and delegation, storage APIs such as local storage and IndexedDB, the Fetch API and XMLHttpRequest, IntersectionObserver and ResizeObserver for efficient rendering, Web Workers and service workers for background tasks, and considerations around serialization, thread boundaries, and resource limits. Candidates should also be able to measure and debug platform interactions and reason about when to use a particular web platform primitive.
Modern JavaScript Fundamentals
Focuses on modern JavaScript language features, semantics, and runtime behavior used in frontend and general JavaScript development. Topics include ES2015 and newer syntax and constructs such as arrow functions, destructuring, spread and rest operators, template literals, let and const scoping, classes, and modules. Also include asynchronous programming patterns and runtime concepts such as Promises, async and await, the event loop, callback queue and microtask queue, closure, scope and hoisting, prototypal inheritance and the this keyword, and common browser concerns such as event handling, basic DOM manipulation, and interaction with browser APIs. Interviewers assess both conceptual understanding and practical usage, including debugging and choosing idiomatic patterns.
Basic Data Structures (Objects, Maps, Sets)
Understand how objects work in JavaScript including prototypal inheritance and property descriptors. Know when to use Maps vs Objects and Sets vs Arrays. Understand the performance characteristics of different data structures. Be comfortable with nested data structures and how to manipulate them efficiently.
JavaScript Fundamentals and Design Patterns
Assess deep understanding of the JavaScript language and how to architect maintainable modular code without relying solely on frameworks. Topics include closures the prototype chain this binding scoping and the event loop including microtask and macrotask behavior. Expect questions on asynchronous patterns such as callbacks promises and async await error propagation and cancellation and on DOM event delegation and manipulation. Candidates should also explain common design patterns such as Observer Module Singleton Factory and when to apply them to build testable performant vanilla JavaScript solutions.
Functional Programming Utilities Curry, Partial, Memoization
Implement functional programming utilities like curry (transform function with multiple arguments into series of functions with one argument each), partial application (preset some arguments), and memoization (cache function results). Understand use cases for each pattern. Discuss performance trade-offs, cache invalidation, and serialization challenges for memoization. Understand how these patterns improve code composition and reusability.
Asynchronous JavaScript and Event Loop
Comprehensive understanding of asynchronous programming in JavaScript including callback functions and the pitfalls of callback nesting, Promises including their lifecycle and state transitions, promise chaining, and common utility methods such as Promise.all, Promise.race, and Promise.allSettled. Knowledge of async and await as syntactic sugar over Promises, proper error handling patterns using try catch and promise catch, and avoiding unhandled rejections. Practical skills for working with multiple concurrent operations such as coordinating parallel requests, implementing retry logic, rate limiting, throttling and debouncing of async calls, and handling race conditions. Deep understanding of the JavaScript event loop model including the call stack, task queue, microtask queue, the ordering of macrotasks versus microtasks, how timers and promise callbacks are scheduled, and how this affects concurrency and ordering. Familiarity with implementing a simplified Promise from first principles to demonstrate internal behavior, diagnosing timing and ordering bugs, and designing solutions for real world asynchronous flows and performance considerations.
JavaScript Language Specifics
Assess detailed knowledge of JavaScript language features and idioms used to implement algorithms and user interfaces. Topics include native array and string methods and their performance characteristics, functional patterns such as map filter and reduce, object and collection usage including Set and Map, closures and lexical scope, prototype based inheritance, the event loop and asynchronous programming with promises and async await, memory and performance implications, writing efficient loops and handling edge cases, debugging strategies, and reasoning about time and space complexity when selecting data structures.
Error Handling and Defensive Programming
Covers designing and implementing defensive, fault tolerant code and system behaviors to prevent and mitigate production failures. Topics include input validation and sanitization, null and missing data handling, overflow and boundary protections, exception handling and propagation patterns, clear error reporting and structured logging for observability, graceful degradation and fallback strategies, retry and backoff policies and idempotency for safe retries. Also address concurrency and synchronization concerns, resource and memory management to avoid exhaustion, security related input checks, and how to document and escalate residual risks. Candidates should discuss pragmatic trade offs between robustness and complexity, show concrete defensive checks and assertions, and describe test strategies for error paths including unit tests and integration tests and how monitoring and operational responses tie into robustness.