Salesforce India Placement Papers 2026

Meta Description: Salesforce India placement papers 2026 with latest exam pattern, coding questions, CRM interview tips, and preparation strategy. Crack Salesforce with PapersAdda!

---

Introduction

Salesforce India is a pioneer in cloud-based CRM solutions and enterprise software. With development centers in Hyderabad and Bangalore, Salesforce offers exciting opportunities in cloud computing, AI (Einstein), and platform development. Known for its exceptional work culture and employee benefits, Salesforce is a dream employer for many tech professionals. This guide covers the complete Salesforce India 2026 placement process.

---

Salesforce India Exam & Interview Pattern 2026

Round	Type	Duration	Topics Covered
Round 1	Online Coding Test	90 mins	Data Structures, Algorithms, Aptitude
Round 2	Technical Interview 1	60 mins	Coding, Problem-solving, OOP concepts
Round 3	Technical Interview 2	60 mins	System Design, Scalability, Architecture
Round 4	Technical Interview 3	60 mins	Advanced coding, Project discussion
Round 5	Cultural/Values Interview	45 mins	Behavioral, Salesforce values alignment
Round 6	Hiring Manager	45 mins	Team fit, Career aspirations

Key Highlights:

• Strong emphasis on object-oriented design
• System design questions are common even for freshers
• Cultural fit is extremely important at Salesforce
• Questions often relate to CRM and cloud concepts

---

Practice Questions with Detailed Answers

Question 1: Design Parking Lot System

Problem: Design an object-oriented parking lot system.

Solution:

from enum import Enum
from typing import List, Optional

class VehicleType(Enum):
    MOTORCYCLE = 1
    CAR = 2
    BUS = 3

class Vehicle:
    def __init__(self, license_plate: str, vehicle_type: VehicleType):
        self.license_plate = license_plate
        self.vehicle_type = vehicle_type
        self.spot = None

class ParkingSpot:
    def __init__(self, spot_id: int, spot_type: VehicleType):
        self.spot_id = spot_id
        self.spot_type = spot_type
        self.vehicle = None
        self.is_occupied = False
    
    def can_fit(self, vehicle: Vehicle) -> bool:
        return not self.is_occupied and vehicle.vehicle_type.value <= self.spot_type.value
    
    def park(self, vehicle: Vehicle) -> bool:
        if self.can_fit(vehicle):
            self.vehicle = vehicle
            self.is_occupied = True
            vehicle.spot = self
            return True
        return False
    
    def remove(self):
        if self.vehicle:
            self.vehicle.spot = None
            self.vehicle = None
            self.is_occupied = False

class ParkingLevel:
    def __init__(self, level_id: int, num_spots: int):
        self.level_id = level_id
        self.spots: List[ParkingSpot] = []
        self._initialize_spots(num_spots)
    
    def _initialize_spots(self, num_spots: int):
        # 50% motorcycle, 40% car, 10% bus spots
        for i in range(num_spots):
            if i < num_spots * 0.5:
                self.spots.append(ParkingSpot(i, VehicleType.MOTORCYCLE))
            elif i < num_spots * 0.9:
                self.spots.append(ParkingSpot(i, VehicleType.CAR))
            else:
                self.spots.append(ParkingSpot(i, VehicleType.BUS))
    
    def park(self, vehicle: Vehicle) -> bool:
        for spot in self.spots:
            if spot.park(vehicle):
                return True
        return False
    
    def remove(self, spot_id: int):
        for spot in self.spots:
            if spot.spot_id == spot_id:
                spot.remove()
                return True
        return False

class ParkingLot:
    def __init__(self, num_levels: int, spots_per_level: int):
        self.levels: List[ParkingLevel] = []
        for i in range(num_levels):
            self.levels.append(ParkingLevel(i, spots_per_level))
    
    def park(self, vehicle: Vehicle) -> bool:
        for level in self.levels:
            if level.park(vehicle):
                return True
        return False
    
    def remove(self, level_id: int, spot_id: int):
        if level_id < len(self.levels):
            return self.levels[level_id].remove(spot_id)
        return False

---

Question 2: Design LRU Cache

Problem: Design and implement an LRU (Least Recently Used) cache with O(1) operations.

Solution:

class Node:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.head = Node()
        self.tail = Node()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.size = 0
    
    def _add_to_head(self, node: Node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    
    def _remove_node(self, node: Node):
        prev = node.prev
        new = node.next
        prev.next = new
        new.prev = prev
    
    def _move_to_head(self, node: Node):
        self._remove_node(node)
        self._add_to_head(node)
    
    def _pop_tail(self) -> Node:
        res = self.tail.prev
        self._remove_node(res)
        return res
    
    def get(self, key: int) -> int:
        node = self.cache.get(key)
        if not node:
            return -1
        self._move_to_head(node)
        return node.value
    
    def put(self, key: int, value: int):
        node = self.cache.get(key)
        if not node:
            new_node = Node(key, value)
            self.cache[key] = new_node
            self._add_to_head(new_node)
            self.size += 1
            
            if self.size > self.capacity:
                tail = self._pop_tail()
                del self.cache[tail.key]
                self.size -= 1
        else:
            node.value = value
            self._move_to_head(node)

---

Question 3: Rate Limiter Design

Problem: Design a rate limiter that limits API calls to N requests per minute per user.

Solution:

from collections import deque
import time

class RateLimiter:
    def __init__(self, max_requests: int, window_seconds: int):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.user_requests = {}  # user_id -> deque of timestamps
    
    def is_allowed(self, user_id: str) -> bool:
        current_time = time.time()
        
        if user_id not in self.user_requests:
            self.user_requests[user_id] = deque()
        
        requests = self.user_requests[user_id]
        
        # Remove old requests outside the window
        while requests and requests[0] <= current_time - self.window_seconds:
            requests.popleft()
        
        if len(requests) < self.max_requests:
            requests.append(current_time)
            return True
        
        return False

# Sliding window counter approach
class SlidingWindowRateLimiter:
    def __init__(self, max_requests: int, window_minutes: int):
        self.max_requests = max_requests
        self.window_minutes = window_minutes
        self.user_windows = {}  # user_id -> {timestamp: count}
    
    def is_allowed(self, user_id: str) -> bool:
        import time
        current_minute = int(time.time() / 60)
        
        if user_id not in self.user_windows:
            self.user_windows[user_id] = {}
        
        window = self.user_windows[user_id]
        
        # Remove old windows
        for minute in list(window.keys()):
            if minute < current_minute - self.window_minutes:
                del window[minute]
        
        # Count total requests in window
        total = sum(window.values())
        
        if total < self.max_requests:
            window[current_minute] = window.get(current_minute, 0) + 1
            return True
        
        return False

---

Question 4: Design Twitter

Problem: Design a simplified version of Twitter where users can post tweets, follow/unfollow, and see the 10 most recent tweets in their news feed.

Solution:

import heapq
from collections import defaultdict
from datetime import datetime

class Tweet:
    def __init__(self, tweet_id: int, timestamp: datetime):
        self.tweet_id = tweet_id
        self.timestamp = timestamp
    
    def __lt__(self, other):
        # For max heap, we want most recent first
        return self.timestamp > other.timestamp

class Twitter:
    def __init__(self):
        self.timestamp = 0
        self.user_tweets = defaultdict(list)  # user_id -> list of tweets
        self.user_following = defaultdict(set)  # user_id -> set of followees
    
    def postTweet(self, userId: int, tweetId: int):
        self.timestamp += 1
        tweet = Tweet(tweetId, self.timestamp)
        self.user_tweets[userId].append(tweet)
    
    def getNewsFeed(self, userId: int):
        # Get all followees including self
        followees = self.user_following[userId].copy()
        followees.add(userId)
        
        # Max heap for most recent tweets
        heap = []
        
        for followee in followees:
            if followee in self.user_tweets:
                tweets = self.user_tweets[followee]
                if tweets:
                    # Push the most recent tweet from each followee
                    heapq.heappush(heap, tweets[-1])
        
        result = []
        while heap and len(result) < 10:
            tweet = heapq.heappop(heap)
            result.append(tweet.tweet_id)
            
            # Find which user this tweet belongs to
            for followee in followees:
                if followee in self.user_tweets and self.user_tweets[followee]:
                    if self.user_tweets[followee][-1].tweet_id == tweet.tweet_id:
                        # Remove this tweet from user's list
                        self.user_tweets[followee].pop()
                        # Push next most recent if exists
                        if self.user_tweets[followee]:
                            heapq.heappush(heap, self.user_tweets[followee][-1])
                        break
        
        return result
    
    def follow(self, followerId: int, followeeId: int):
        if followerId != followeeId:
            self.user_following[followerId].add(followeeId)
    
    def unfollow(self, followerId: int, followeeId: int):
        if followeeId in self.user_following[followerId]:
            self.user_following[followerId].remove(followeeId)

---

Question 5: Design Tic-Tac-Toe

Problem: Design a Tic-Tac-Toe game that is played between two players on an n x n grid.

Solution:

class TicTacToe:
    def __init__(self, n: int):
        self.n = n
        self.rows = [0] * n
        self.cols = [0] * n
        self.diag = 0
        self.anti_diag = 0
    
    def move(self, row: int, col: int, player: int) -> int:
        # Player 1: +1, Player 2: -1
        value = 1 if player == 1 else -1
        
        self.rows[row] += value
        self.cols[col] += value
        
        if row == col:
            self.diag += value
        
        if row + col == self.n - 1:
            self.anti_diag += value
        
        # Check if player wins
        if (abs(self.rows[row]) == self.n or
            abs(self.cols[col]) == self.n or
            abs(self.diag) == self.n or
            abs(self.anti_diag) == self.n):
            return player
        
        return 0

---

Question 6: Design Snake Game

Problem: Design a Snake game that runs on a device with screen height = height and screen width = width.

Solution:

from collections import deque

class SnakeGame:
    def __init__(self, width: int, height: int, food: List[List[int]]):
        self.width = width
        self.height = height
        self.food = deque(food)
        self.snake = deque([(0, 0)])
        self.snake_set = {(0, 0)}
        self.score = 0
        self.directions = {
            'U': (-1, 0),
            'D': (1, 0),
            'L': (0, -1),
            'R': (0, 1)
        }
    
    def move(self, direction: str) -> int:
        dr, dc = self.directions[direction]
        head_r, head_c = self.snake[0]
        new_head = (head_r + dr, head_c + dc)
        
        # Check boundaries
        if (new_head[0] < 0 or new_head[0] >= self.height or
            new_head[1] < 0 or new_head[1] >= self.width):
            return -1
        
        # Check if food exists at new head
        if self.food and list(new_head) == self.food[0]:
            self.food.popleft()
            self.score += 1
        else:
            # Remove tail if no food eaten
            tail = self.snake.pop()
            self.snake_set.remove(tail)
        
        # Check if snake hits itself
        if new_head in self.snake_set:
            return -1
        
        # Add new head
        self.snake.appendleft(new_head)
        self.snake_set.add(new_head)
        
        return self.score

---

Question 7: Design Search Autocomplete System

Problem: Design a search autocomplete system for a search engine.

Solution:

from collections import defaultdict
import heapq

class TrieNode:
    def __init__(self):
        self.children = {}
        self.sentences = defaultdict(int)

class AutocompleteSystem:
    def __init__(self, sentences: List[str], times: List[int]):
        self.root = TrieNode()
        self.current_input = ""
        
        # Build trie
        for sentence, time in zip(sentences, times):
            self._add_sentence(sentence, time)
    
    def _add_sentence(self, sentence: str, time: int):
        node = self.root
        for char in sentence:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
            node.sentences[sentence] += time
    
    def input(self, c: str) -> List[str]:
        if c == '#':
            self._add_sentence(self.current_input, 1)
            self.current_input = ""
            return []
        
        self.current_input += c
        
        # Search for sentences with current prefix
        node = self.root
        for char in self.current_input:
            if char not in node.children:
                return []
            node = node.children[char]
        
        # Get top 3 sentences
        heap = []
        for sentence, count in node.sentences.items():
            heapq.heappush(heap, (-count, sentence))
        
        result = []
        for _ in range(min(3, len(heap))):
            result.append(heapq.heappop(heap)[1])
        
        return result

---

Question 8: Design File System

Problem: Design a file system that supports creating new paths and getting values at paths.

Solution:

class FileSystem:
    def __init__(self):
        self.root = {}
    
    def createPath(self, path: str, value: int) -> bool:
        if path == "" or path == "/":
            return False
        
        parts = path.strip("/").split("/")
        node = self.root
        
        # Check if parent exists
        for i in range(len(parts) - 1):
            if parts[i] not in node:
                return False
            node = node[parts[i]]
        
        # Check if path already exists
        if parts[-1] in node:
            return False
        
        # Create path
        node[parts[-1]] = {"_value": value}
        return True
    
    def get(self, path: str) -> int:
        parts = path.strip("/").split("/")
        node = self.root
        
        for part in parts:
            if part not in node:
                return -1
            node = node[part]
        
        return node.get("_value", -1)

---

Question 9: Design Browser History

Problem: Design a browser history system that supports visiting URLs, going back, and going forward.

Solution:

class BrowserHistory:
    def __init__(self, homepage: str):
        self.history = [homepage]
        self.current = 0
        self.last = 0
    
    def visit(self, url: str):
        self.current += 1
        if self.current < len(self.history):
            self.history[self.current] = url
        else:
            self.history.append(url)
        self.last = self.current
    
    def back(self, steps: int) -> str:
        self.current = max(0, self.current - steps)
        return self.history[self.current]
    
    def forward(self, steps: int) -> str:
        self.current = min(self.last, self.current + steps)
        return self.history[self.current]

---

Question 10: Design Hit Counter

Problem: Design a hit counter which