My interview journey for the MTS role at Salesforce, with my 3 years of experience from a product-based startup and an ECE background from a Tier-3 college, began with an Online Assessment.

Round 1 – Online Assessment (HackerRank)

Round 2 – DSA Round

Round 3 – Final Technical Round

I was approached by a recruiter for the Lead Software Engineer/LMTS - Backend - Distributed Systems role at Salesforce India, given my ~10.3 years of experience. The entire interview process led to an offer.

Screening Round: Hackerrank

This round consisted of two LeetCode medium-level questions, to be completed in 75 minutes under proctored conditions with my microphone and video on. For the first question, I identified the need for a binary heap (priority queue) and solved it. The second question was trickier, which I tackled using a combination of sorting and math rather than basic DP. I successfully passed all test cases for both problems, and HR contacted me the very next day to advance to the next rounds.

Round 1: DSA

This was a virtual interview conducted via Google Meet. We started with a brief introduction about my work and a discussion on a challenging situation I recently handled, which lasted about 10 minutes. The interviewer then moved to the coding questions.

• First, I was asked to implement a max stack. I took my time to think and explained my approach thoroughly using Excalidraw, which significantly helped in communicating my thought process. Initially, my solution had a higher time complexity, but the interviewer probed me to reduce it to O(1). Once I figured out the optimal O(1) approach, I wrote the full Java implementation, including various test cases.
• With about 15 minutes remaining, the interviewer asked me to implement a frequency stack. Again, I used Excalidraw to explain my approach. Due to time constraints, I couldn't write the code, but I sensed the interviewer was convinced by my explanation.

The interviewer concluded by wishing me luck for the next round.

Round 2: LLD

This was another virtual round via Google Meet. We began with a brief discussion (5-6 minutes) about my work, roles, and responsibilities. Following this, we had a 15-17 minute discussion on various database concepts, including sharding, partitioning, and when to choose each. I explained my reservations about sharding due to its inherent complexities and the need for careful implementation. The interviewer also checked for my practical knowledge regarding scalability. Then came the core LLD question:

"Implement a connection pool."

Initially, my mind went blank, but I quickly regained composure and started clarifying the requirements. The key specifications were:

• A pool of 1000-2000 connections.
• Developers should be able to request a connection.
• Provide a free connection if available.
• Developers can return or close a connection.
• If a connection is closed, a new one should be created to maintain the pool count.
• Connections have three states: FREE, BLOCKED, CLOSED.
• If connections are exhausted, implement a mechanism with a default timeout to reject requests if no connection becomes free within that time.

I implemented this through continuous discussions with the interviewer, thinking out loud, and explaining my thought process before writing any code. The interviewer was particularly interested in how I handled concurrency with limited connections, for which I used a BlockingQueue and ensured methods were synchronous where applicable. For the default timeout, I chose an O(n) approach, mentioning that for larger scales (e.g., 10^6 connections), I would use two different blocking queues for O(1) access, noting it as a TODO. The interviewer appreciated this transparent design choice. I ensured all requirements were met, and we ran out of time. I also used the last 5 minutes to ask my questions.

I received the call for Round 3 two weeks after Round 2.

Round 3: HLD

This was an in-person, whiteboard interview at the office. The interviewer asked me to design a marketing campaign system. As is typical for HLD, I clarified the requirements and started drawing on the whiteboard while explaining my thought process. The interviewer wasn't looking for a complete end-to-end solution but rather deep dives into specific proposals. Every time I drew or proposed something, they would dig deep into the justifications and reasoning. The discussion was very interactive, and the interviewer course-corrected me twice. Most deep dives revolved around distributed transactions, scalability, various distributed architectures, failure handling, self-healing systems, and briefly, the Saga pattern.

Round 4: HM

This was also an in-person, whiteboard interview at the office. The Hiring Manager extensively questioned me about my current project and grilled me on its architecture for about 45 minutes. Following this, we moved to behavioral questions, focusing on my roles, responsibilities, leadership, and mentoring traits. As we walked out, the HM inquired about my notice period. The very next day, HR hinted at positive feedback, and I received the confirmation call the day after.

My interview process for the SMTS position at Salesforce consisted of a few rounds. The initial Online Assessment questions aren't clear in my memory, but they were typical of what one might expect. Round 1 focused on data structures and algorithms, where I was asked to solve the 'Longest Non-Repeating Substring' problem and to implement a 'Min Stack'. Round 2 was a Low-Level Design challenge, requiring me to design an 'Elevator Service' system with advanced features, specifically the option to change the direction of escalators within a building with N floors.

I was approached by a recruiter for the SMTS Backend role at Salesforce, which led to an interview process comprising two main rounds.

Round 1: Platform - HackerRank

This round consisted of two coding questions, to be completed within 75 minutes. The first question was a variant of Remove Duplicates from Unsorted Linked List, requiring me to ensure only a single occurrence of numbers. The second was a variant of Kth Largest Element in an Array. I managed to solve both problems efficiently within 40 minutes.

Round 2: Virtual DSA Coding Round

This round also presented two questions, with a 60-minute time limit. The first question was a variant of Reconstruct Itinerary, simplified by the constraint that the input would not contain any loops or multiple paths. I solved this problem using a hashmap and a set in approximately 30 minutes, and the interviewer seemed satisfied with my approach.

The second question was to design a Queue with an O(1) getMax() operation. I initially considered using a queue combined with a monotonic increasing stack, but while coding, I realized a monotonic deque, similar to the technique used in the Sliding Window Maximum problem, would be a more suitable approach. Unfortunately, I was unable to complete the deque solution within the remaining 30 minutes.

I recently applied for a Staff Member of Technical Staff (SMTS) Backend role at Salesforce through their careers portal. After applying, I was invited to complete an Online Assessment on Hackerrank. The assessment consisted of two coding questions, and I had 75 minutes to complete them.

YOE: 6YOE

Online Assessment: 2 DS Question Solved Both.

Problem Statement 1

A classification system evaluates whether given texts are spam based on a list of spam words.
A text is labeled “spam” if it contains at least two spam words (each occurrence of a spam word in the text counts toward the total).
Spam word matching is case-sensitive.

Example:

texts = {
    "This is a limited offer just for you",
    "Win cash now! Click here to claim your prize",
    "Hello friend, just checking in",
    "Congratulations! You have won a free gift"
};

spamWords = {
    "offer", "cash", "Click", "prize", "Congratulations", "free"
};

Output:
["not_spam", "spam", "not_spam", "spam"]

Function Signature:
vector<string> classifyTexts(vector<string> texts, vector<string> spamWords);

Input:
 texts: a list of strings (the texts to evaluate).
 spamWords: a list of strings (the spam words).

Output:
 A list of strings, each either "spam" or "not_spam" for each text.

Constraints:
1 ≤ n ≤ 10^3 (number of texts)
1 ≤ k ≤ 10^5 (number of spam words)
1 ≤ len(text) ≤ 10^5
1 ≤ len(spamWord) ≤ 10^5
Combined length of all spam words does not exceed 10^7

Solution

  List < String > result = new ArrayList < >();

  // Convert spam words to lowercase for case-insensitive comparison
  Set < String > lowerSpamWords = new HashSet < >();
  for (String word: spamwords) {
    lowerSpamWords.add(word.toLowerCase());
  }

  // Process each text
  for (String text: texts) {
    // Split text into words and convert to lowercase
    String[] words = text.toLowerCase().split("\W+");

    int spamCount = 0;

    // Count spam word occurrences (each occurrence counts)
    for (String word: words) {
      if (!word.isEmpty() && lowerSpamWords.contains(word)) {
        spamCount++;
      }
    }

    // Classify: spam if >= 2 spam words found, otherwise not_spam
    if (spamCount >= 2) {
      result.add("spam");
    } else {
      result.add("not_spam");
    }
  }

  return result;
}

Problem Statement 2 : Longest Subsequence

Determine the maximum length of a subsequence from one string that is also a substring of another string. A subsequence of a string is created by removing zero or more characters from it, while a substring consists of consecutive characters from the string.
Given two strings x and y, determine the length of the longest subsequence of x that is also a substring of y.

Example:
x = "abcd"
y = "bbdc"

The subsequences of "abcd" are: "a", "b", "c", "d", "ab", "ac", "ad", "bc", "bd", "cd", "abc", "abd", "acd", "bcd", and "abcd".
The substrings of "bbdc" are: "b", "b", "d", "c", "bb", "bd", "dc", "bbd", "bdc", and "bbdc".

The longest subsequence of x that is also a substring of y is "bd" with length 3.
Function Description:
Complete the function longestSubsequence in the editor with the following parameter(s):
string x: a string to find the subsequence of
string y: a string to find the substring of
Returns:
int: the length of the longest subsequence of x that is a substring of y
Constraints:
1 ≤ lengths of x and y ≤ 2000
Strings x and y consist of lowercase English letters (ascii[a-z])

Solution

public static int longestSubsequence(String x, String y) {
        int maxLength = 0;
        
        // For each starting position in y (try all possible substrings)
        for (int start = 0; start < y.length(); start++) {
            int xIndex = 0;
            int yIndex = start;
            int currentLength = 0;
            
            // Greedily match consecutive characters from y[start...] 
            // as a subsequence in x
            while (xIndex < x.length() && yIndex < y.length()) {
                if (x.charAt(xIndex) == y.charAt(yIndex)) {
                    currentLength++;
                    yIndex++;
                }
                xIndex++;
            }
            
            maxLength = Math.max(maxLength, currentLength);
        }
        
        return maxLength;
    }

