Juspay Placement Papers 2026

Last Updated: March 2026

---

Company Overview

Juspay is India's leading payments technology company that powers the payment infrastructure for some of the largest internet companies in the country. It is the technology partner behind major UPI platforms and processes over 50 million transactions daily. Juspay built the BECKN protocol that powers the Open Network for Digital Commerce (ONDC) and its payment orchestration platform HyperSDK is used by companies like Amazon, Flipkart, Swiggy, and IRCTC.

Key Facts:

• Founded: 2012
• Headquarters: Bangalore, Karnataka
• Employees: 1,200+
• Key Products: HyperSDK, NAMMA (open mobility), Express Checkout, Juspay Safe
• Backed By: Accel Partners, VEF, SoftBank Vision Fund
• Transactions Processed: 50+ million per day

Juspay is considered one of the best startups for engineers who want to work on high-scale, low-latency financial systems. The company is known for its functional programming culture (Haskell, PureScript) and strong engineering-first ethos. Campus hiring happens during March-June at top engineering colleges.

---

Eligibility Criteria

Criteria	Requirement
Degree	B.Tech/B.E, M.Tech, Dual Degree
Branches	CSE, IT, ECE, EEE (with strong coding)
Academic Score	7.0+ CGPA or 70%+ in X, XII, Graduation
Backlogs	No active backlogs
Gap	No educational gap preferred
Experience	Freshers and pre-final year interns

---

CTC & Compensation

Role	CTC (Fresher)	In-Hand (Approx)
Software Engineer	Rs 18-28 LPA	Rs 1,20,000-1,80,000/month
Backend Engineer	Rs 18-28 LPA	Rs 1,20,000-1,80,000/month
Frontend Engineer	Rs 16-24 LPA	Rs 1,05,000-1,55,000/month
SDE Intern (6 months)	Rs 50,000-80,000/month stipend	—

Note: Juspay offers among the highest fresher salaries in the Indian startup ecosystem. CTC includes base salary, performance bonus, and ESOPs. Top performers from IITs can receive offers exceeding Rs 30 LPA.

---

Selection Process

Juspay's recruitment process is known for being technically demanding:

1. Online Coding Round - 3 algorithmic problems (90 minutes)
2. Technical Round 1: DSA Deep Dive - Solve 2-3 problems live on a shared editor with an engineer
3. Technical Round 2: System Design + CS Fundamentals - Design a payment system component, discuss OS/DBMS/Networks
4. Technical Round 3 (for some candidates): Advanced Problem Solving - Hard-level algorithmic problems or functional programming concepts
5. Culture Fit / HR Round - Values alignment, long-term goals, interest in payments/fintech

The process is heavily coding-focused. Unlike many companies, Juspay places significant weight on code quality, not just correctness. Writing clean, well-structured code with proper variable naming and edge case handling is important.

---

Exam Pattern

Section	Questions	Duration	Difficulty Level
Coding Round	3 problems	90 min	Medium to Hard
Problem 1	1	~20 min	Medium (Greedy/Sorting)
Problem 2	1	~30 min	Medium-Hard (Trees/Graphs)
Problem 3	1	~40 min	Hard (DP/Advanced Graph)

Platform: HackerEarth / Custom Platform Languages Allowed: C, C++, Java, Python, Haskell Negative Marking: No Partial Scoring: Yes (test case based)

The coding round is the primary elimination filter. Juspay's problems are considered harder than most service companies and on par with companies like Google and Flipkart. Tree and graph problems are especially common.

---

Aptitude Questions

Juspay does not have a traditional aptitude section. However, their coding problems often require strong mathematical reasoning. Here are some logic-based problems that appear in their assessments:

Q1: Modular Arithmetic

Find the remainder when 2^100 is divided by 7.

Solution: 2^1 mod 7 = 2, 2^2 mod 7 = 4, 2^3 mod 7 = 1 Pattern repeats every 3: 100 mod 3 = 1 2^100 mod 7 = 2^1 mod 7 = 2

Q2: Graph Theory Logic

A connected graph has 8 vertices. What is the minimum number of edges?

Solution: A connected graph with n vertices requires minimum n-1 edges (a spanning tree). Minimum edges = 8 - 1 = 7

Q3: Combinatorics

In how many ways can you climb a staircase of 10 steps if you can take 1 or 2 steps at a time?

Solution: This is the Fibonacci sequence: f(1)=1, f(2)=2, f(n)=f(n-1)+f(n-2) f(10) = 89 ways

Q4: Bit Manipulation

What is the result of 25 XOR 30?

Solution: 25 = 11001, 30 = 11110 XOR: 00111 = 7

Q5: Number Theory

Find the GCD of 48 and 18 using the Euclidean algorithm.

Solution: 48 = 18 x 2 + 12 18 = 12 x 1 + 6 12 = 6 x 2 + 0 GCD = 6

---

Technical Questions

Q1: Explain how a payment transaction works in a UPI system.

Q2: What is the difference between optimistic and pessimistic locking?

Q3: Explain event-driven architecture. Why is it important for payment systems?

Q4: What are B-Trees and why are they used in databases?

Q5: What is the difference between horizontal and vertical scaling?

---

Coding Questions

Q1: Lowest Common Ancestor in a Binary Tree

Given a binary tree and two nodes, find their lowest common ancestor.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def lowest_common_ancestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left = lowest_common_ancestor(root.left, p, q)
    right = lowest_common_ancestor(root.right, p, q)
    if left and right:
        return root
    return left if left else right

# Time: O(n) | Space: O(h) where h is tree height

