PlacementPrep

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

34 min read
Company Placement Papers
Advertisement Placement

CRED Placement Papers 2026 - Complete Preparation Guide

Last Updated: March 2026

📋 Company Overview

CRED is an Indian fintech company founded in 2018 by Kunal Shah, the founder of FreeCharge. Headquartered in Bengaluru, Karnataka, CRED has revolutionized credit card payments in India by creating a members-only platform that rewards users for paying their credit card bills on time.

With a valuation exceeding $6 billion, CRED has expanded into rent payments, utility bill payments, short-term lending (CRED Cash), and e-commerce (CRED Store). The company is known for its premium brand positioning, distinctive marketing campaigns featuring celebrities, and focus on high-trust users with good credit scores.

🎯 Eligibility Criteria for Freshers 2026

ParameterRequirements
Academic QualificationB.Tech/B.E (CS/IT/ECE), MCA, M.Tech, B.Des (for design roles)
Batch Eligible2025, 2026 graduating batches
Minimum CGPA7.5/10 or 75% throughout academics
BacklogsNo active backlogs
Skills PreferredPython, Node.js, React, React Native, System Design, Product Thinking
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
Performance BonusUp to 20% of CTC
ESOPsVariable (significant upside)
Total CTC₹20,00,000 - ₹30,00,000

📊 Exam Pattern 2026

CRED follows a unique hiring process focusing on product thinking and system design:

Stage 1: Online Assessment (OA)

SectionDurationQuestionsTopics
Aptitude & Logic30 mins15Quant, Puzzles, Pattern Recognition
Product Sense20 mins5Product case studies, metrics
Technical MCQ25 mins15DSA, System Design, Web Technologies
Coding Problems60 mins2-3Algorithms, Data Structures
System Design (Theory)30 mins5HLD concepts, scalability

Stage 2-5: Interview Rounds

RoundTypeDurationFocus Area
Round 2Problem Solving60 minsDSA, coding
Round 3System Design60 minsDesign distributed systems
Round 4Product/Managerial45 minsProduct thinking, guesstimates
Round 5Culture Fit30 minsValues alignment, motivation

Marking Scheme:

  • Aptitude: +4/-1 scoring
  • Coding evaluated on efficiency, edge cases, code elegance
  • Heavy weightage on system design and product sense

🧮 Aptitude Questions with Solutions (15 Questions)

Question 1

Problem: CRED has 2 million active users. If 40% are premium members paying ₹1,999 annually and the rest are free users, what is the annual revenue from premium subscriptions?

Solution: Premium users = 2,000,000 × 0.40 = 800,000 Annual revenue = 800,000 × 1,999 = ₹1,599,200,000 or ₹159.92 crores

Question 2

Problem: A credit card offers 2% cashback on all transactions. If you spend ₹25,000 in a month, how much cashback do you earn?

Solution: Cashback = 25,000 × 0.02 = ₹500

Question 3

Problem: Find the next number: 2, 6, 12, 20, 30, 42, ?

Solution: Pattern: n(n+1) where n starts at 1 1×2=2, 2×3=6, 3×4=12, 4×5=20, 5×6=30, 6×7=42, 7×8=56

Question 4

Problem: The average of 8 numbers is 25. If each number is multiplied by 3, what is the new average?

Solution: When each number is multiplied by k, average is also multiplied by k. New average = 25 × 3 = 75

Question 5

Problem: A sum of money at simple interest amounts to ₹8,200 in 4 years and ₹9,100 in 7 years. Find the principal.

Solution: Interest for 3 years (7-4) = 9100 - 8200 = ₹900 Interest for 1 year = ₹300 Interest for 4 years = ₹1,200 Principal = 8200 - 1200 = ₹7,000

Question 6

Problem: If a bill payment reminder is sent every 15 days starting January 1, on which dates in February will reminders be sent? (Assume non-leap year)

Solution: January reminders: Jan 1, Jan 16, Jan 31 February reminders: Feb 15, Mar 2 In February: February 15 only

Question 7

Problem: A merchant marks goods 50% above cost price and gives a 20% discount. What is the profit percentage?

Solution: Let CP = 100 Marked Price = 150 SP = 150 × 0.80 = 120 Profit = 20%

Shortcut: (1.50 × 0.80 - 1) × 100 = 0.20 × 100 = 20%

Question 8

Problem: In a group of 70 people, 45 use CRED, 35 use other payment apps, and 15 use both. How many use neither?

Solution: CRED ∪ Others = 45 + 35 - 15 = 65 Neither = 70 - 65 = 5 people

Question 9

Problem: If 8 workers can complete a job in 12 days, how many days will 16 workers take?

Solution: M1×D1 = M2×D2 8 × 12 = 16 × D2 D2 = 96/16 = 6 days

Question 10

Problem: Find the wrong number: 1, 1, 2, 6, 24, 96, 720

Solution: Pattern: Factorial sequence 1! = 1, 2! = 2, 3! = 6, 4! = 24, 5! = 120, 6! = 720 96 should be 120

Question 11

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

Solution: Let distance = d km, scheduled time = t hours d/4 = t + 10/60 = t + 1/6 d/6 = t - 5/60 = t - 1/12

Subtracting: d/4 - d/6 = 1/6 + 1/12 = 1/4 d(3-2)/12 = 1/4 d/12 = 1/4 d = 3 km

Question 12

Problem: The ratio of boys to girls in a tech team is 5:3. If 12 more girls join, the ratio becomes 5:4. Find the original number of boys.

Solution: Let boys = 5x, girls = 3x 5x/(3x + 12) = 5/4 20x = 15x + 60 5x = 60 x = 12 Boys = 5 × 12 = 60

Question 13

Problem: Find the unit digit of 2^51 + 3^49.

Solution: Cycle of 2: 2, 4, 8, 6 (every 4) 51 mod 4 = 3, so 2^51 ends in 8

Cycle of 3: 3, 9, 7, 1 (every 4) 49 mod 4 = 1, so 3^49 ends in 3

Unit digit of sum: 8 + 3 = 11 → 1

Question 14

Problem: A sum becomes 4 times itself in 6 years at compound interest. In how many years will it become 16 times itself?

Solution: If 4 times in 6 years, then: Year 6: 4x Year 12: 16x Answer = 12 years

Shortcut: Since 16 = 4², time = 6 × 2 = 12 years

Question 15

Problem: Solve for x: log₂(x) + log₂(x-2) = 3

Solution: log₂(x(x-2)) = 3 x(x-2) = 2³ = 8 x² - 2x - 8 = 0 (x-4)(x+2) = 0 x = 4 or x = -2 Since log of negative is undefined, x = 4

💻 Technical/CS Questions with Solutions (10 Questions)

Question 1

Q: Design a Credit Card Bill Payment System.

  1. Bill Fetch Service:

    • Integrates with card networks (Visa, Mastercard, RuPay)
    • Fetches outstanding amount, due date, minimum due
    • Uses secure APIs with encryption

  2. Payment Orchestrator:

    • Routes payments to appropriate gateways
    • Handles UPI, Netbanking, Debit Card options
    • Implements retry logic for failures

  3. Notification Service:

    • Sends bill reminders via push, SMS, email
    • Schedule based on due date
    • Smart reminders for different user segments

  4. Rewards Engine:

    • Calculates CRED coins based on bill amount
    • Tracks user streaks for consistent payments
    • Manages reward redemption

Database Design:

  • Users: user_id, credit_score, joined_date
  • Cards: card_id, user_id, masked_number, network
  • Bills: bill_id, card_id, amount, due_date, status
  • Payments: payment_id, bill_id, amount, method, status

Scaling Considerations:

  • Queue-based architecture for high throughput
  • Idempotency for duplicate payment prevention
  • Event sourcing for transaction history

Question 2

Q: Explain the concept of Gamification in Apps.

CRED Examples:

  • CRED Coins: Reward points for bill payments
  • Streaks: Rewards for consistent on-time payments
  • Jackpots: Random rewards creating variable reinforcement
  • Leaderboards: Community comparisons (anonymized)

Core Mechanics:

  1. Points: Quantify progress (CRED coins)
  2. Badges: Achievement recognition
  3. Leaderboards: Social comparison
  4. Challenges: Time-bound goals
  5. Progress Bars: Visual goal tracking

Psychology:

  • Variable rewards create dopamine loops
  • Loss aversion drives streak maintenance
  • Social proof through community features

Question 3

Q: What is A/B Testing and how would you implement it?

Implementation:

  1. Hypothesis: Define what you're testing (e.g., "Green CTA button increases conversions")

  2. Randomization:

def assign_variant(user_id):
    hash_val = hash(f"{user_id}{experiment_id}")
    return 'A' if hash_val % 2 == 0 else 'B'

  1. Metrics:

    • Primary: Conversion rate, revenue
    • Secondary: Engagement, retention
    • Guardrail: Error rates, latency

  2. Statistical Significance:

    • Calculate sample size beforehand
    • Use chi-square or t-tests
    • 95% confidence level minimum

  3. Duration: Run for full business cycles

CRED Use Cases:

  • Notification timing optimization
  • Rewards screen layouts
  • Onboarding flow variations

Question 4

Q: Explain API Rate Limiting strategies.

Algorithms:

  1. Token Bucket:

    • Tokens added at fixed rate to bucket
    • Request consumes token
    • Allows short bursts

  2. Leaky Bucket:

    • Queue requests, process at fixed rate
    • Queue full = requests dropped
    • Smooths traffic

  3. Fixed Window:

    • Count requests in time window
    • Reset at window boundary
    • Simple but has burst issues

  4. Sliding Window Log:

    • Store timestamp of each request
    • Count requests in sliding window
    • Accurate but memory intensive

  5. Sliding Window Counter:

    • Approximation combining fixed windows
    • Good balance of accuracy and efficiency

Implementation:

import redis

def is_allowed(user_id, max_requests=100, window=60):
    key = f"rate_limit:{user_id}"
    pipe = redis.pipeline()
    now = time.time()
    pipe.zremrangebyscore(key, 0, now - window)
    pipe.zcard(key)
    pipe.zadd(key, {str(now): now})
    pipe.expire(key, window)
    _, current, _, _ = pipe.execute()
    return current < max_requests

Question 5

Q: What is Feature Flagging and its benefits?

Types:

  1. Release Toggles: Hide incomplete features
  2. Experiment Toggles: A/B testing
  3. Ops Toggles: Circuit breakers, kill switches
  4. Permission Toggles: Premium features

Benefits:

  • Continuous Deployment: Deploy incomplete features safely
  • Canary Releases: Gradual rollout to % of users
  • Instant Rollback: Disable problematic features
  • A/B Testing: Control feature exposure
  • Premium Tiers: Gated features for different user types

Architecture:

if feature_flags.is_enabled('new_checkout_flow', user_id):
    show_new_checkout()
else:
    show_old_checkout()

Tools: LaunchDarkly, Unleash, custom implementations with Redis

Question 6

Q: Explain Webhook architecture and reliability mechanisms.

Architecture:

  1. Event Generation: System generates event
  2. Webhook Registration: Users register callback URLs
  3. Delivery: HTTP POST to registered URLs
  4. Acknowledgment: 2xx response indicates success

Reliability Mechanisms:

  1. Retries:

    • Exponential backoff: 1s, 2s, 4s, 8s...
    • Maximum retry attempts
    • Dead letter queue for failures

  2. Idempotency:

    • Include event_id in payload
    • Consumers deduplicate using event_id

  3. Circuit Breaker:

    • Stop sending to failing endpoints
    • Health checks to re-enable

  4. Signature Verification:

    • HMAC signature in header
    • Consumers verify authenticity
import hmac
import hashlib

def generate_signature(payload, secret):
    return hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()

Question 7

Q: What is the difference between Monolithic and Microservices architecture?

AspectMonolithicMicroservices
StructureSingle codebaseMultiple independent services
DeploymentOne deploy for allIndependent service deployment
ScalingScale entire appScale individual services
Tech StackSingle technologyPolyglot (different per service)
ComplexitySimpler initiallyHigher operational complexity
DebuggingEasierDistributed tracing needed
Team StructureHorizontal layersVertical business domains

When to Choose:

  • Monolith: Small team, rapid prototyping, simple domain
  • Microservices: Large scale, multiple teams, independent scaling needs

CRED Approach: Microservices for independent scaling of payments, rewards, and store.

Question 8

Q: Explain Database Connection Pooling.

Why Needed:

  • Creating connections is expensive (TCP handshake, auth)
  • Without pooling: Connection per request = overhead
  • With pooling: Reuse existing connections

How It Works:

  1. Pool creates minimum connections on startup
  2. Thread requests connection from pool
  3. If available, connection is borrowed
  4. If all in use and pool not full, create new
  5. If pool full, wait or reject
  6. Connection returned to pool after use

Configuration:

  • Min Pool Size: Always keep these connections
  • Max Pool Size: Upper limit
  • Connection Timeout: Max wait for connection
  • Idle Timeout: Close unused connections

Python Example:

from sqlalchemy import create_engine

engine = create_engine(
    'postgresql://user:pass@localhost/db',
    pool_size=10,
    max_overflow=20,
    pool_timeout=30,
    pool_recycle=3600
)

Question 9

Q: What is CDN and how does it improve performance?

How It Works:

  1. User requests asset (image, JS, CSS)
  2. DNS routes to nearest CDN edge server
  3. If cached, serve directly
  4. If not cached, fetch from origin, cache, serve
  5. Subsequent requests served from edge

Benefits:

  • Reduced Latency: Content served from nearby servers
  • Load Reduction: Origin server handles less traffic
  • Bandwidth Savings: Cached content doesn't hit origin
  • DDoS Protection: Distributed nature absorbs attacks
  • SSL Termination: Handles encryption at edge

Types of Content:

  • Static: Images, CSS, JS (ideal for CDN)
  • Dynamic: API responses (with edge computing)

CRED Usage: App assets, marketing images, static content.

Question 10

Q: Explain the concept of Data Consistency in distributed systems.

Consistency Models:

  1. Strong Consistency:

    • All reads see the most recent write
    • Synchronous replication
    • Higher latency

  2. Eventual Consistency:

    • Reads may not see latest write immediately
    • Updates propagate asynchronously
    • All replicas converge eventually

  3. Causal Consistency:

    • Preserves因果关系 (causal relationships)
    • Concurrent writes may be seen differently

CAP Theorem Context:

  • Choose consistency level based on use case
  • Financial transactions: Strong consistency
  • Social feeds: Eventual consistency acceptable

Implementation:

  • Strong: 2PC, Paxos, Raft
  • Eventual: Gossip protocols, vector clocks

📝 Verbal/English Questions with Solutions (10 Questions)

Question 1

Spot the error: The team of developers are working on the new feature.

Question 2

Fill in the blank: CRED _______ one of the most valuable fintech startups in India.

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

Question 3

Synonym: PRISTINE

Options: (a) Dirty (b) Flawless (c) Old (d) Damaged

Question 4

Antonym: FRUGAL

Options: (a) Economical (b) Extravagant (c) Careful (d) Thrifty

Question 5

Rearrange: (A) CRED rewards / (B) responsible financial / (C) users for / (D) behavior

Question 6

Idiom: "To break the bank"

Meaning: (a) To rob a bank (b) To cost too much (c) To save money (d) To invest wisely

Question 7

One word substitution: A person who spends money extravagantly

Options: (a) Miser (b) Spendthrift (c) Economist (d) Banker

Question 8

Reading Comprehension: CRED's business model focuses on acquiring high-trust customers with good credit scores, offering them exclusive rewards and experiences in exchange for timely credit card bill payments.

What is CRED's target customer segment?

Question 9

Sentence Correction: Neither the designer nor the developers was satisfied with the prototype.

Question 10

Analogies: Credit Card : Payment :: Insurance : ?

Options: (a) Money (b) Protection (c) Risk (d) Investment

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

Question 1: Longest Substring Without Repeating Characters

Problem: Given a string, find the length of the longest substring without repeating characters.

Solution:

def length_of_longest_substring(s):
    """
    Sliding Window Approach
    Time Complexity: O(n)
    Space Complexity: O(min(m, n)) where m is charset size
    """
    char_index = {}  # char -> last seen index
    max_length = 0
    start = 0
    
    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        
        char_index[char] = end
        max_length = max(max_length, end - start + 1)
    
    return max_length

# Test
print(length_of_longest_substring("abcabcbb"))  # 3 ("abc")
print(length_of_longest_substring("bbbbb"))     # 1 ("b")
print(length_of_longest_substring("pwwkew"))    # 3 ("wke")

Question 2: Number of Islands

Problem: Given a 2D grid representing a map of '1's (land) and '0's (water), count the number of islands.

Solution:

def num_islands(grid):
    """
    DFS Approach
    Time Complexity: O(m × n)
    Space Complexity: O(m × n) for recursion stack
    """
    if not grid:
        return 0
    
    rows, cols = len(grid), len(grid[0])
    count = 0
    
    def dfs(r, c):
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] == '0':
            return
        
        grid[r][c] = '0'  # Mark as visited
        
        # Explore all 4 directions
        dfs(r + 1, c)
        dfs(r - 1, c)
        dfs(r, c + 1)
        dfs(r, c - 1)
    
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                dfs(r, c)
    
    return count

# Test
grid = [
    ["1","1","0","0","0"],
    ["1","1","0","0","0"],
    ["0","0","1","0","0"],
    ["0","0","0","1","1"]
]
print(num_islands(grid))  # 3

Question 3: Design HashMap

Problem: Design a HashMap without using built-in hash table libraries.

Solution:

class MyHashMap:
    """
    Using separate chaining with linked list
    Time Complexity: O(1) average, O(n) worst
    Space Complexity: O(n)
    """
    def __init__(self):
        self.size = 1000
        self.buckets = [[] for _ in range(self.size)]
    
    def _hash(self, key):
        return key % self.size
    
    def put(self, key: int, value: int) -> None:
        hash_key = self._hash(key)
        bucket = self.buckets[hash_key]
        
        for i, (k, v) in enumerate(bucket):
            if k == key:
                bucket[i] = (key, value)
                return
        
        bucket.append((key, value))
    
    def get(self, key: int) -> int:
        hash_key = self._hash(key)
        bucket = self.buckets[hash_key]
        
        for k, v in bucket:
            if k == key:
                return v
        
        return -1
    
    def remove(self, key: int) -> None:
        hash_key = self._hash(key)
        bucket = self.buckets[hash_key]
        
        for i, (k, v) in enumerate(bucket):
            if k == key:
                del bucket[i]
                return

# Test
hash_map = MyHashMap()
hash_map.put(1, 1)
hash_map.put(2, 2)
print(hash_map.get(1))       # 1
print(hash_map.get(3))       # -1
hash_map.put(2, 1)
print(hash_map.get(2))       # 1
hash_map.remove(2)
print(hash_map.get(2))       # -1

Question 4: Meeting Rooms II

Problem: Given an array of meeting time intervals, find the minimum number of conference rooms required.

Solution:

def min_meeting_rooms(intervals):
    """
    Using min heap
    Time Complexity: O(n log n)
    Space Complexity: O(n)
    """
    if not intervals:
        return 0
    
    # Sort by start time
    intervals.sort(key=lambda x: x[0])
    
    import heapq
    # Min heap of end times
    rooms = [intervals[0][1]]
    
    for start, end in intervals[1:]:
        # If earliest ending meeting is done, reuse that room
        if rooms[0] <= start:
            heapq.heappop(rooms)
        
        heapq.heappush(rooms, end)
    
    return len(rooms)

