How to Prepare for a JP Morgan Java Backend Interview (SDE-2 and Associate)

By Preeti Verma

This guide is based on interview experiences that candidates have shared publicly for Java backend roles at JP Morgan Chase (SDE-2 and Associate level, roughly two to five years of experience). Processes change from team to team, so treat it as a map of what people commonly report, not a promise of what you will be asked.

What the process usually looks like

Candidates typically describe four stages:

  1. An online test with two DSA problems.
  2. A DSA round that often includes reviewing a pull request. You may be asked to spot what is wrong in a piece of code, for example how static and volatile are being used.
  3. A system design round.
  4. A hiring manager or senior leadership round.

Two things stand out: the code review and the blend of design with practical Java. You are being tested as someone who can own production code, not only solve puzzles.

Core Java: the questions that repeat

  • Making an existing HashMap thread-safe without ConcurrentHashMap. Talk about synchronized wrappers, locking around access and the trade-offs against ConcurrentHashMap. Understand how HashMap and ConcurrentHashMap work internally, including collisions.
  • Alternatives to synchronized. Volatile, atomic classes, ReentrantLock, and higher-level tools like executors.
  • Runnable versus Callable, and virtual threads (which Java version added them).
  • String pool behaviour. Given two literals and one new String with the same text, how many objects are created.
  • A short Streams task. Filter, map and sum with a clear pipeline.

Spring Boot and Hibernate

Questions reported here go beyond usage:

  • How @Transactional works internally, and whether it works on private or protected methods.
  • How you would log every method annotated with @Transactional (a good place to talk about AOP).
  • Centralised exception handling across a very large codebase.
  • Rate limiting a REST API to a number of calls per time window.
  • Circular dependencies, and how to make an API asynchronous.
  • Connection pool sizing in Hibernate, pagination, and @Embeddable.

For the internals, read our Spring Boot interview scenarios.

SQL

Expect classics with a twist: finding duplicate rows, the second-highest salary (and what happens with ties), TRUNCATE versus DELETE, and how you would speed up a search on a table with a million rows. The last one is really a design question about indexing, partitioning, sharding and replication, so explain the trade-offs rather than listing terms.

Microservices and Kafka

This is where many candidates lose ground. Prepare clear answers to:

  • How do you handle partial failures across services?
  • How do you keep data consistent across several instances?
  • How do you make sure only one consumer processes a message, and what do you do when consuming fails?
  • How do you prevent duplicate payments, and what does zero data loss actually require?
  • How do you alert when a service keeps returning 500 errors?

For payments, the core idea is idempotency: give each operation a unique key so retrying it cannot charge twice.

System design

Reported prompts include designing a rate limiter and improving a Google Drive-like design with a load balancer, file service, user service and object storage, including event streaming. Also expect a "big sale, millions of users" question that touches Kubernetes scaling and the CAP theorem. If you are new to this, start with our system design guide for beginners.

GenAI questions

For AI-leaning roles, candidates report RAG architecture (how to chunk text and images and how to store chunks), embeddings, the difference between LangChain and LangGraph, and building a retrieval pipeline that does not hallucinate on financial documents and tables.

DSA practice

Problems that candidates mention include sliding window (longest substring without repeating characters, minimum window substring, sliding window maximum), duplicates in an array, Dijkstra-style shortest path, Kadane's algorithm, top K elements, move zeroes, anagrams, coin change and longest increasing subsequence. Prepare patterns, not only individual problems.

A simple plan

  • Days 1 to 5: Core Java and collections, out loud.
  • Days 6 to 10: Spring Boot internals and SQL.
  • Days 11 to 15: Kafka, microservices and payments.
  • Days 16 to 20: DSA patterns from the list above.
  • Every day: one mock answer spoken aloud and reviewed.

We collected these questions, rewrote them as realistic scenarios and added the reported DSA problems in the JP Morgan sheet, with a free preview of the first three questions. Good luck.