Q2: Detect Cycle in a Directed Graph

Given a directed graph represented as an adjacency list, detect if it contains a cycle.

def has_cycle(num_nodes, adj_list):
    WHITE, GRAY, BLACK = 0, 1, 2
    color = [WHITE] * num_nodes

    def dfs(node):
        color[node] = GRAY
        for neighbor in adj_list[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 range(num_nodes):
        if color[node] == WHITE:
            if dfs(node):
                return True
    return False

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

Q3: Minimum Cost to Connect All Cities (Prim's Algorithm)

Given N cities and weighted edges between some of them, find the minimum cost to connect all cities.

import heapq

def min_cost_connect(n, edges):
    # Build adjacency list
    graph = [[] for _ in range(n)]
    for u, v, w in edges:
        graph[u].append((w, v))
        graph[v].append((w, u))

    visited = set()
    min_heap = [(0, 0)]  # (cost, node)
    total_cost = 0

    while min_heap and len(visited) < n:
        cost, node = heapq.heappop(min_heap)
        if node in visited:
            continue
        visited.add(node)
        total_cost += cost
        for weight, neighbor in graph[node]:
            if neighbor not in visited:
                heapq.heappush(min_heap, (weight, neighbor))

    return total_cost if len(visited) == n else -1

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

---

Interview Tips

1. Think Aloud: Juspay interviewers value your problem-solving process. Explain your approach before writing code.
2. Code Quality: Write clean code with meaningful variable names and proper structure. Avoid single-letter variables (except loop counters).
3. Edge Cases: Always discuss edge cases before and after coding. Empty inputs, single elements, very large inputs.
4. Time/Space Complexity: Analyze and state the complexity of your solution. If asked to optimize, discuss trade-offs.
5. Functional Programming: Juspay uses Haskell and PureScript internally. Showing familiarity with functional concepts (immutability, pure functions, higher-order functions) is a plus but not mandatory for freshers.
6. Payment Domain: Understanding basic payment flows (UPI, cards, wallets) shows genuine interest and can set you apart.
7. Ask Questions: Show curiosity about Juspay's tech challenges, scale, and engineering culture.

---

Preparation Strategy

1. DSA Priority: Focus on Trees (BST, Binary Trees, segment trees), Graphs (BFS, DFS, shortest path, topological sort, cycle detection), and Dynamic Programming (knapsack, LCS, matrix chain). These topics account for 70%+ of Juspay coding questions.
2. LeetCode Target: Solve 250+ problems - 80 Easy, 120 Medium, 50 Hard. Focus on tree and graph sections.
3. Competitive Programming: Participate in 2-3 contests per week on Codeforces or AtCoder to build speed.
4. System Design: Read about payment system architecture, idempotency, distributed transactions, and event sourcing.
5. CS Fundamentals: Operating Systems (process synchronization, deadlocks, virtual memory), DBMS (ACID properties, indexing, transactions), and Networks (TCP/IP, HTTP, REST).
6. Past Papers: Practice previous Juspay coding problems from GeeksforGeeks and PrepInsta.

---

Previous Year Cutoffs

College Tier	Coding Test Cutoff	Final Selection Rate
Tier 1 (IITs, BITS, IIIT-H)	2.5/3 problems (with optimal solutions)	~20% of shortlisted
Tier 2 (NITs, top private)	3/3 problems	~10% of shortlisted

Juspay is highly selective. The company prefers fewer high-quality hires over volume hiring. Strong coding skills and clean code are non-negotiable.

---

FAQs

Is Juspay a good company for freshers to start their career?

Juspay is widely regarded as one of the best startups for freshers in India. You get to work on large-scale payment systems processing 50+ million transactions daily, learn functional programming (Haskell), and collaborate with a strong engineering team. The high CTC (Rs 18-28 LPA for freshers) and rapid career growth make it attractive. However, the work intensity is high, and you should be comfortable with a fast-paced startup environment.

Does Juspay require knowledge of Haskell for campus hiring?

No, Haskell knowledge is not required for the campus hiring process. You can use C++, Java, or Python for the coding rounds. However, showing awareness of functional programming concepts (pure functions, immutability, map/filter/reduce) is appreciated during interviews. Once you join, Juspay provides training for Haskell and PureScript, which are used for backend and frontend development respectively.

How is Juspay's work-life balance?

Juspay follows a startup culture with a strong engineering focus. During critical projects or payment processing issues, the pace can be intense. However, the company has improved work-life balance policies over the years, including flexible working hours and a hybrid work model. Freshers should expect a steep learning curve in the first 6-12 months. The work is intellectually stimulating, which many engineers find rewarding despite the intensity.

What makes Juspay's coding test different from other companies?

Juspay's coding test stands out because of its heavy emphasis on tree and graph problems, which many candidates underprepare for. While companies like TCS or Infosys test basic programming, Juspay's problems are at LeetCode Medium-Hard level. Additionally, partial scoring means your score depends on how many test cases pass, so brute-force solutions that pass basic cases are partially rewarded. The test also evaluates code quality, not just correctness.

Does Juspay offer internship-to-full-time conversion?

Yes, Juspay actively hires interns from pre-final year batches (typically 6-month internships). The conversion rate to full-time offers is approximately 60-70%, depending on performance. Interns work on production-level projects and are evaluated based on code quality, problem-solving ability, and collaboration skills. The internship stipend ranges from Rs 50,000-80,000 per month.

---

All the best for your Juspay placement preparation! Master trees, graphs, and dynamic programming to crack the coding rounds, and demonstrate genuine curiosity about payment technology during interviews.