Software Engineering Fundamentals interview questions

Showing 121–150 of 1208 results

• Reuse Work Across Multiprocess Image PipelinesMedium

  Implement a thread-safe pipeline execution engine that caches deterministic intermediate prefix results, deduplicates concurrent in-flight computations, and manages a bounded LRU cache.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Review and Improve Four AI-Assisted TypeScript Pull RequestsHard

  Tests code review rigor, ability to audit AI-generated code for subtle regressions and security/type soundness, and hands-on refactoring with test-driven verification.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Same-Host Web Crawler: Single-Threaded, Then Concurrent with a Thread-Safe Visited SetMedium

  Build a web crawler that starts from one URL, follows links only on the same hostname, strips URL fragments and fetches each page once, first single-threaded and then concurrently. It tests graph traversal, URL normalization, a thread-safe visited set and correct termination of concurrent work.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Scale a Thumbnail-and-Watermark Pipeline With Worker ProcessesMedium

  Design a batch pipeline that produces a resized thumbnail with a corner watermark for every uploaded photo, then extend it to run across a bounded pool of worker processes. Tests resource lifecycle, atomic output writes, per-item failure isolation, and what to pass between processes.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain core Java and Spring fundamentalsEasy

  This question evaluates core competencies in Java and Spring, covering data structures and collections, object-oriented design (SOLID), hash-based collections and concurrency primitives, immutability and string handling, exception handling, Spring IoC/DI and AOP, bean lifecycle and annotations, and functional collection processing via the Stream API. Commonly asked in Software Engineering Fundamentals interviews for backend Java/Spring roles, it checks both conceptual understanding and practical application by assessing architectural reasoning, concurrency and thread-safety knowledge, and familiarity with framework conventions and APIs.

  AntraSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Java and Object-Oriented Design FundamentalsMedium

  This problem tests your understanding of interface design, the Liskov Substitution Principle, and proper usage of Java Collections in a Spring-managed context.

  AntraSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• ASIC Verification Fundamentals Across SystemVerilog UVM CDC and ArchitectureHard

  Review a broad ASIC verification set covering SystemVerilog semantics, UVM lifecycle and communication, random constraints, clock-domain crossing, FIFO sizing, timing, clock division, cache coherence, and pipeline hazards. Strong responses distinguish simulation from hardware, define assumptions, derive quantities, compare trade-offs, and use precise examples.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Answer OoO, caches, and memory-system questionsMedium

  This question evaluates core computer-architecture and system-level skills—covering out-of-order execution structures, branch prediction (gshare) mechanics, register renaming/RAT tracing, VLIW versus superscalar tradeoffs, cache coherence protocols, load/store subsystem behavior, copy-on-write after fork, cache indexing math, VIPT aliasing, and asynchronous FIFO design—and is categorized under Software Engineering Fundamentals. It is commonly asked because it probes a candidate’s microarchitectural and OS understanding, performance reasoning, and ability to explain low-level (microarchitecture and system-level) concepts and interactions without requiring full ISA-specific implementations.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Build an Accessible Recursive Expand-and-Collapse Tree in ReactMedium

  This problem tests recursive component design in React, state management for nested data structures, and the implementation of WAI-ARIA standards for accessible UI components.

  AppleFrontend EngineerSoftware Engineering FundamentalsTechnical Screen
