JP Morgan Interview Questions 2026 (with Answers for Freshers)

Last Updated: March 2026

---

Introduction

JPMorgan Chase & Co. is a leading global financial services firm with assets of $3.7 trillion and operations in over 60 countries. The firm's technology division, employing over 50,000 technologists, is one of the largest technology organizations in the world.

JP Morgan's technology teams build and maintain critical systems for investment banking, asset management, consumer banking (Chase), and commercial banking. The firm has significant technology centers in India (Bangalore, Hyderabad, Mumbai), UK, and US.

For freshers, JP Morgan offers exceptional opportunities to work on large-scale distributed systems, learn from experienced engineers, and develop expertise in financial technology.

---

JP Morgan Selection Process 2026

Stage	Description	Duration
Round 1: Online Assessment	Aptitude, Coding, Behavioral	90-120 minutes
Round 2: Technical Interview 1	Algorithms, Data Structures	45-60 minutes
Round 3: Technical Interview 2	System Design, Problem Solving	45-60 minutes
Round 4: HR/Behavioral Interview	Culture fit, Motivation	30-45 minutes

Eligibility Criteria:

• Minimum 60% or 6.5 CGPA
• Strong programming fundamentals
• CS/IT/ECE/MCA preferred
• Good analytical skills

---

HR Interview Questions and Answers

1. Tell me about yourself.

---

2. Why JP Morgan?

---

3. What do you know about JP Morgan's business?

1. Consumer & Community Banking (CCB): Chase consumer banking, credit cards, auto loans
2. Corporate & Investment Bank (CIB): Investment banking, markets, securities services
3. Commercial Banking: Middle-market banking, corporate client banking
4. Asset & Wealth Management: Investment management, private banking

Technology initiatives include:

• JPM Coin: Blockchain-based payment system
• Onyx: Blockchain platform for wholesale payments
• COiN: Contract Intelligence using AI/ML
• Kaleidoscope: Data analytics platform
• Cloud migration: Moving to public and private cloud infrastructure

The firm also operates innovation centers and invests heavily in cybersecurity, AI, and modernizing legacy systems."

---

4. What are your strengths?

---

5. Where do you see yourself in 5 years?

---

Technical Interview Questions and Answers

1. Design a payment processing system.

Components:
1. API Gateway - Authentication, rate limiting
2. Payment Service - Orchestrates payment flow
3. Fraud Detection - Real-time risk scoring
4. Ledger Service - Records transactions (ACID)
5. Notification Service - Email/SMS alerts
6. Reconciliation Service - End-of-day matching

Key Considerations:
- Idempotency for duplicate requests
- Sagas for distributed transactions
- Event sourcing for audit trail
- PCI DSS compliance
- Multi-region deployment for HA

---

2. Find the shortest path in a grid with obstacles.

from collections import deque

def shortest_path(grid, start, end):
    """BFS for shortest path in grid"""
    rows, cols = len(grid), len(grid[0])
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    
    queue = deque([(start[0], start[1], 0)])  # row, col, distance
    visited = {start}
    
    while queue:
        r, c, dist = queue.popleft()
        
        if (r, c) == end:
            return dist
        
        for dr, dc in directions:
            nr, nc = r + dr, c + dc
            
            if (0 <= nr < rows and 0 <= nc < cols and 
                grid[nr][nc] != 1 and (nr, nc) not in visited):
                visited.add((nr, nc))
                queue.append((nr, nc, dist + 1))
    
    return -1  # No path found

# Time: O(rows * cols)
# Space: O(rows * cols)

---

3. Implement a thread pool.

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

public class ThreadPool {
    private final BlockingQueue<Runnable> taskQueue;
    private final Thread[] workers;
    private final AtomicBoolean isShutdown;
    
    public ThreadPool(int numThreads) {
        this.taskQueue = new LinkedBlockingQueue<>();
        this.workers = new Thread[numThreads];
        this.isShutdown = new AtomicBoolean(false);
        
        for (int i = 0; i < numThreads; i++) {
            workers[i] = new Worker();
            workers[i].start();
        }
    }
    
