Backend Engineering Interview Preparation

Trace Java code from compilation through class loading, bytecode execution, and JIT compilation.

Distinguish stack, heap, and metaspace usage in a running Java application.

Explain how object allocation, reachability, and garbage collection affect application latency.

Diagnose likely memory or garbage-collection problems from JVM metrics and symptoms.

Apply happens-before rules with synchronized, volatile, and final fields.

Select an appropriate lock, atomic type, or concurrent collection for a thread-safety requirement.

Identify and correct a race condition or deadlock in Java code.

Configure an ExecutorService or CompletableFuture pipeline without blocking or exhausting threads.

Calculate the time and space complexity of iterative, recursive, and amortized operations.

Apply a repeatable coding-interview workflow to clarify a problem, derive examples, select a pattern, implement a solution, and test edge cases.

Solve a lookup or frequency-counting problem using a hash map or hash set.

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

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

Solve a range-sum or subarray-count problem using prefix sums.

Solve a monotonic search problem using binary search and explicit invariants.

Reverse a singly linked list in place using pointer manipulation.

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

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

Solve a top-k selection problem using a heap.

Find connected components in a graph using depth-first or breadth-first search.

Determine a valid dependency order using topological sorting.

Solve an overlapping-interval problem by sorting and merging intervals.

Generate constrained combinations using backtracking with pruning.

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

Diagnose bean-scope injection mismatches and lifecycle execution order in a Spring application.

Explain Spring AOP proxy mechanisms and correct a method self-invocation issue.

Choose Spring transaction boundaries and propagation behavior for a service operation.

Implement consistent request validation and API error handling in Spring Boot.

Write an isolated JUnit and Mockito test for service-layer behavior.

Write a Spring Boot integration test using a real database through Testcontainers.

Apply timeout, retry, and circuit-breaker policies to a Spring client call.

Refactor a representative Spring Boot service slice into testable domain, application, and infrastructure boundaries.

Write a SQL query that combines joins, filtering, grouping, and aggregation.

Use a SQL window function to rank or aggregate rows without collapsing them.

Interpret an execution plan and propose an index for a slow SQL query.

Choose a transaction isolation level to prevent a specified concurrency anomaly.

Design a normalized relational schema with appropriate keys and constraints.

Design a MongoDB document model around specified access patterns.

Choose between relational and document databases for a backend workload.

Design a cache-aside flow with an explicit invalidation strategy.

Trace a backend request through DNS, TCP, TLS, HTTP, a load balancer, and an application service.

Choose between REST, RPC, and GraphQL for a specified service interaction.

Design a REST resource contract with appropriate methods, status codes, and error responses.

Make a state-changing API safe to retry using idempotency keys.

Design cursor-based pagination for a changing dataset.

Differentiate authentication from authorization in an OAuth 2.0 and JWT-based flow.

Identify and mitigate common backend risks involving injection, broken access control, and exposed secrets.

Design a rate-limiting policy and select an implementation algorithm.

Use consistency, availability, and partition-failure trade-offs to justify a distributed design decision.

Choose replication and partitioning strategies for a scalable data service.

Design an idempotent event consumer using deduplication keys and atomic state updates.

Design reliable event publishing with the transactional outbox pattern to prevent dual-write anomalies.

Choose Kafka partition keys to meet ordering and throughput requirements.

Explain how Kafka consumer groups, rebalancing, and offset ownership interact.

Configure offset commits to achieve a stated event-delivery guarantee.

Handle poison messages and schema evolution using dead-letter handling and compatible event contracts.

Create a production-oriented multi-stage Dockerfile for a Spring Boot service.

Diagnose a container startup, networking, or resource-limit failure.

Map a Spring Boot workload to Kubernetes Deployment, Service, and Ingress resources.

Configure Kubernetes health probes and resource requests for reliable scheduling and rollout behavior.

Securely supply application configuration to a Kubernetes-hosted Spring Boot service using ConfigMaps and Secrets.

Select appropriate AWS services and access-control boundaries for a highly available Java backend architecture.

Design a CI/CD pipeline with automated build, test, security, and deployment gates.

Choose and execute a rolling, blue-green, or canary deployment with a rollback plan.

Clarify functional requirements, nonfunctional requirements, constraints, and scope in a design interview.

Estimate traffic, storage, bandwidth, and peak capacity using back-of-the-envelope calculations.

Define core APIs and a data model for a system-design prompt.

Produce a high-level architecture with clear component responsibilities and request flows.

Identify bottlenecks and scale them using load balancing, caching, replication, or partitioning.

Select consistency and availability guarantees for the critical operations in a design.

Add failure isolation, redundancy, recovery objectives, and graceful degradation to a design.

Define logs, metrics, traces, service-level indicators, and alerts for a backend system.

Complete a time-boxed design of a scalable URL-shortening service and defend its data and caching choices.

Complete a time-boxed design of a multi-channel notification service with retries, preferences, and delivery tracking.

Complete a time-boxed design of an order and inventory workflow that prevents overselling.

Complete a time-boxed design of a payment-processing workflow that handles retries and duplicate requests safely.

Complete a time-boxed design of a high-throughput event-ingestion pipeline with durable processing.

Complete a time-boxed design of a low-latency product catalog using multi-level caching and read partitioning.

Complete a time-boxed design of a secure, versioned API platform for multiple internal client teams.

Complete and critique a time-boxed end-to-end system-design mock interview.

Map prior experiences to a behavioral story bank covering impact, ownership, collaboration, conflict, failure, and growth.

Structure a behavioral answer using STAR while keeping actions and measurable results explicit.

Deliver a concise technical-project walkthrough that explains architecture, decisions, and personal contribution.

Deliver a STAR answer about influencing others through a technical disagreement without relying on formal authority.

Answer an ambiguity or pressure question by showing prioritization and communication.

Discuss a failure by separating accountability, corrective action, and lasting learning.

Complete a timed Java coding mock on an unseen easy-to-medium problem, then evaluate communication, correctness, complexity, and testing with a rubric.

Conduct a behavioral mock interview and revise weak answers using a structured rubric.