• Cafe Open-Now Check: Split Shifts and Midnight-Crossing HoursEasy

  Build an 'is the cafe open right now' check across three stages of growing complexity -- one fixed daily window, then select weekdays, then multiple shifts per day including windows that cross midnight. Tests clean incremental time modeling more than any single clever algorithm.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Describe common RTL lint warnings and errorsMedium

  This question evaluates understanding of RTL static analysis and common lint warnings/errors in Verilog/SystemVerilog, testing competence in diagnosing issues such as modules treated as black boxes, combinational loops, and width mismatches.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a Population-Weighted Random Country PickerMedium

  This problem tests your ability to implement a weighted sampling algorithm efficiently and write testable code by decoupling randomness.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Design a deck of cards with shuffle/drawMedium

  This question evaluates object-oriented design skills, understanding of randomness and probability in algorithms, and analysis of time/space complexity for data structures and operations.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Diagnose Cold-Load and Massive-Table Performance in a Web AppMedium

  This problem tests your understanding of critical path rendering optimization for cold loads and memory management strategies for handling massive datasets in a browser environment.

  AppleFrontend EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain HashMap Resizing Without Long PausesMedium

  This question evaluates understanding of hash map internals—how keys are mapped to buckets, collision resolution strategies, and when and why resizing occurs—testing competence in data structures and performance engineering within the Software Engineering Fundamentals domain.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain How TLS Secures a Connection: Handshake, Certificates and KeysHard

  Explain in detail how TLS establishes a secure connection and protects the data that follows: the handshake messages and round trips, certificate chain validation, ephemeral key exchange and key derivation, record encryption, forward secrecy, and how TLS 1.3 differs from TLS 1.2.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain JavaScript Scope, Closures, Timers, and the Event LoopMedium

  Tests deep understanding of the JavaScript runtime, specifically lexical scope, closures, the distinction between task and microtask queues in the event loop, and browser script loading mechanics.

  AppleFrontend EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain Runnable vs Callable and thread-safe SingletonMedium

  This question tests the conceptual differences between Java concurrency interfaces and the practical implementation of thread-safe creational design patterns.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain SystemVerilog verification concepts and write constraintsMedium

  This question evaluates proficiency with SystemVerilog verification concepts — including concurrency primitives, constrained-random modeling, assertions, OOP features, synchronization primitives, and testbench architecture — and tests the ability to specify non-overlapping/randomized constraints and reason about solve-order and sampling semantics; it is commonly asked because interviewers seek assurance that a candidate can build correct constrained-random testbenches and diagnose simulation or coverage issues. Category/domain: Software Engineering Fundamentals with a focus on hardware design verification; level of abstraction: language-level implementation details and testbench architecture/behavioral verification concerns.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain key React concepts and error handlingMedium

  This question assesses a candidate's deep understanding of the React ecosystem, covering reconciliation, hook lifecycles, and robust error management strategies.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain thermal and signal fundamentalsHard

  This question tests the ability to bridge hardware constraints with firmware design, covering thermal management, signal integrity, communication protocol trade-offs, and data interpretation.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Explain use cases for clock synchronizersMedium

  This question evaluates understanding of clock domain crossing and digital system design competencies, focusing on metastability, synchronization techniques (such as flip-flop synchronizers, edge detection, asynchronous FIFOs, and request/acknowledge handshakes) and the trade-offs among reliability, latency, throughput, and area.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Give a Kubernetes Pod a Token to Call an External Service SecurelyMedium

  Decide how a Kubernetes pod should obtain a token for calling an external service. Tests knowledge of Secrets delivered as volumes or environment variables, RBAC and encryption at rest, external secret managers, workload identity with projected service account tokens, and rotating the token without downtime.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• How to debug a Python loop-condition bugMedium

  This question evaluates debugging skills and understanding of loop termination and control-flow correctness in Python, emphasizing practical familiarity with debugging tools and techniques for isolating faulty loop conditions.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• How to root-cause Wi‑Fi chip stops after 30 minutesMedium

  This question evaluates troubleshooting and diagnostic skills for embedded wireless systems, focusing on firmware behavior, testbed instrumentation, and measurement analysis.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a Consistent Hashing Ring From ScratchMedium

  Implement a consistent hashing ring that maps string keys to server nodes with add, remove and lookup operations. Tests sorted-position lookup with wrap-around, deterministic hashing across processes, virtual nodes for load balance, operation complexity and how few keys move when membership changes.

  AppleSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a Five-Minute Hit CounterMedium

  This problem tests your ability to design a high-throughput, time-series data structure that balances memory usage with query performance.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Mutual-Exclusion Lock Without Built-In LocksHard

  Implement a mutual-exclusion lock without any built-in lock, mutex or semaphore, relying only on atomic operations. Tests atomic read-modify-write, memory ordering, spinning versus sleeping waiters, fairness, reentrancy, and software-only mutual exclusion when atomic instructions are unavailable.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Reusable Cyclic Barrier from a Mutex and Condition VariablesHard

  Implement a reusable cyclic barrier from a mutex and condition variables, where a fixed number of threads block until all have arrived and are then released together. Tests round tracking for safe reuse, spurious wakeups, timeout and broken-barrier semantics, an atomics-only variant and concurrency testing.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Thread-Safe Bounded Blocking Queue for Producers and ConsumersHard

  Implement a thread-safe bounded blocking queue shared by multiple producer and consumer threads, built from a mutex and condition variables instead of a library concurrent queue. Tests wait and wakeup logic, spurious wakeups, FIFO ordering, shutdown handling and the OS mechanisms beneath blocking synchronization.

  AppleSoftware EngineerSoftware Engineering FundamentalsOnsite