Tools
EXAMS TODAY!
Get Notes Now
Juspay Hiring Challenge 2026

Juspay Test Day Checklist

Everything you need to know about the 3-round Juspay hiring process, platform rules, and the infamous Learn-A-Thon round that confuses most candidates

Registration Status: Closed (HackerEarth Round)

The Juspay hiring test registration window closed on September 20, 2026. If you missed Round 1, don't worry — use this checklist to prepare for the Learn-A-Thon (Round 2) if you receive an invite, or bookmark these resources for the next hiring cycle.

Already cleared Part-A MCQs? Focus on graph algorithms and the Tree of Space problem for Part-B. The prep never goes to waste!

Free DownloadNo credit card

Get the 1-Page The 4 Graph Algorithms You Must Master Before the Juspay Hiring Test — Free

Enter your email and we'll send it straight to your inbox.

  • DFS & BFS with code templates in C++, Java, Python
  • Dijkstra's algorithm for shortest path problems
  • Topological sorting for dependency resolution
  • Union-Find for connected components
  • Real Juspay-style practice problems with solutions

We'll also send you one follow-up email about our ₹79 bundle. That's it.

The 3-Round Structure

1

Round 1: Online Assessment (OA)

Duration: 4-5 hours
Format:
  • • Part A: 15-20 technical MCQs (bit manipulation, recursion, OS/concurrency, time complexity)
  • • Part B: 2-3 coding problems (including the famous "Tree of Space" locking problem)

⚠️ 70% elimination rate — MCQs are NOT standard aptitude. They are tricky CS fundamentals.

2

Round 2: 24-Hour Hackathon / Learn-A-Thon

Duration: 24 hours (submit by deadline)
What is Learn-A-Thon?

Juspay may ask you to learn a new functional programming language (PureScript, Haskell, Rust, or Elm) and build a mini-project in 24 hours.

💡 Key Strategy: Don't panic! They're NOT testing mastery of the language. They're testing your ability to read docs, debug errors, and ship working code under pressure.

How to Handle Learn-A-Thon:

  • • Hour 1-2: Read official getting-started guide, run Hello World
  • • Hour 3-6: Browse example repos on GitHub for similar projects
  • • Hour 7-20: Copy-paste-adapt patterns that work, focus on functionality
  • • Hour 21-23: Test edge cases, clean up code, write README
  • • Hour 24: Submit! Even 70% working is better than 0%
3

Round 3: Technical Interviews

Duration: 2-3 rounds, 45-60 minutes each
What to Expect:
  • • Round 3A: DSA problem-solving (graphs, DP, trees)
  • • Round 3B: System design / functional programming discussion
  • • Round 3C (if any): Behavioral + project deep-dive

🎯 Round-by-Round Elimination Thresholds

Real cutoff benchmarks from Juspay 2024-2026 batches. These are the scores you need to advance past each stage:

1A

Round 1 Part-A: Technical MCQ Screening

  • • Questions: 15-20 MCQs (bit manipulation, recursion, OS/concurrency, time complexity)
  • • Typical Clearance: 70-75%+ (12-15 correct answers)
  • • No Negative Marking — but questions are locked after submission
  • • Elimination Rate: ~70% filtered here (trickiest MCQs in campus placements)
1B

Round 1 Part-B: Coding Problems (Tree of Space)

  • • Problems: 2-3 coding tasks (4-5 hours total)
  • • Critical Problem: "Tree of Space" locking/unlocking (M-ary tree with concurrency)
  • • Minimum to Pass:
    • → Tree of Space: 100% of visible test cases + 80%+ hidden
    • → Other problems: 60%+ test cases each
  • • Elimination Rate: ~50% filtered (only 15-20% pass Tree of Space)

⚠️ Critical: Partial solutions don't count. You MUST achieve O(log n) or O(h) time complexity for lock/unlock operations to pass hidden test cases.

2

Round 2: 24-Hour Learn-A-Thon (Functional Programming)

  • • Challenge: Learn PureScript/Haskell and build a mini-project in 24 hours
  • • Evaluation Criteria:
    • → Working functionality: 70%+ features implemented
    • → Code quality: Clean, documented, follows FP patterns
    • → Learning aptitude: Did you grasp FP concepts quickly?
  • • Pro Tip: They're NOT testing mastery — focus on shipping working code even if imperfect
  • • Elimination Rate: ~30% filtered (learning ability + functional thinking)
3

Round 3: Technical Interviews (2-3 rounds)

  • • Round 3A: DSA deep-dive (graphs, DP, trees) — must solve 1-2 problems live
  • • Round 3B: System design OR functional programming discussion
  • • Clearance Bar:
    • → Solve at least 1 medium problem correctly with optimal approach
    • → Explain Tree of Space solution coherently (time/space complexity reasoning)
    • → Show functional programming understanding (even basic level)
  • • Elimination Rate: ~20% filtered (behavioral fit + technical depth)

📊 Overall Success Rate: Only 2-3% of applicants receive final offers. The Tree of Space problem (Part-B) is the single biggest filter — invest 80% of your prep time there.

Platform Rules & Proctoring

Round 1 (Online Assessment):

  • • Platform: HackerEarth or Unstop's custom platform
  • • Browser Lock: May require full-screen mode (no tab switching)
  • • Camera Proctoring: Webcam must be ON for entire duration
  • • Code Editor: Built-in IDE with C++, Java, Python support
  • • Test Cases: Only 2-3 visible, 80%+ hidden (must pass all to clear)
  • • Submission Limit: Unlimited, but each submission counts toward time

Round 2 (24-Hour Hackathon):

  • • Platform: Usually GitHub submission or Google Drive upload
  • • No Proctoring: You can use any resources, Google, Stack Overflow
  • • Submission Format: GitHub repo link + README with setup instructions
  • • Evaluation: Code quality, functionality, documentation

Round 3 (Technical Interviews):

  • • Platform: Google Meet / Zoom with shared coding pad
  • • Format: Live coding + discussion
  • • Tools: CoderPad, Google Docs, or whiteboard

48-Hour Prep Checklist

Tree of Space Deep-Dive

Battle-tested solutions in C++, Java, Python with line-by-line explanations

Read Guide →

15-Minute MCQ Drill

Practice the exact questions that filter 70% in Part-A screening

Start Drill →