SDE 2

Write small Go programs using variables, control flow, functions, and packages without AI assistance.

Manipulate Go strings, runes, arrays, slices, and maps in interview-style exercises.

Define structs and methods and use interfaces through implicit implementation.

Predict how pointers, value copying, slice headers, and map references affect program behavior.

Handle errors and resource cleanup using error values, wrapping, defer, panic, and recover appropriately.

Write table-driven unit tests for a Go function using the standard testing package.

Debug a failing Go program systematically using compiler messages, focused tests, and a debugger.

Translate a problem statement into pseudocode before implementing and testing a Go solution independently.

Determine the time and auxiliary-space complexity of iterative and recursive code.

Use a hash map or hash set to solve lookup, counting, and deduplication problems.

Apply sorting to simplify comparison, grouping, and interval problems.

Use two pointers to solve pair, partition, and in-place array problems.

Use a fixed-size sliding window to compute contiguous-range statistics efficiently.

Use a variable-size sliding window to find a longest or shortest valid range.

Use prefix sums to answer repeated range queries and count target-sum subarrays.

Explain and test an array or hash-map solution under interview time constraints.

Implement binary search while maintaining an explicit search-space invariant.

Adapt binary search to find a boundary or optimize a monotonic answer space.

Trace recursive calls and define correct base cases for a recursive solution.

Reverse a singly linked list by updating pointers iteratively.

Use slow and fast pointers to detect cycles or locate positions in a linked list.

Use a stack to validate or evaluate nested expressions.

Use a monotonic stack to find the next greater or smaller element.

Choose and implement a queue or deque for first-in-first-out and endpoint-processing problems.

Implement preorder, inorder, and postorder traversal of a binary tree recursively.

Implement an iterative binary-tree traversal using an explicit stack.

Perform level-order traversal of a tree using breadth-first search.

Use the binary-search-tree invariant to search, validate, or locate an ordered value.

Compute a tree property such as height, balance, or diameter using postorder information.

Find the lowest common ancestor of nodes in a binary tree.

Use a heap to maintain the smallest or largest candidates in a stream.

Solve a top-k or kth-element problem with an appropriate heap strategy.

Represent directed and undirected graphs with adjacency lists in Go.

Traverse a graph with breadth-first search while tracking visited states.

Traverse a graph with depth-first search without revisiting nodes.

Detect a dependency cycle and produce a topological ordering when one exists.

Implement disjoint-set union with path compression and union by rank or size.

Generate subsets or permutations using a backtracking decision tree.

Solve a constraint-search problem by choosing, exploring, and undoing decisions.

Use Dijkstra's algorithm to find shortest paths in a non-negative weighted graph.

Recognize when repeated subproblems and state choices justify dynamic programming.

Convert a recursive recurrence into memoized and bottom-up one-dimensional dynamic programs.

Build a two-dimensional dynamic program for a grid-based path or counting problem.

Solve a subsequence problem by defining state, transition, and base cases.

Solve a constrained selection problem using a knapsack-style dynamic program.

Apply a greedy strategy to an interval scheduling or merging problem.

Justify a greedy choice with an exchange argument or identify why greedy reasoning fails.

Complete and review a timed mixed-pattern coding set in Go without AI assistance.

Write SQL queries using joins, grouping, aggregation, and filtering for backend scenarios.

Design a relational schema with keys and constraints for a stated access pattern.

Use an execution plan to explain how an index changes a query's performance.

Explain how ACID transactions protect a multi-step data update.

Predict anomalies under common transaction isolation levels.

Choose between relational, document, key-value, and wide-column storage for stated requirements.

Explain how replication affects availability, read scaling, and consistency.

Select a partition key and identify skew or cross-partition query risks.

Trace an HTTP request through DNS, connection establishment, a load balancer, and an application server.

Design a versioned HTTP API with appropriate methods, status codes, validation, and pagination.

Explain authentication and authorization boundaries for a backend API.

Use goroutines, channels, and context cancellation to coordinate concurrent Go work.

Identify and correct a data race, deadlock, or goroutine leak in Go code.

Apply timeouts, bounded retries, exponential backoff, and idempotency to a remote operation.

Choose logs, metrics, and traces that make a backend failure diagnosable.

Design unit, integration, and contract tests for a backend component.

Clarify functional requirements, constraints, and extension points before beginning a low-level design.

Model a backend domain with cohesive Go types, interfaces, and package boundaries.

Use composition and dependency injection to keep Go components replaceable and testable.

Apply a suitable design pattern without introducing unnecessary abstraction.

Design a concurrency-safe in-memory component with a clearly stated locking strategy.

Implement a testable cache or rate-limiter component from a written specification.

Review a machine-coding solution for correctness, extensibility, concurrency, and test coverage.

Complete a scoped Go machine-coding exercise within a fixed interview time box.

Separate functional requirements from quality attributes in a system-design prompt.

Estimate traffic, storage, bandwidth, and peak capacity using explicit assumptions.

Define service APIs and a data model that support the system's core access patterns.

Explain how load balancing and stateless services support horizontal scaling.

Choose a caching strategy and address invalidation, eviction, and hot-key risks.

Compare replication and sharding strategies for a growing data store.

Reason about consistency, availability, and behavior during network partitions.

Use queues and event-driven processing to decouple work and absorb traffic spikes.

Design a URL-shortening service and defend its identifier, storage, and redirection choices.

Design a distributed rate limiter and discuss accuracy, latency, and failure trade-offs.

Design a notification service that supports retries, user preferences, and multiple channels.

Design a news-feed service and compare fan-out-on-write with fan-out-on-read.

Design a real-time chat service with connection management, message ordering, and offline delivery.

Design a metrics collection service with high write throughput and time-based querying.

Present a system design in a structured 40-minute interview conversation.

Critique a proposed architecture by identifying bottlenecks, failure modes, and scaling limits.

Rewrite résumé bullets to show ownership, technical decisions, and measurable backend impact.

Build a role-selection rubric based on engineering level, stack fit, learning opportunity, and interview readiness.

Deliver a concise recruiter-screen introduction that connects past experience to an SDE II role.

Prepare STAR stories covering ownership, conflict, failure, ambiguity, and measurable impact.

Explain one previous backend system deeply, including trade-offs, incidents, and personal contributions.

Complete a timed coding mock while clarifying requirements, testing aloud, and analyzing complexity.

Complete a timed system-design mock while driving requirements, architecture, and trade-off discussion.

Run a weekly application and interview-review process that converts feedback into targeted practice.