# Alternative: Chronological Ordering
def min_meeting_rooms_chronological(intervals):
    if not intervals:
        return 0
    
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    
    rooms = 0
    end_ptr = 0
    
    for start in starts:
        if start >= ends[end_ptr]:
            # Reuse room
            end_ptr += 1
        else:
            # Need new room
            rooms += 1
    
    return rooms

# Test
print(min_meeting_rooms([[0,30],[5,10],[15,20]]))  # 2
print(min_meeting_rooms([[7,10],[2,4]]))           # 1

Question 5: Serialize and Deserialize Binary Tree

Problem: Design an algorithm to serialize and deserialize a binary tree.

Solution:

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

class Codec:
    """
    Preorder traversal based serialization
    Time Complexity: O(n) for both
    Space Complexity: O(n) for both
    """
    def serialize(self, root):
        """Encodes a tree to a single string"""
        def helper(node):
            if not node:
                result.append("#")
                return
            result.append(str(node.val))
            helper(node.left)
            helper(node.right)
        
        result = []
        helper(root)
        return ",".join(result)
    
    def deserialize(self, data):
        """Decodes your encoded data to tree"""
        def helper():
            val = next(values)
            if val == "#":
                return None
            node = TreeNode(int(val))
            node.left = helper()
            node.right = helper()
            return node
        
        values = iter(data.split(","))
        return helper()

# Test
# Create tree:    1
#               / \
#              2   3
#                 / \
#                4   5
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(4)
root.right.right = TreeNode(5)

codec = Codec()
serialized = codec.serialize(root)
print(serialized)  # "1,2,#,#,3,4,#,#,5,#,#"
deserialized = codec.deserialize(serialized)
print(codec.serialize(deserialized))  # Same output

🎯 Interview Tips for CRED

  1. Product Thinking: CRED values product sense highly. Practice guesstimates (market sizing), feature prioritization frameworks, and metrics analysis.

  2. Know the Business: Understand CRED's revenue model, user segments, and competitors. Read about their expansion into lending, insurance, and e-commerce.

  3. System Design Depth: Be ready to design scalable systems with focus on reliability and user experience. Think about fraud detection, payment reliability, and notification systems.

  4. Clean Code: CRED engineers value code elegance. Write modular, well-named, and testable code in interviews.

  5. Startup Mindset: Show entrepreneurial thinking, comfort with ambiguity, and willingness to wear multiple hats.

  6. Design Aesthetics: If applying for frontend/mobile roles, showcase attention to UI/UX details. CRED is design-focused.

  7. Financial Awareness: Basic understanding of credit scores, lending, and fintech regulations shows maturity.

❓ Frequently Asked Questions (FAQs)

Q1: What makes CRED different from other fintech companies?

A: CRED focuses on premium, high-trust customers with good credit scores. Their reward-first model and distinctive brand positioning differentiate them from competitors like Paytm and PhonePe.

Q2: What is the work culture like at CRED?

A: CRED has a design-centric, product-focused culture with high ownership. Teams are small and empowered, similar to early-stage startups but with the resources of a well-funded company.

Q3: Does CRED have a machine coding round?

A: Yes, CRED typically includes a system design + machine coding hybrid round where you design and implement a working component.

Q4: What tech stack does CRED use?

A: CRED uses Node.js, Python, React, React Native, Go, PostgreSQL, MongoDB, Redis, Kafka, and AWS infrastructure.

Q5: What are CRED's expansion plans?

A: CRED is expanding into lending (CRED Cash), insurance, e-commerce (CRED Store), and international markets. Understanding this ecosystem is valuable for interviews.

Ace your CRED placement with confidence! 🚀

Advertisement Placement

Share this article: