PlacementPrep

Razorpay Placement Papers 2026 | Freshers Exam Pattern, Syllabus & Questions

36 min read
Company Placement Papers
Advertisement Placement

Razorpay Placement Papers 2026 - Complete Preparation Guide

Last Updated: March 2026

📋 Company Overview

Razorpay is India's leading full-stack financial solutions company, founded in 2014 by Harshil Mathur and Shashank Kumar. Headquartered in Bengaluru, Karnataka, Razorpay started as a payment gateway provider and has evolved into a comprehensive financial infrastructure platform serving businesses of all sizes.

With a valuation of over $7 billion, Razorpay powers payments for 8+ million businesses including enterprises like Facebook, Ola, Zomato, and Swiggy. The company offers payment gateway, payment links, payment pages, subscriptions, smart collect, route (split payments), and banking services (RazorpayX).

🎯 Eligibility Criteria for Freshers 2026

ParameterRequirements
Academic QualificationB.Tech/B.E (CS/IT/ECE), MCA, M.Tech
Batch Eligible2025, 2026 graduating batches
Minimum CGPA7.5/10 or 75% throughout academics
BacklogsNo active backlogs at time of joining
Skills PreferredGo, Node.js, React, Python, PostgreSQL, Redis, Kafka
ExperienceFreshers (0-1 years)

💰 CTC Package for Freshers 2026

ComponentAmount (INR)
Base Salary₹15,00,000 - ₹22,00,000
Joining Bonus₹2,00,000 - ₹3,00,000
Relocation Allowance₹50,000 - ₹75,000
Performance BonusUp to 20% of CTC
ESOPsVariable (vesting over 4 years)
BenefitsHealth insurance, wellness, learning budget
Total CTC₹20,00,000 - ₹30,00,000

📊 Exam Pattern 2026

Razorpay's recruitment process emphasizes practical problem-solving and system design:

Stage 1: Online Assessment (OA)

SectionDurationQuestionsTopics
Quantitative Aptitude25 mins12Arithmetic, Algebra, Probability
Logical Reasoning20 mins10Puzzles, Pattern Recognition
Technical MCQ30 mins20DSA, OOPS, DBMS, CN, OS
Coding Problems75 mins3Algorithms, Data Structures
System Design Theory20 mins5Scalability, Architecture

Stage 2-5: Interview Rounds

RoundTypeDurationFocus Area
Round 2DSA + Problem Solving60-75 mins2-3 coding problems
Round 3System Design60 minsDesign scalable systems
Round 4Engineering Manager45 minsProjects, experience
Round 5HR + Culture30 minsMotivation, compensation

Marking Scheme:

  • MCQs: +4 for correct, -1 for incorrect
  • Coding: Evaluated on correctness, efficiency, code readability
  • Heavy emphasis on problem-solving approach and communication

🧮 Aptitude Questions with Solutions (15 Questions)

Question 1

Problem: Razorpay processes 50,000 transactions per minute during peak hours. How many transactions does it process in an 8-hour peak window?

Solution: Transactions per hour = 50,000 × 60 = 3,000,000 8-hour total = 3,000,000 × 8 = 24,000,000 transactions

Question 2

Problem: A payment gateway charges 2% + ₹3 per transaction. What is the total fee for a ₹5,000 transaction?

Solution: Percentage fee = 5,000 × 0.02 = ₹100 Fixed fee = ₹3 Total fee = ₹103

Question 3

Problem: Find the missing number: 3, 8, 15, 24, 35, ?

Solution: Pattern: n(n+2) where n starts at 1 1×3=3, 2×4=8, 3×5=15, 4×6=24, 5×7=35, 6×8=48

Question 4

Problem: The average of 6 numbers is 28. When a 7th number is added, the average becomes 30. What is the 7th number?

Solution: Sum of 6 numbers = 6 × 28 = 168 Sum of 7 numbers = 7 × 30 = 210 7th number = 210 - 168 = 42

Question 5

Problem: A merchant offers a 15% discount on an item marked at ₹800, then an additional 10% discount on the reduced price. What is the final price?

Solution: After 15% discount: 800 × 0.85 = ₹680 After 10% discount: 680 × 0.90 = ₹612

Shortcut: 800 × 0.85 × 0.90 = 800 × 0.765 = ₹612

Question 6

Problem: In a batch of 100 payment requests, 5% fail due to network issues and 10% fail due to insufficient funds. How many payments succeed?

Solution: Total failures = 5% + 10% = 15% Success rate = 85% Successful payments = 100 × 0.85 = 85

Question 7

Problem: If a sum doubles in 5 years at compound interest, in how many years will it become 8 times itself?

Solution: 2 times in 5 years 4 times in 10 years 8 times in 15 years

Question 8

Problem: A and B can complete a project in 12 days, B and C in 15 days, and A and C in 20 days. How long will A, B, and C take together?

Solution: 1/A + 1/B = 1/12 1/B + 1/C = 1/15 1/A + 1/C = 1/20

Adding: 2(1/A + 1/B + 1/C) = 1/12 + 1/15 + 1/20 = (5+4+3)/60 = 12/60 = 1/5 1/A + 1/B + 1/C = 1/10

Together: 10 days

Question 9

Problem: Find the unit digit of 4^73 + 9^35.

Solution: Cycle of 4: 4, 6 (every 2) 73 mod 2 = 1, so 4^73 ends in 4

Cycle of 9: 9, 1 (every 2) 35 mod 2 = 1, so 9^35 ends in 9

Unit digit of sum: 4 + 9 = 13 → 3

Question 10

Problem: A man walks at 5 km/hr and misses his bus by 8 minutes. If he walks at 7 km/hr, he reaches 4 minutes early. Find the distance to the bus stop.

Solution: Let distance = d km, scheduled time = t hours d/5 = t + 8/60 d/7 = t - 4/60

Subtracting: d/5 - d/7 = 12/60 = 1/5 d(7-5)/35 = 1/5 2d/35 = 1/5 d = 3.5 km

Question 11

Problem: The present ages of A and B are in ratio 4:5. After 8 years, the ratio becomes 5:6. Find B's present age.

Solution: Let ages be 4x and 5x (4x + 8)/(5x + 8) = 5/6 6(4x + 8) = 5(5x + 8) 24x + 48 = 25x + 40 x = 8 B's age = 5 × 8 = 40 years

Question 12

Problem: A shopkeeper sells an item for ₹720 at a loss of 10%. At what price should he sell it to gain 15%?

Solution: CP = 720/0.90 = ₹800 SP for 15% profit = 800 × 1.15 = ₹920

Question 13

Problem: Find the wrong number: 1, 1, 2, 3, 5, 8, 13, 21, 34, 56

Solution: Fibonacci sequence: Each number is sum of previous two 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 56 should be 55

Question 14

Problem: In how many ways can 6 people be seated around a circular table?

Solution: Circular permutation = (n-1)! (6-1)! = 5! = 120 ways

Question 15

Problem: The HCF of two numbers is 23 and their LCM is 805. If one number is 115, find the other.

Solution: Product = HCF × LCM 115 × x = 23 × 805 x = (23 × 805)/115 = 161

💻 Technical/CS Questions with Solutions (10 Questions)

Question 1

Q: Design a Payment Gateway System.

  1. API Gateway:

    • Authentication & authorization
    • Rate limiting
    • Request routing
    • SSL termination

  2. Payment Orchestrator:

    • Route to appropriate payment method
    • Handle payment method logic (cards, UPI, netbanking)
    • Retry failed payments
    • Idempotency handling

  3. Payment Method Handlers:

    • Card: PCI-compliant tokenization, 3DS handling
    • UPI: UPI intent, collect requests
    • Netbanking: Bank redirects
    • Wallets: Wallet integrations

  4. Risk Engine:

    • Real-time fraud detection
    • Rule-based and ML models
    • Velocity checks

  5. Reconciliation:

    • Match settlements with transactions
    • Handle refunds and chargebacks

Database Schema:

  • merchants: merchant_id, api_key, settlement_config
  • transactions: txn_id, merchant_id, amount, status, method
  • settlements: settlement_id, merchant_id, amount, status

Scaling:

  • Async processing via message queues
  • Database sharding by merchant_id
  • Multi-region deployment

Question 2

Q: Explain PCI DSS Compliance.

Key Requirements:

  1. Secure Network: Firewalls, secure configurations
  2. Cardholder Data Protection: Encryption, tokenization
  3. Vulnerability Management: Regular scans, patches
  4. Access Control: Need-to-know basis, authentication
  5. Network Monitoring: Logging, intrusion detection
  6. Security Policy: Information security policies

Compliance Levels:

  • Level 1: >6M card transactions/year - full audit
  • Level 2: 1-6M transactions - SAQ + scan
  • Level 3: 20K-1M e-commerce transactions
  • Level 4: <20K e-commerce transactions

Razorpay Approach:

  • Tokenization - store tokens, not card numbers
  • 3D Secure for authentication
  • Regular PCI audits
  • Network segmentation

Question 3

Q: What is Webhook Security and how to implement it?

Security Measures:

  1. Signature Verification:
import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

  1. Timestamp Validation:

    • Include timestamp in payload
    • Reject requests older than threshold (e.g., 5 minutes)
    • Prevents replay attacks

  2. HTTPS Only:

    • Never send webhooks to HTTP URLs
    • Certificate validation

  3. IP Whitelisting:

    • Publish webhook source IPs
    • Clients whitelist these IPs

  4. Retry with Exponential Backoff:

    • Don't overwhelm receivers
    • Max retry attempts with dead letter queue

Question 4

Q: Explain Database Sharding strategies.

Sharding Strategies:

  1. Hash Sharding:

    • shard = hash(key) % num_shards
    • Even distribution
    • Hard to add shards (data movement)

  2. Range Sharding:

    • Shards by key ranges
    • Easy range queries
    • Hot spots possible

  3. Directory-Based:

    • Lookup service maps keys to shards
    • Flexible, allows rebalancing
    • Lookup service is bottleneck

  4. Geographic Sharding:

    • Data closest to users
    • Compliance with data residency

Razorpay Context:

  • Sharding by merchant_id for transaction data
  • Consistent hashing for distributed caching

Considerations:

  • Cross-shard queries are expensive
  • Shard key selection is critical
  • Rebalancing without downtime

Question 5

Q: What is Event-Driven Architecture?

Components:

  1. Event Producers: Generate events
  2. Event Bus: Routes events (Kafka, RabbitMQ)
  3. Event Consumers: Process events

Patterns:

  1. Event Notification:

    • Service emits event, others react
    • Loose coupling

  2. Event-Carried State Transfer:

    • Event contains full state
    • Consumers don't need to query source

  3. Event Sourcing:

    • State changes stored as events
    • Event log is source of truth
    • Can replay events

Benefits:

  • Scalability
  • Flexibility
  • Audit trail

Razorpay Use Cases:

  • Payment status updates
  • Settlement processing
  • Notification delivery
  • Analytics pipeline

Question 6

Q: Explain the concept of Idempotency Keys.

Why Needed:

  • Network timeouts cause retries
  • Users click buttons multiple times
  • Background jobs retry on failure

Implementation:

  1. Client generates unique key (UUID)
  2. Sends with request in header: Idempotency-Key: uuid
  3. Server stores mapping: key → response
  4. On duplicate: Return stored response
def process_payment(request):
    idempotency_key = request.headers.get('Idempotency-Key')
    
    # Check cache
    cached = cache.get(idempotency_key)
    if cached:
        return cached
    
    # Process payment
    result = execute_payment(request)
    
    # Cache result with TTL
    cache.set(idempotency_key, result, ttl=86400)
    return result

Key Properties:

  • Uniqueness: Client generates unique keys
  • TTL: Keys expire after reasonable time
  • Scope: Keys scoped to resource/endpoint

Question 7

Q: What is the difference between Authentication and Authorization?

AuthenticationAuthorization
Verifies identityDetermines permissions
"Who are you?""What can you do?"
Credentials, tokensRoles, policies, ACLs
First stepSecond step
OAuth, SAML, JWTRBAC, ABAC, OAuth scopes

Authentication Methods:

  • Password-based
  • Token-based (JWT)
  • Multi-factor (MFA)
  • OAuth/OpenID Connect
  • API Keys

Authorization Models:

  • RBAC: Role-Based Access Control
  • ABAC: Attribute-Based Access Control
  • OAuth Scopes: Permission sets

Razorpay Context:

  • API Key authentication for merchants
  • OAuth for partner integrations
  • Webhook signature verification

Question 8

Q: Explain Caching strategies and patterns.

Caching Patterns:

  1. Cache-Aside (Lazy Loading):

    • Check cache first
    • If miss, fetch from DB and populate cache
    • Application manages cache

  2. Write-Through:

    • Write to cache and DB simultaneously
    • Consistent but higher write latency

  3. Write-Behind (Write-Back):

    • Write to cache, async write to DB
    • Fast writes, risk of data loss

  4. Read-Through:

    • Cache fetches from DB on miss
    • Cache library handles population

Cache Eviction Policies:

  • LRU (Least Recently Used)
  • LFU (Least Frequently Used)
  • TTL (Time To Live)
  • Random

Challenges:

  • Cache Stampede: Thundering herd on expiry
    • Solution: Staggered TTL, request coalescing
  • Cache Invalidation: Keeping cache consistent
    • Solution: Write-through, cache warming

Razorpay Usage:

  • Merchant configuration caching
  • Token metadata caching
  • Session management with Redis

Question 9

Q: What is Distributed Tracing?

Why Needed:

  • Microservices make debugging hard
  • Need to follow request path
  • Performance bottleneck identification

Components:

  1. Trace: End-to-end request flow
  2. Span: Single operation within trace
  3. Span Context: Trace ID, Span ID, baggage

How It Works:

  1. Request enters system → New trace ID generated
  2. Each service creates spans with parent-child relationships
  3. Spans sent to collector (Jaeger, Zipkin)
  4. Visualize trace timeline

Implementation:

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("process_payment"):
    with tracer.start_as_current_span("validate_card"):
        validate_card()
    with tracer.start_as_current_span("charge_customer"):
        charge_customer()

Razorpay Context:

  • Payment flow tracing across services
  • Latency analysis
  • Error root cause analysis

Question 10

Q: Explain the Saga Pattern for distributed transactions.

Types:

  1. Choreography-Based:

    • Each service emits event after completion
    • Next service listens and acts
    • Decentralized, no coordinator

  2. Orchestration-Based:

    • Central coordinator manages flow
    • Tells each service what to do
    • Easier to understand and debug

Compensating Transactions:

  • If step fails, undo previous steps
  • Each action has corresponding rollback action

Example: Payment Flow

  1. Reserve inventory (compensate: release inventory)
  2. Charge customer (compensate: refund)
  3. Create shipment (compensate: cancel shipment)
  4. Send confirmation

Razorpay Usage:

  • Complex payment flows
  • Multi-step merchant onboarding
  • Refund processing workflows

📝 Verbal/English Questions with Solutions (10 Questions)

Question 1

Spot the error: The number of transactions have increased significantly this quarter.

Question 2

Fill in the blank: Razorpay _______ one of India's most valuable fintech companies.

Options: (a) are (b) is (c) were (d) been

Question 3

Synonym: ROBUST

Options: (a) Weak (b) Fragile (c) Strong (d) Delicate

Question 4

Antonym: TRANSPARENT

Options: (a) Clear (b) Opaque (c) Visible (d) Apparent

Question 5

Rearrange: (A) Razorpay enables / (B) to accept / (C) businesses / (D) online payments

Question 6

Idiom: "To hit the ground running"

Meaning: (a) To fall (b) To start immediately with enthusiasm (c) To run fast (d) To succeed quickly

Question 7

One word substitution: A person who starts and runs a business

Options: (a) Employee (b) Entrepreneur (c) Manager (d) Investor

Question 8

Reading Comprehension: Razorpay's Route product enables marketplaces to split payments automatically between vendors, handling complex money movement workflows and settlement reconciliation.

What problem does Route solve?

Question 9

Sentence Correction: Neither the API nor the documentation were updated.

Question 10

Analogies: Gateway : Payment :: Router : ?

Options: (a) Computer (b) Data (c) Network (d) Cable

👨‍💻 Coding Questions with Python Solutions (5 Questions)

Question 1: Binary Tree Level Order Traversal

Problem: Given the root of a binary tree, return the level order traversal of its nodes' values.

Solution:

from collections import deque

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

def level_order(root):
    """
    BFS Approach
    Time Complexity: O(n)
    Space Complexity: O(w) where w is max width
    """
    if not root:
        return []
    
    result = []
    queue = deque([root])
    
    while queue:
        level_size = len(queue)
        level = []
        
        for _ in range(level_size):
            node = queue.popleft()
            level.append(node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        result.append(level)
    
    return result

# Test
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)

print(level_order(root))  # [[3], [9, 20], [15, 7]]

Question 2: Find Median from Data Stream

Problem: Implement a data structure to find the median of a stream of numbers.

Solution:

import heapq

class MedianFinder:
    """
    Using two heaps
    Time Complexity: O(log n) for addNum, O(1) for findMedian
    Space Complexity: O(n)
    """
    def __init__(self):
        # Max heap for lower half (store negatives for Python)
        self.left = []
        # Min heap for upper half
        self.right = []
    
    def addNum(self, num: int) -> None:
        # Add to left (max heap)
        heapq.heappush(self.left, -num)
        
        # Balance: left's max should be <= right's min
        if self.left and self.right and (-self.left[0]) > self.right[0]:
            val = -heapq.heappop(self.left)
            heapq.heappush(self.right, val)
        
        # Size balance: left can have at most 1 more element
        if len(self.left) > len(self.right) + 1:
            val = -heapq.heappop(self.left)
            heapq.heappush(self.right, val)
        
        if len(self.right) > len(self.left):
            val = heapq.heappop(self.right)
            heapq.heappush(self.left, -val)
    
    def findMedian(self) -> float:
        if len(self.left) > len(self.right):
            return float(-self.left[0])
        return (-self.left[0] + self.right[0]) / 2.0

# Test
mf = MedianFinder()
mf.addNum(1)
print(mf.findMedian())  # 1.0
mf.addNum(2)
print(mf.findMedian())  # 1.5
mf.addNum(3)
print(mf.findMedian())  # 2.0

Question 3: Decode Ways

Problem: A message containing letters from A-Z is encoded to numbers. 'A'→1, 'B'→2, ..., 'Z'→26. Given a string of digits, determine the total number of ways to decode it.

Solution:

def num_decodings(s: str) -> int:
    """
    Dynamic Programming
    Time Complexity: O(n)
    Space Complexity: O(1) with space optimization
    """
    if not s or s[0] == '0':
        return 0
    
    n = len(s)
    # dp[i] = number of ways to decode s[0:i]
    dp = [0] * (n + 1)
    dp[0] = 1  # Empty string
    dp[1] = 1  # Single non-'0' digit
    
    for i in range(2, n + 1):
        # Single digit decode (if current digit is not '0')
        if s[i-1] != '0':
            dp[i] += dp[i-1]
        
        # Two digit decode (if 10-26)
        two_digit = int(s[i-2:i])
        if 10 <= two_digit <= 26:
            dp[i] += dp[i-2]
    
    return dp[n]

# Space optimized
def num_decodings_optimized(s: str) -> int:
    if not s or s[0] == '0':
        return 0
    
    prev2, prev1 = 1, 1  # dp[i-2], dp[i-1]
    
    for i in range(1, len(s)):
        current = 0
        
        if s[i] != '0':
            current += prev1
        
        two_digit = int(s[i-1:i+1])
        if 10 <= two_digit <= 26:
            current += prev2
        
        prev2, prev1 = prev1, current
    
    return prev1

# Test
print(num_decodings("12"))   # 2 ("AB", "L")
print(num_decodings("226"))  # 3 ("BZ", "VF", "BBF")
print(num_decodings("0"))    # 0

Question 4: Task Scheduler

Problem: Given tasks and cooling time n, find the least number of units of time to finish all tasks. Identical tasks must be separated by at least n intervals.

Solution:

def least_interval(tasks, n):
    """
    Time Complexity: O(n)
    Space Complexity: O(1) - at most 26 characters
    """
    from collections import Counter
    
    # Count task frequencies
    task_counts = Counter(tasks)
    max_freq = max(task_counts.values())
    
    # Number of tasks with max frequency
    max_count = sum(1 for count in task_counts.values() if count == max_freq)
    
    # Calculate minimum intervals needed
    # (max_freq - 1) cycles × (n + 1) slots + max_count tasks at end
    min_intervals = (max_freq - 1) * (n + 1) + max_count
    
    # If we have enough other tasks to fill gaps, answer is just len(tasks)
    return max(len(tasks), min_intervals)

# Test
print(least_interval(["A","A","A","B","B","B"], 2))  # 8
print(least_interval(["A","A","A","B","B","B"], 0))  # 6
print(least_interval(["A","A","A","A","A","A","B","C","D","E","F","G"], 2))  # 16

Question 5: LFU Cache

Problem: Design and implement a data structure for Least Frequently Used (LFU) cache.

Solution:

class LFUCache:
    """
    Time Complexity: O(1) for get and put
    Space Complexity: O(capacity)
    """
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.min_freq = 0
        self.key_to_val = {}  # key -> value
        self.key_to_freq = {}  # key -> frequency
        self.freq_to_keys = {}  # frequency -> {keys}
    
    def get(self, key: int) -> int:
        if key not in self.key_to_val:
            return -1
        
        # Increase frequency
        self._increase_freq(key)
        return self.key_to_val[key]
    
    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0:
            return
        
        if key in self.key_to_val:
            self.key_to_val[key] = value
            self._increase_freq(key)
            return
        
        # If at capacity, evict LFU (and LRU among them)
        if len(self.key_to_val) >= self.capacity:
            self._evict()
        
        # Add new key
        self.key_to_val[key] = value
        self.key_to_freq[key] = 1
        if 1 not in self.freq_to_keys:
            self.freq_to_keys[1] = set()
        self.freq_to_keys[1].add(key)
        self.min_freq = 1
    
    def _increase_freq(self, key):
        freq = self.key_to_freq[key]
        self.key_to_freq[key] = freq + 1
        
        # Remove from old freq
        self.freq_to_keys[freq].remove(key)
        if not self.freq_to_keys[freq]:
            del self.freq_to_keys[freq]
            if self.min_freq == freq:
                self.min_freq += 1
        
        # Add to new freq
        if freq + 1 not in self.freq_to_keys:
            self.freq_to_keys[freq + 1] = set()
        self.freq_to_keys[freq + 1].add(key)
    
    def _evict(self):
        # Get keys with min frequency
        keys = self.freq_to_keys[self.min_freq]
        # Remove LRU (any one, use iteration order)
        key_to_remove = next(iter(keys))
        keys.remove(key_to_remove)
        if not keys:
            del self.freq_to_keys[self.min_freq]
        
        del self.key_to_val[key_to_remove]
        del self.key_to_freq[key_to_remove]

# Test
lfu = LFUCache(2)
lfu.put(1, 1)
lfu.put(2, 2)
print(lfu.get(1))       # 1
lfu.put(3, 3)           # evicts key 2
print(lfu.get(2))       # -1
print(lfu.get(3))       # 3
lfu.put(4, 4)           # evicts key 1
print(lfu.get(1))       # -1
print(lfu.get(3))       # 3
print(lfu.get(4))       # 4

🎯 Interview Tips for Razorpay

  1. Understand Payments Deeply: Study payment flows, fraud detection, and payment methods. Know about UPI, cards, netbanking, and wallets.

  2. System Design: Be ready to design scalable payment systems, transaction processing, and notification systems.

  3. Security Focus: Understand PCI DSS, encryption, tokenization, and secure coding practices.

  4. Distributed Systems: Study microservices, event-driven architecture, message queues (Kafka), and distributed transactions.

  5. Coding Excellence: Write clean, efficient, well-tested code. Razorpay values production-ready code quality.

  6. Go/Python Skills: Razorpay uses Go and Python extensively. Knowledge of these languages is advantageous.

  7. Product Thinking: Understand merchant pain points and how Razorpay's products solve them. Think about developer experience.

❓ Frequently Asked Questions (FAQs)

Q1: What makes Razorpay different from other fintech companies?

A: Razorpay focuses on B2B payment infrastructure, offering comprehensive solutions for businesses including payment gateway, banking (RazorpayX), and lending services. It serves 8+ million businesses including major enterprises.

Q2: What tech stack does Razorpay use?

A: Razorpay primarily uses Go and Node.js for backend, React for frontend, PostgreSQL and MongoDB for databases, Redis for caching, Kafka for streaming, and Kubernetes for orchestration on AWS infrastructure.

Q3: Does Razorpay hire freshers through off-campus drives?

A: Yes, Razorpay hires freshers through their careers portal, coding challenges on platforms like HackerEarth, and referrals. Strong problem-solving skills and system design knowledge are valued.

Q4: What is the work culture at Razorpay?

A: Razorpay has a high ownership, fast-paced, engineering-driven culture with focus on solving real merchant problems. Teams are empowered to make decisions and ship quickly.

Q5: How should I prepare for Razorpay interviews?

A: Focus on DSA (medium-hard problems), system design (design payment systems, high-scale architectures), and understanding payment concepts. Practice coding in Go or Python if possible.

Best of luck with your Razorpay placement! 🚀

Advertisement Placement

Share this article: