JP Morgan HackerRank Test (2026-27): Questions, Format, Proctoring and Prep

The JP Morgan (JPMC) HackerRank coding challenge is the online coding screen candidates report for the Software Engineer Program and the Code for Good pipeline. It is a timed, auto-graded test, and it follows predictable patterns, so focused preparation works.

This guide covers the reported format, the DSA topics, whether the test is proctored, how the 2027 cycle looks, and how to practise. JPMorgan does not publish the exact test configuration, so format details here come from candidate reports and prep sites. Your invitation is the authority.

Is your invite called "CodeVue" instead? Some JPMC invites (for example "AMERS - AFE CodeVue - 2026") use HireVue's CodeVue rather than HackerRank. See the CodeVue and HireVue coding assessment guide.

Start practising now: the DSA Patterns Sheet covers the patterns these tests lean on.

---

JP Morgan HackerRank Test Format (As Reported)

These are candidate-reported figures, not official JPMorgan numbers.

Detail	Specification
Platform	HackerRank
Number of Questions	2 coding problems
Difficulty	Medium (LeetCode equivalent)
Time Limit	60-90 minutes
Languages	Python, Java, C++, JavaScript, and more
Environment	HackerRank IDE with test cases
Proctoring	Not confirmed by JPMorgan; see the proctoring section below
Retakes	JPMorgan says many assessments cannot be retaken for a designated period

How It Works

1. After you apply and are selected to proceed, you receive an email with a HackerRank link
2. The invitation sets the window (candidates report several days to a week or more)
3. Once you start, the timer runs continuously
4. Each problem has visible test cases and hidden test cases
5. Your score is based on correctness (passing test cases)

---

Is the JP Morgan HackerRank Test Proctored?

Short answer: JPMorgan hasn't published its proctoring settings, so assume it may be monitored.

• HackerRank's platform can flag tab switches and full-screen exits, monitor a webcam feed and keep session replays when an employer enables Proctor Mode. Whether JPMorgan enables it for your test is not confirmed.
• Reports are mixed and some are old. One JPMorgan candidate in 2022 described a webcam and mic requirement with screen recording, while 2026 prep guides describe basic tab-switch detection and no lockdown browser.
• Practical rule: do the test in one browser window with no other tabs, no notes you aren't allowed to use, and no copied code. Read the rules page on your invitation before you start, because it states what is on.

Sources: HackerRank Proctor Mode docs, LeetCode discussion (2022 JPMorgan report).

---

2027 Cycle: What Is Different?

JPMorgan's 2027 Software Engineer Program (US, full-time, February 2027 start) and Code for Good listings are open to students graduating in 2026-2027. Listings show an application deadline in early November 2026 for the US program, and candidate reports describe a HackerRank coding challenge for advancing applicants, with some also routed to Code for Good. Sources disagree on the exact order of stages, so follow your email. The test style (timed, auto-graded, Easy-Medium DSA) has not been reported to change.

---

DSA Topics You Must Know

Based on candidate reports, these are the topics people most often describe, ranked roughly by frequency. JPMorgan does not publish its question bank and the questions change, so we do not list "actual" questions:

Tier 1: Almost Always Tested

Arrays and Strings

The most frequently tested category. Expect problems involving:

• Array manipulation and transformation
• String parsing and pattern matching
• Subarray/substring problems
• Two-pointer techniques

Example problem types:

• Find the longest substring without repeating characters
• Rotate an array by K positions
• Merge overlapping intervals

Practice focus: Array and String patterns

Hash Maps and Sets

Used for optimization and lookup problems:

• Frequency counting
• Grouping elements by property
• Finding pairs or complements
• Deduplication

Example problem types:

• Two Sum variants
• Group anagrams
• Find the first non-repeating character

Tier 2: Frequently Tested

Sorting and Searching

• Custom comparator sorting
• Binary search on sorted arrays
• Search in rotated arrays
• Merge sort applications

Example problem types:

• Find the kth largest element
• Search in a sorted matrix
• Merge sorted arrays

Dynamic Programming (1D)

Usually simpler DP, not complex multi-dimensional problems:

• Climbing stairs variants
• Maximum subarray (Kadane's algorithm)
• Coin change problems
• Longest increasing subsequence

Example problem types:

• Minimum cost to reach the end
• Count the number of ways to make change
• Maximum profit from stock transactions

Tier 3: Occasionally Tested

Graphs and Trees

When they appear, they're usually straightforward traversals:

• BFS/DFS traversal
• Level-order traversal
• Connected components
• Shortest path in unweighted graphs

Greedy Algorithms

• Interval scheduling
• Activity selection
• Optimal assignment problems

Stacks and Queues

• Valid parentheses
• Next greater element
• Implement queue using stacks

---

Difficulty Calibration

JP Morgan's HackerRank questions are solidly in the medium range. Here's how they compare:

Platform	Equivalent Difficulty
LeetCode	Medium (occasionally Easy-Medium)
HackerRank	Medium
Codeforces	Div 2 A-B
CodeChef	1200-1500 rating

What "Medium" Means in Practice

• You need to know standard algorithms and data structures
• Brute force solutions usually time out — optimization is required
• Problems typically have 1-2 key insights to discover
• Clean implementation matters (edge cases, off-by-one errors)
• You should solve each problem in 20-30 minutes

💡 Pro Tip: JP Morgan's problems tend to be more practical than purely algorithmic. Instead of "find the minimum spanning tree," you might see "optimize a delivery schedule" that requires similar graph/greedy thinking.

---

Problem-Solving Framework

Use this framework for every problem:

Step 1: Understand (3-5 minutes)

• Read the problem statement twice
• Identify input/output format
• Work through the given examples by hand
• Identify edge cases: empty input, single element, very large input, negative numbers

Step 2: Plan (3-5 minutes)

• Identify the DSA pattern (is this a sliding window? Two pointers? DP?)
• Consider brute force first, then optimize
• Estimate time complexity — will your approach pass within the time limit?
• Write pseudocode if the problem is complex

Step 3: Implement (10-15 minutes)

• Write clean, readable code
• Use meaningful variable names
• Handle edge cases explicitly
• Add brief comments for non-obvious logic

Step 4: Test (3-5 minutes)

• Run the visible test cases
• Test your own edge cases
• Check for off-by-one errors
• Verify your solution handles the constraints

---

Language-Specific Tips

Python (Recommended for Speed)

PYTHON
Copy
# Use collections for common patterns
from collections import Counter, defaultdict, deque

# List comprehensions for clean array operations
result = [x for x in arr if x > 0]

# Sorting with custom key
arr.sort(key=lambda x: x[1])

# Binary search with bisect
from bisect import bisect_left, bisect_right

Advantages: Faster to write, built-in data structures, less boilerplate Watch out for: Recursion depth limit (use sys.setrecursionlimit), slower runtime for heavy computation

Java (Recommended for Robustness)

JAVA
Copy
// Use HashMap, HashSet, PriorityQueue
Map<String, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();
PriorityQueue<Integer> pq = new PriorityQueue<>();

// Sorting with comparator
Arrays.sort(arr, (a, b) -> a[1] - b[1]);

// StringBuilder for string manipulation
StringBuilder sb = new StringBuilder();

Advantages: Strong typing catches errors, faster runtime, familiar to most CS students Watch out for: More verbose, integer overflow with int vs long

JavaScript

JAVASCRIPT
Copy
// Map and Set
const map = new Map();
const set = new Set();

// Sorting (careful — default is lexicographic!)
arr.sort((a, b) => a - b);

// Useful array methods
arr.filter(x => x > 0);
arr.reduce((sum, x) => sum + x, 0);

Advantages: Flexible, good for string manipulation Watch out for: Default sort is lexicographic, no built-in heap/priority queue

---

Practice Plan: 4 Weeks to Ready

Week 1: Foundations

• Goal: Master arrays, strings, and hash maps
• Daily: Solve 2-3 problems from Thita.ai DSA patterns
• Focus: Understanding patterns, not memorizing solutions
• Topics: Two pointers, sliding window, hash map lookups

Week 2: Core Algorithms

• Goal: Learn sorting, searching, and basic DP
• Daily: Solve 2-3 medium problems
• Focus: Identifying which pattern to apply
• Topics: Binary search, sorting tricks, 1D dynamic programming

Week 3: Advanced Topics

• Goal: Cover graphs, trees, greedy, and stacks
• Daily: Solve 2 medium problems + 1 review problem
• Focus: Speed and accuracy under time pressure
• Topics: BFS/DFS, greedy algorithms, stack-based problems

Week 4: Mock Tests

• Goal: Simulate real test conditions
• Daily: One timed session (2 problems in 60 minutes)
• Focus: Time management and stress handling
• Resources: AI DSA mock interviews for spoken practice and a written report

---

Time Management During the Test

With 60-90 minutes for 2 problems, time management is crucial:

Strategy 1: Easy First

1. Read both problems quickly (2 minutes)
2. Start with the easier one
3. Spend 25-30 minutes on Problem 1
4. Spend 25-30 minutes on Problem 2
5. Use remaining time to optimize and test

Strategy 2: Equal Split

1. Set a 35-minute timer for each problem
2. If stuck after 20 minutes, move to the other problem
3. Come back with fresh eyes

When You're Stuck

• Re-read the problem statement — you might have missed a constraint
• Try a different example input to spot the pattern
• Consider: is this a variation of a classic problem?
• Think about what data structure would make the operation you need efficient
• If brute force works within constraints, submit it and optimize later

---

Common Pitfalls

1. Not Reading Constraints

The constraints tell you the expected time complexity:

• n ≤ 100 → O(n³) is fine
• n ≤ 1,000 → O(n²) works
• n ≤ 10,000 → O(n log n) needed
• n ≤ 100,000 → O(n) or O(n log n)
• n ≤ 1,000,000 → Must be O(n) or better

2. Off-by-One Errors

The most common bug in timed assessments. Double-check:

• Array index boundaries
• Loop termination conditions
• Inclusive vs exclusive ranges

3. Not Handling Edge Cases

Always check:

• Empty arrays/strings
• Single-element inputs
• All elements the same
• Already sorted/reverse sorted input
• Maximum constraint values

4. Submitting Without Testing

Run ALL visible test cases before submitting. Then add your own edge case tests.

5. Over-Engineering

Don't implement a complex algorithm when a simpler one works within constraints. A clean O(n²) beats a buggy O(n log n).

---

What Happens After the HackerRank Test

Stages vary by program. Many candidates are later asked for a HireVue video interview, and some are invited to Code for Good. Start preparing for that early.

Next steps:

• Prepare for the HireVue video interview
• Read the complete Code for Good guide
• Continue practising DSA

---

Practise JP Morgan HackerRank Problems with an AI Mock Interview

The HackerRank test is silent and auto-graded, so the best practice is timed problem-solving. An AI mock interview adds a second skill that helps later rounds:

• You solve a DSA problem in an in-browser editor and your code runs against real test cases in Python, C++, Java, JavaScript, Go and C#.
• It is a timed, spoken interview: the AI interviewer listens to your reasoning and asks follow-ups when your explanation is thin.
• Each session ends with a written report on your approach and how the code performed on the tests.
• The Starter plan is free with limited access.

It does not copy HackerRank's interface or question bank. Use it alongside timed sets from the DSA Patterns Sheet.

Start a DSA mock interview →

---

More HackerRank guides

• Goldman Sachs HackerRank assessment
• Does HackerRank record your screen?
• HackerRank AI-assisted tests

Frequently Asked Questions

Can I use an IDE or is it browser-only?

The test runs in HackerRank's browser-based IDE. Pasting may be logged by the platform and your invitation's rules govern what is allowed, so write and test in the test editor.

Are there partial scores?

On HackerRank, generally yes. Each problem has multiple test cases. Passing some but not all earns partial credit. Always submit something, even if it doesn't pass all cases.

What if I run out of time?

Submit whatever you have. Partial solutions are better than nothing. HackerRank auto-submits your last saved code when time expires.

Is the test proctored, and can I Google during it?

JPMorgan hasn't published its settings. HackerRank can flag tab switches and monitor webcams when an employer enables it, so assume you are monitored and follow your invitation's rules. Preparation should make Googling unnecessary.

How soon do I hear back?

JPMorgan publishes no fixed timeline and applications are reviewed on a rolling basis. Candidates report waits from days to several weeks.

Start preparing today with the DSA Patterns Sheet.