JPMorgan SDE-2 Interview Experience - 3 Rounds | Java, Code Review & System Design

Round 1 : Behavioral + Code Review + Core Java

The first round started with a discussion about my professional experience, projects and day-to-day responsibilities. The interviewer explored my approach to teamwork, ownership, problem solving and handling technical challenges.

After the behavioral discussion, the focus shifted toward a code review exercise. Instead of asking me to write code from scratch, the interviewer shared an existing code snippet and asked me to analyze it as if I were reviewing a pull request submitted by another developer.

This was particularly interesting because it simulated a real-world software engineering task. In production environments, engineers spend a significant amount of time reviewing code written by teammates, identifying issues and suggesting improvements before changes are merged.

Code Review Discussion

The interviewer expected me to evaluate the code from multiple perspectives:

Core Java Discussion

Toward the end of the round, the interviewer asked several Java-focused questions covering concepts commonly encountered in enterprise applications. Topics included: Object-Oriented Programming

Discussion areas:

• Encapsulation
• Abstraction
• Inheritance
• Polymorphism
• Composition vs Inheritance
• SOLID Principles
• Collections Framework

Questions focused on:

• HashMap internals
• ConcurrentHashMap
• Hash collisions
• ArrayList vs LinkedList
• Set implementations
• Time complexities
• Memory Management

Topics discussed:

• Heap vs Stack
• Garbage Collection
• Memory leaks
• Strong, Weak and Soft References
• Object lifecycle

Many experienced Java interviews place significant emphasis on Java internals and collections because these concepts directly impact application performance and reliability.

Round 2 : System Design

System Design Question : Design a Flight Search System similar to Skyscanner.

The interviewer intentionally chose a practical large-scale system rather than a theoretical design problem. The objective was not to build an entire travel platform but to demonstrate system design thinking, API design skills, scalability considerations and trade-off analysis.

Understanding the Problem

The system needed to allow users to:

• Search flights
• Filter results
• Sort results
• View availability
• Handle large traffic volumes

A typical user journey might look like:

• Search flights from Mumbai to Bangalore
• Filter by airline
• Filter by price range
• Sort by duration
• View available seats

The interviewer wanted the discussion to begin with requirements gathering before jumping into architecture.

API Design Discussion

One of the major focus areas was API design. We discussed endpoints such as:

• GET /flights/search

Possible query parameters: source, destination, departureDate, returnDate, airline, priceRange, page, pageSize.

The interviewer also explored:

• Pagination strategies
• Sorting support
• Filtering mechanisms
• Response structure
• Error handling

A key lesson from this round was: System design is not only about databases and servers. API design is equally important.

Real-Time Availability Challenges

One of the most interesting discussions involved flight availability. Unlike static data, seat availability changes continuously because bookings happen every second. Questions included:

• How should availability be updated?
• How often should partner systems synchronize?
• What happens if two users book simultaneously?
• How do we prevent overbooking?

This naturally led to discussions around:

• Event-driven updates
• Distributed locking
• Eventual consistency
• Inventory synchronization

Database Design Discussion

The interviewer explored how flight information could be stored. Key entities included: Flight, Airline, Route, Airport, Fare, Inventory.

We discussed indexing strategies for: source, destination, departure date, airline. since search performance would be critical.

Caching Strategy

Since flight searches are highly repetitive, caching became an important discussion topic. Potential cache candidates:

• Popular routes
• Frequently searched cities
• Airline metadata
• Airport information

The interviewer wanted to understand:

• What should be cached?
• What should not be cached?
• Cache invalidation challenges
• Trade-offs between freshness and performance

Scalability Discussion

Toward the end of the round, the conversation focused on scaling. Topics included:

• Load balancing
• Horizontal scaling
• Read replicas
• Database partitioning
• Distributed caching
• High availability

The interviewer was primarily evaluating whether I could reason about growth and system evolution rather than produce a perfect architecture diagram.

System design rounds at JPMorgan frequently emphasize API design, scalability and practical engineering trade-offs rather than purely academic architectures.

Round 3 : Behavioral + Concurrency + Advanced Java

The final round started with behavioral questions and discussions around my previous projects. The interviewer explored:

• Ownership
• Technical decisions
• Challenges faced
• Production incidents
• Learning experiences

Behavioral discussions are often given significant importance in experienced engineering interviews because they reveal how candidates operate within teams and handle real-world situations.

Deep Dive into Previous Projects

Unlike generic project discussions, the interviewer went several layers deeper. Questions included:

• Why was this architecture chosen?
• What alternatives were considered?
• What bottlenecks existed?
• What would you redesign today?
• What failures occurred in production?

The focus was on understanding whether I genuinely owned the systems mentioned on my resume.

Concurrency and Multithreading Discussion

The interviewer then revisited the code review problem from Round 1. This time the discussion shifted toward concurrent execution. Topics included:

Race Conditions

Questions explored situations where multiple threads modify shared data simultaneously. Discussion involved:

• Lost updates
• Inconsistent state
• Data corruption
• Synchronization

Topics included:

• synchronized keyword
• Locks
• ReentrantLock
• Thread coordination

Thread Safety

Questions focused on:

• Immutable objects
• Concurrent collections
• Stateless design
• Shared mutable state

Advanced Java Concepts

The final part of the interview covered:

• Executor Framework
• Thread Pools
• CompletableFuture
• ConcurrentHashMap
• JVM Memory Model
• Best Practices for Concurrent Programming

The interviewer was less interested in textbook definitions and more interested in practical application within production systems.

Key Learnings From This Interview

Although I did not receive an offer, the interview process was extremely valuable because it highlighted what experienced engineering interviews actually evaluate. Some important observations:

• Strong Java Fundamentals Matter : Understanding Java internals, collections, concurrency and memory management is critical for backend engineering roles.

• Code Review Skills Are Important Many engineers focus only on writing code but neglect code review skills. Being able to identify:

  • bugs
  • design flaws
  • maintainability issues
  • performance problems is equally important.

• System Design Requires Practical Thinking The interviewer cared more about: trade-offs, scalability, API design and reasoning than producing a perfect architecture diagram.

• Communication Is Critical : In every round, the quality of explanation mattered almost as much as the technical answer itself.

Preparation Tips

1. Practice Code Reviews

Review open-source pull requests and identify: bugs, design issues, naming problems, maintainability concerns

2. Strengthen Core Java

Focus heavily on: Collections, JVM, Memory Management, Concurrency, Multithreading

3. Practice Real-World System Design

Prepare systems such as: Flight Search, URL Shortener, Payment System, Notification Platform, Ride-Sharing Service. Focus on APIs, scalability, caching and trade-offs.

4. Know Your Projects Deeply

Expect interviewers to challenge architectural decisions and ask why specific approaches were chosen.

Final Thoughts

Even though I was not selected, the interview process was one of the most practical and insightful engineering interviews I have experienced. Unlike interviews that rely heavily on algorithmic problem solving, this process focused on how engineers think in real production environments reviewing code, designing scalable systems, understanding Java internals and reasoning about concurrency.

The biggest takeaway was: For experienced software engineering roles, strong coding skills are important, but engineering judgment, system design thinking, communication and deep understanding of fundamentals often make the difference between getting rejected and receiving an offer.

Recommended Interview Experience