Experince: 7 years
Current: Prduct Based Compnay (36 + 5.5 + 4.5 (LTI)) - ~46 LPA
Offer in Hand: Walmart: 45 + 8.7 + 3.5(stocks) = ~57 LPA
Kotak Mahindra: 49 + 7.5 + 4.5(LTI) = ~ 60 LPA

I was part of salesforce hiring drive today i.e. 1st November 2025
Round -1 DSA:
find the maximum subarray sum of array1 after applying m operations from arr2: condition for operation:
1. you can choose one element from arr2 either from front or either from back and put it in array 1 either at back or front.
2. you have to delete element that you pick from array 2.
3. after adding element to array1, now you need to find the maximum subarray sum of array 1.

you can perform above opertions m times where m is the size of array 2
e.g. array1 ={1,3,-5,2,2} array2 = {2,3}
o/p = 2,2,2,3 = 9 when you put but the elements of array 2 at the end of array 1.

Not able to solve it.
Solution is highly appreciated but not the chatGpt/Claude/deepseek
Result: Rejected

Anyone have idea what's the difficulty : medium or hard.

Interview(75 min)

Easy problem related to Set

Easy medium problem similiar to 0-1 Knapsack

I was able to solve both within 30 minutes, but I haven’t heard back for over a week. Has anyone else experienced something similar?

I had my first round interview at Salesforce for the SMTS position. After a brief one-minute introduction, the interviewer immediately presented me with two coding questions via a Hackerrank link. The first question was identical to Remove All Adjacent Duplicates in String II. I initially brainstormed a brute-force approach but, after about 10-15 minutes, I pivoted to a more efficient stack-based solution. However, since nearly 30 minutes had passed, the interviewer decided to move on. The second question was conceptually the same as Binary Tree Maximum Path Sum, but it came with a significant twist: the input was provided as List<Integer> parent and List<Integer> values. This meant I had to either construct the entire tree from these lists myself or develop an approach that could work directly with this input format. I managed to devise the core approach for the problem but found the task of building the tree from scratch within the tight time constraints to be quite challenging. In the end, I wasn't able to fully solve either problem, though I was able to articulate my thought processes and proposed solutions for both.

The recruitment process started after a recruiter reached out to me on LinkedIn for a different position, but after sending my resume, I was offered an online assessment for this MTS role. My journey began with Round 1, an OA consisting of 3-4 LeetCode medium-hard questions, though I don't recall the exact problems. Following the OA, I had Rounds 2 & 3 on the same day in late September.

Round 2 started with a straightforward string question. After solving and testing it, the interviewer, seeing we had time, moved on to a more challenging dynamic programming problem. I managed to solve both questions, albeit with a little extra time needed.

Round 3 was a combination of Data Structures & Algorithms and Low-Level Design. The interviewer initially posed a simple array question, keen to see how I'd approach edge cases and scalability for increased input limits. We then transitioned into designing a Meeting Scheduler, where I discussed the core objects, classes, design patterns, and strategies for handling conflicting meetings. My design approach seemed to satisfy the interviewer.

After clearing these virtual rounds, the recruiter scheduled my onsite interview in Hyderabad.

Round 4 involved two interviewers, an SMTS and a Director. They were incredibly accommodating, allowing me time to settle in before starting. We began by discussing my previous projects. Given my background in search algorithms, they then asked me about high-level requirements for a Facebook search-type application. Following this, I was asked to design a parking lot on a whiteboard and write valid code for it. The interview concluded with me asking a few questions.

Currently, I'm in the waiting phase. The recruiter reached out the following week for offer negotiations and has been assuring me consistently that an offer is in process, though it has been ongoing for 20 days already. I'm hopeful to receive it soon and that my experience proves helpful to others.

My interview for the MTS role at Salesforce began with a standard introduction where I discussed my background and the projects I've worked on. Following that, I was presented with a DSA question. The problem was 'Word Break', and although I could come up with a recursive solution, it did require some hints from the interviewer to get there.

The recruiter reached out to me for a MTS position at Salesforce in Bengaluru. I first completed an Online Assessment. A couple of weeks later, I received an invite for the interview round.

My first and only round consisted of two coding questions that needed to be solved within an hour. I unfortunately ran out of time and was unable to complete both, leading to a rejection.

I took the Salesforce Online Assessment on HackerRank, which presented two coding challenges. I had 75 minutes to complete both problems. After submitting my solutions, I later received a rejection.

I just completed the SalesForce Online Assessment. It was hosted on HackerRank and presented two distinct coding problems. The first problem involved designing a text classification system to identify spam based on a given list of spam words and a specific count threshold, requiring careful consideration of case-sensitivity and word counting. The second challenge was a direct LeetCode problem, 'Delete and Earn'. I'm currently awaiting results for this round and will share updates on subsequent stages.