    public void execute(Runnable task) {
        if (isShutdown.get()) {
            throw new IllegalStateException("Pool is shutdown");
        }
        taskQueue.offer(task);
    }
    
    public void shutdown() {
        isShutdown.set(true);
        for (Thread worker : workers) {
            worker.interrupt();
        }
    }
    
    private class Worker extends Thread {
        public void run() {
            while (!isShutdown.get() || !taskQueue.isEmpty()) {
                try {
                    Runnable task = taskQueue.poll(100, TimeUnit.MILLISECONDS);
                    if (task != null) {
                        task.run();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

---

4. Longest Increasing Subsequence.

def lengthOfLIS(nums):
    """
    DP with binary search - O(n log n)
    """
    if not nums:
        return 0
    
    # tails[i] = smallest tail of increasing subsequence of length i+1
    tails = []
    
    for num in nums:
        # Binary search for insertion point
        left, right = 0, len(tails)
        while left < right:
            mid = (left + right) // 2
            if tails[mid] < num:
                left = mid + 1
            else:
                right = mid
        
        if left == len(tails):
            tails.append(num)
        else:
            tails[left] = num
    
    return len(tails)

# Time: O(n log n)
# Space: O(n)

---

5. Design a distributed cache.

Key Components:
1. Cache Client - SDK for applications
2. Proxy/Router - Routes requests to appropriate shard
3. Cache Nodes - Store actual data
4. Consistent Hashing - Distribute keys across nodes
5. Replication - Primary-replica for availability
6. Eviction Policy - LRU/LFU for memory management

Consistency:
- Write-through: Write to cache and DB simultaneously
- Write-behind: Async write to DB
- Cache-aside: Application manages cache

Scaling:
- Horizontal: Add more nodes
- Rebalancing: Consistent hashing minimizes movement

---

6. Maximum subarray sum (Kadane's algorithm).

def maxSubArray(nums):
    """
    Kadane's algorithm - O(n)
    """
    max_sum = float('-inf')
    current_sum = 0
    
    for num in nums:
        # Either start new subarray or extend existing
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    
    return max_sum

# With start and end indices
def maxSubArrayWithIndices(nums):
    max_sum = float('-inf')
    current_sum = 0
    start = end = temp_start = 0
    
    for i, num in enumerate(nums):
        if current_sum + num < num:
            current_sum = num
            temp_start = i
        else:
            current_sum += num
        
        if current_sum > max_sum:
            max_sum = current_sum
            start = temp_start
            end = i
    
    return max_sum, start, end

# Time: O(n)
# Space: O(1)

---

7. Explain Java Memory Model.

Memory Areas:

1. Heap: Objects and arrays (shared across threads)
2. Stack: Local variables, method calls (per thread)
3. Method Area: Class metadata, static variables
4. PC Register: Current instruction address
5. Native Method Stack: Native method execution

Happens-Before Relationship:

// Changes in synchronized block visible to other threads
synchronized (lock) {
    sharedVar = newValue;
}

// volatile ensures visibility
volatile int sharedCounter;

Garbage Collection:

• Young Generation (Eden, Survivor spaces)
• Old Generation
• Metaspace (replacing PermGen)

---

8. Detect cycle in directed graph.

def hasCycle(graph):
    """
    DFS with three-color marking
    White: Not visited
    Gray: Being processed (in current DFS path)
    Black: Finished processing
    """
    WHITE, GRAY, BLACK = 0, 1, 2
    color = {node: WHITE for node in graph}
    
    def dfs(node):
        color[node] = GRAY
        
        for neighbor in graph.get(node, []):
            if color[neighbor] == GRAY:
                return True  # Back edge found
            if color[neighbor] == WHITE and dfs(neighbor):
                return True
        
        color[node] = BLACK
        return False
    
    for node in graph:
        if color[node] == WHITE:
            if dfs(node):
                return True
    
    return False

# Time: O(V + E)
# Space: O(V)

---

9. Implement an ATM system.

from threading import Lock
from enum import Enum

class TransactionType(Enum):
    WITHDRAWAL = 1
    DEPOSIT = 2
    BALANCE_INQUIRY = 3
    TRANSFER = 4

class ATM:
    def __init__(self, atm_id, initial_cash):
        self.atm_id = atm_id
        self.cash_available = initial_cash
        self.cash_denominations = {2000: 0, 500: 0, 100: 0}
        self.lock = Lock()
        self.transaction_log = []
    
    def authenticate_user(self, card_number, pin):
        """Validate card and PIN with bank"""
        # Call bank's authentication service
        pass
    
    def withdraw(self, account, amount):
        with self.lock:
            if amount > self.cash_available:
                return False, "Insufficient cash in ATM"
            
            if not account.debit(amount):
                return False, "Insufficient balance"
            
            # Dispense cash
            notes = self._calculate_notes(amount)
            if not notes:
                account.credit(amount)  # Rollback
                return False, "Cannot dispense exact amount"
            
            self.cash_available -= amount
            self._log_transaction(TransactionType.WITHDRAWAL, account, amount)
            return True, notes
    
    def _calculate_notes(self, amount):
        """Greedy algorithm for note dispensing"""
        result = {}
        for denom in sorted(self.cash_denominations.keys(), reverse=True):
            if amount >= denom:
                count = min(amount // denom, self.cash_denominations[denom])
                result[denom] = count
                amount -= count * denom
        
        return result if amount == 0 else None

---

10. Word break problem.

def wordBreak(s, wordDict):
    """
    DP solution - O(n^2 * m) where m is avg word length
    """
    word_set = set(wordDict)
    n = len(s)
    
    # dp[i] = True if s[0:i] can be segmented
    dp = [False] * (n + 1)
    dp[0] = True
    
    for i in range(1, n + 1):
        for j in range(i):
            if dp[j] and s[j:i] in word_set:
                dp[i] = True
                break
    
    return dp[n]

# With path reconstruction
def wordBreakWithPath(s, wordDict):
    word_set = set(wordDict)
    n = len(s)
    
    dp = [[] for _ in range(n + 1)]
    dp[0] = [[]]
    
    for i in range(1, n + 1):
        for j in range(i):
            word = s[j:i]
            if dp[j] and word in word_set:
                for prev in dp[j]:
                    dp[i].append(prev + [word])
    
    return dp[n]

# Time: O(n^2 * m)
# Space: O(n * k) where k is number of valid splits

---

JP Morgan-Specific Interview Tips

1. Focus on Fintech Domain: Understand payments, trading, risk management basics
2. Master Distributed Systems: Consistency, availability, partitioning
3. Practice System Design: Design scalable, reliable systems
4. Know Java Deeply: JP Morgan is primarily a Java shop
5. Study Database Optimization: Indexing, query optimization, transactions
6. Understand Security: Authentication, authorization, encryption
7. Learn Cloud Basics: AWS, Azure fundamentals
8. Research JPM Initiatives: Onyx, JPM Coin, AI/ML projects
9. Prepare Behavioral Questions: Use STAR format with fintech examples
10. Show Passion for Technology: Demonstrate genuine interest in engineering

---

FAQs

Q: What is the salary for freshers at JP Morgan? A: ₹12-18 LPA for software engineering roles in India.

Q: What technologies does JP Morgan use? A: Java, Python, JavaScript, React, Angular, Spring Boot, Kafka, Spark, cloud platforms.

Q: Is financial knowledge required? A: Basic understanding helps but not mandatory for SDE roles.

Q: How to prepare for the online assessment? A: Practice LeetCode medium-hard problems, system design basics, and aptitude questions.

---

Best of luck with your JP Morgan interview!