Software Engineering

Derive time and space complexity for iterative and recursive code using Big-O notation.

Compare amortized, average-case, and worst-case complexity for common operations.

Select arrays, dynamic arrays, linked lists, stacks, and queues based on operation costs.

Use hash tables while accounting for collisions, load factor, and pathological cases.

Trace and implement binary search while preserving its loop invariant.

Compare elementary and divide-and-conquer sorting algorithms by complexity and stability.

Solve array problems using two-pointer and sliding-window techniques.

Use prefix sums and frequency maps to reduce repeated computation.

Implement tree traversal using recursive and iterative depth-first and breadth-first approaches.

Use binary-search-tree invariants to search, insert, and validate values.

Use heaps to implement priority-based processing and top-k queries.

Use tries to support prefix lookup over strings.

Represent directed and undirected graphs using adjacency lists.

Apply breadth-first search and depth-first search to graph reachability problems.

Use topological sorting to order tasks with dependencies and detect cycles.

Apply Dijkstra’s algorithm to graphs with non-negative edge weights.

Solve connectivity problems using a disjoint-set union data structure.

Generate candidate solutions using backtracking with explicit pruning.

Formulate dynamic-programming solutions by defining states, transitions, and base cases.

Convert a memoized recursive solution into an iterative dynamic-programming solution.

Justify when a greedy choice yields an optimal solution.

Identify algorithmic edge cases and construct tests that expose them.

Explain an algorithm’s correctness using invariants or induction.

Implement an interview solution in Kotlin while communicating complexity and trade-offs.

Explain how processes, threads, and context switching affect application execution.

Relate virtual memory, paging, stacks, and heaps to program behavior and performance.

Explain how file systems organize, persist, and cache application data.

Identify race conditions and protect shared state with synchronization primitives.

Recognize deadlock conditions and evaluate strategies for preventing them.

Trace DNS resolution and a TCP connection from client request to server response.

Explain HTTP methods, status codes, headers, connection reuse, and TLS at an engineering level.

Diagnose a simple latency or connectivity problem using layered networking reasoning.

Translate application requirements into entities, relationships, keys, and constraints.

Normalize a relational schema through third normal form and justify deliberate denormalization.

Write SQL joins, aggregations, subqueries, and common table expressions for application queries.

Explain how B-tree indexes accelerate reads and impose write and storage costs.

Interpret a query execution plan and propose an evidence-based optimization.

Apply ACID transaction boundaries to preserve business invariants.

Compare transaction isolation levels using concrete concurrency anomalies.

Contrast locking and multiversion concurrency control as concurrency strategies.

Choose between relational, document, key-value, wide-column, and graph databases for a workload.

Design access-pattern-driven keys and indexes for a non-relational data model.

Compare leader-based and leaderless replication strategies.

Select a data-partitioning key while accounting for skew and rebalancing.

Explain consistency, availability, and partition trade-offs without misapplying the CAP theorem.

Select an appropriate consistency model for a product requirement.

Design a cache policy that addresses invalidation, eviction, and cache stampedes.

Plan a database migration that supports backward compatibility and rollback.

Create a layered Kotlin backend service with clear domain, application, and infrastructure boundaries.

Design an HTTP API with consistent resources, validation, errors, pagination, and versioning.

Define a GraphQL schema using appropriate object, input, interface, and connection types.

Implement GraphQL queries, mutations, and resolvers in a Kotlin service.

Prevent GraphQL N+1 queries through batching and request-scoped data loading.

Enforce authentication and field- or operation-level authorization in an API.

Test API behavior across unit, integration, database, and contract boundaries.

Instrument a backend service with structured logs, metrics, traces, and health checks.

Estimate traffic, storage, bandwidth, and latency from product assumptions.

Distribute traffic using load balancing, health checks, and horizontal scaling.

Use queues and event streams to decouple services and absorb traffic bursts.

Design idempotent operations and deduplication for at-least-once delivery.

Apply timeouts, retries with backoff, circuit breakers, and bulkheads to remote calls.

Explain why clocks, ordering, and partial failures complicate distributed coordination.

Describe the purpose and limits of leader election and consensus.

Define service-level indicators and objectives for a distributed service.

Separate functional requirements, quality attributes, and constraints in an architecture brief.

Define service boundaries using cohesion, coupling, ownership, and data invariants.

Compare a modular monolith with microservices for a specific organizational context.

Choose synchronous or asynchronous communication for an inter-service workflow.

Apply rate limiting, admission control, and backpressure to protect a service.

Design an API evolution strategy that preserves compatibility across clients.

Identify single points of failure and design graceful degradation paths.

Evaluate an architecture using explicit cost, complexity, reliability, and scalability trade-offs.

Produce a scalable design for a URL-shortening service with collision and expiration handling.

Produce a scalable design for a notification system with preferences, retries, and delivery tracking.

Produce a scalable design for a real-time chat system with presence and message ordering.

Produce a scalable design for a social feed with fan-out and ranking trade-offs.

Produce a scalable design for file upload and delivery using object storage and a content delivery network.

Produce a scalable design for search autocomplete with latency and freshness constraints.

Produce a scalable design for an API rate limiter in a distributed environment.

Review a system design to identify bottlenecks, failure modes, and pragmatic improvements.

Refactor code toward cohesive units while preserving behavior with tests.

Use dependency inversion and interface boundaries to isolate volatile infrastructure.

Perform a code review that identifies correctness, maintainability, security, and performance risks.

Choose a branching, review, and continuous-integration workflow for a development team.

Diagnose a production defect using reproduction, hypothesis testing, logs, metrics, and traces.

Solve a timed coding problem while clarifying requirements, testing incrementally, and explaining trade-offs.

Lead a timed system-design interview from requirement discovery through bottleneck analysis.

Construct concise behavioral interview stories that demonstrate ownership, conflict resolution, and technical impact.