Google or Walmart

Solve an array or string lookup problem using a hash map or hash set.

Solve a sorted-array pair problem using the two-pointer pattern.

Solve a contiguous subarray or substring problem using a fixed-size sliding window.

Solve a variable-length window problem while maintaining a valid window invariant.

Solve a range aggregation problem using prefix sums.

Solve a next-greater-element problem using a monotonic stack.

Implement queue and stack behavior for an interview problem using Java collections.

Reverse or merge linked-list segments by manipulating pointers safely.

Implement binary search while preserving explicit low/high boundary invariants.

Use binary search on an answer space for a monotonic feasibility problem.

Traverse a binary tree iteratively and recursively in Java.

Solve a binary-tree path or depth problem using depth-first search.

Solve a level-order tree problem using breadth-first search.

Validate or query a binary search tree using its ordering invariant.

Solve a top-k or streaming-selection problem using a heap.

Merge overlapping intervals after defining a correct sorting rule.

Represent a graph with an adjacency list and choose an appropriate traversal strategy.

Solve a graph connectivity problem using breadth-first or depth-first search.

Detect a cycle in a directed graph using traversal state.

Produce a valid dependency order using topological sorting.

Find shortest paths in an unweighted graph using breadth-first search.

Generate constrained combinations using backtracking and pruning.

Formulate and solve a one-dimensional dynamic-programming recurrence.

Formulate and solve a grid-based dynamic-programming recurrence.

Identify race conditions and visibility defects in multithreaded Java code.

Choose between intrinsic locks, explicit locks, atomics, and concurrent collections for a synchronization requirement.

Compose asynchronous service operations with CompletableFuture while handling failure and cancellation.

Evaluate when Java virtual threads are appropriate for a backend workload.

Diagnose a JVM memory symptom using heap, stack, allocation, and garbage-collection evidence.

Compare garbage-collector choices for latency-sensitive and throughput-oriented services.

Design a bounded concurrency strategy that prevents resource exhaustion under load.

Explain Java memory-model happens-before relationships in a code review.

Convert an ambiguous product prompt into prioritized functional and non-functional requirements.

Estimate request volume, storage growth, bandwidth, and peak capacity from stated assumptions.

Define service boundaries and external APIs for a system-design prompt.

Create a data model that supports a system's dominant access patterns.

Construct a high-level architecture and narrate the main request and data flows.

Identify a proposed design's likely bottlenecks and single points of failure.

Compare design alternatives using scalability, reliability, complexity, latency, and cost trade-offs.

Present a system design in a structured 45-minute interview sequence.

Select between relational, document, key-value, and search stores for a stated workload.

Choose a cache pattern and define its invalidation behavior for a read-heavy service.

Choose a partition key that balances load while supporting required queries.

Compare leader-based replication options using consistency, latency, and failover trade-offs.

Select an appropriate consistency model for a user-visible product requirement.

Design idempotency controls for retried API and message-processing operations.

Apply optimistic concurrency control to prevent lost updates.

Explain how quorum choices affect consistency and availability during failures.

Define event ownership and event boundaries for a retail business workflow.

Design a backward-compatible event schema and evolution policy.

Apply the transactional outbox pattern to coordinate database writes and event publication.

Design an idempotent Kafka consumer that tolerates duplicate delivery.

Choose partition keys and consumer-group structure for ordering and throughput requirements.

Model a multi-service business transaction as a saga with explicit compensating actions.

Design a dead-letter and replay process that prevents uncontrolled data corruption.

Design a near-real-time inventory availability system under concurrent updates.

Define service-level indicators and objectives for a customer-facing backend capability.

Use an error budget to make a release or reliability investment decision.

Design timeout, retry, backoff, circuit-breaker, and bulkhead policies for a dependency.

Construct an observability plan linking logs, metrics, traces, and actionable alerts.

Lead incident triage by forming and testing hypotheses from production signals.

Write a blameless incident review with concrete corrective actions and owners.

Threat-model a backend data flow using trust boundaries and common abuse cases.

Design authentication, authorization, and secrets-handling controls for a service API.

Write an architecture decision record that makes assumptions and trade-offs reviewable.

Evaluate whether to build, buy, reuse, or retire a platform capability.

Decompose a high-risk architectural change into reversible delivery increments.

Design a strangler migration from a legacy component while preserving service continuity.

Run a design review that surfaces risks without dictating implementation details.

Define measurable fitness functions that detect architectural drift.

Create a technical roadmap that connects engineering investments to business outcomes.

Communicate an architecture recommendation differently to engineers, product leaders, and executives.

Delegate an engineering outcome with clear context, constraints, authority, and checkpoints.

Give actionable code-review feedback that separates correctness, maintainability, and preference.

Create a mentoring plan with observable growth goals for an engineer.

Facilitate resolution of a technical disagreement using evidence and decision criteria.

Identify delivery risks and negotiate scope while protecting critical quality attributes.

Plan ownership and interfaces for work spanning multiple engineering teams.

Use delivery and operational metrics without incentivizing counterproductive behavior.

Handle an underperforming workstream through expectations, feedback, and follow-up.

Map evidence from prior projects to Senior, Staff, and Lead competency expectations.

Build a concise STAR narrative demonstrating technical leadership and measurable impact.

Build a STAR narrative about conflict, failure, or changed judgment without deflecting responsibility.

Build a STAR narrative demonstrating cross-team influence without formal authority.

Answer a lead-level architecture challenge using explicit assumptions and trade-offs.

Conduct a timed Java coding simulation while narrating reasoning and testing.

Evaluate a mock system-design response with a structured scoring rubric.

Create a 30–60–90-day plan for joining a large engineering organization as a technical lead.