Salesforce Interviews

Older 2 IIT's(CSE) Total Exp: 8+ Years (Mostly startups). Was part of November hiring drive

Round 1 - Algo DS Graph medium question. Did it in given time and ran all test cases. Interviewer had difficulty understanding c++ but was accomodating.

Round 2 - Algo DS + LLD Leetcode medium quesiton on Dp. Then few LLD design questions

Round 3 - Design Round with LMTS Got a really bad interviewer. The task was to design Google like news feed. I think I did pretty good on covering most of the basic things and went into deep dive on few things. Since we crossed the interview time, I cut her off and ended the interview.

Hiring Manager - Onsite with Director at Salesforce This interview was unconventional. At one point we were dicussing physics principles and aruging about fundamentals. The best round I had in salesforce interviews. Post our discussions, I really hoped that I can work under the director.

The whole interviews were finished in two weeks. Recruiter called me and informed me that I got selected for LMTS. But upon hearing that I'm waiting for google reponse, gave me a deadline of week to decide if I want to go with Salesforce or not, I said no.

The ballpark TC that recruiter said was 95+ lpa for this role

I applied for the SMTS role directly on LinkedIn, bringing 5 years of experience. My interview process started with an OA round which had two LeetCode medium questions, though I don't recall the specifics.

I then had Technical Round 1, a virtual DSA round, where I was given problems similar to Pairs of Songs With Total Durations Divisible by 60 and Asteroid Collision. I received positive feedback for this round.

Next was Technical Round 2, another virtual round covering DSA and Low-Level Design. The DSA question was Longest Substring Without Repeating Characters, and for LLD, I had to design an elevator system. This round also resulted in positive feedback.

At this point, the recruiter called, confirming my positive feedback from both technical rounds and scheduled an onsite Hiring Manager round, which I was told would be the last. However, while I was already on my way, the recruiter called again to inform me that I would now have two additional onsite rounds: one for HLD and another DSA round. Being halfway there, I felt I had no choice but to accept this change.

Technical Round 3 was an onsite HLD round, where I was asked to design an API Rate Limiter. Unfortunately, the interviewer seemed disengaged and spoke very softly, making the experience less than ideal. I received negative feedback for this round.

Technical Round 4, another onsite DSA round, followed. The problem was a variation of Longest Substring of All Vowels in Order, but it asked for a subsequence instead of a substring. I hadn't encountered this pattern before and couldn't solve it, leading to negative feedback.

Finally, I had the HM Round onsite, which lasted only 10-15 minutes. I was asked basic behavioral questions about handling conflicts with team members and discussing my impact on past projects. Ultimately, I was rejected.

Technical Round 1 (60 mins):
- Problem 1: Given a string and a number of rows, print the string in zigzag traversal. I provided the most optimized solution and executed it successfully.
- Problem 2: Given digits, print all possible strings like a phone keypad. Again, I delivered the optimal solution within the time limit. Both problems were solved in about 50 minutes.

Technical Round 2 (LLD) 6,0 mins:
- Problem: Implement an LFU (Least Frequently Used) cache. I explained the optimal approach, though the interviewer initially had difficulty following my reasoning. I implemented the entire solution (~100 lines of code). A minor syntax error prevented execution, but the interviewer seemed satisfied with the approach and completeness of the solution.

Hiring Manager Round (On-site):
- The first 15 minutes were a casual discussion where I felt a strong rapport with the hiring manager.
- We discussed my past projects, and I was able to highlight my contributions and technical depth.
- Problem: Adding polynomials. The manager only described the problem verbally without examples.
- Initially, I proposed a different solution.
- After clarifying requirements through discussion, I refined my approach and arrived at the correct solution.
- System Design: Asked to design a login page.
- I focused on gathering requirements, security considerations, and protection mechanisms.
- We discussed these aspects in detail.
- Behavioral Questions: The manager asked a few, and my responses seemed to leave a positive impression.

Outcome:
- After the interviews, I followed up with the recruiter.
- Initially, I was told the hiring manager had given kind a positive signal.
- However, after about 1.5 weeks, I received a rejection email stating that the feedback was not positive and they would not be proceeding further. The feedback mentioned that the candidate did not sufficiently demonstrate the level of design thinking expected for an SMTS role. The candidate is very good in coding and implementation, thought through the solution and implemented it in a highly optimized approach. However, the candidate lacked in discussing assumptions and made some logical mistakes in the implementation.

After clearing the HackerRank round, I received a call from the recruiter for further rounds. Initially, I was told there would be three rounds: DSA, System Design (LLD), and Hiring Manager. However, the plan was adjusted to two DSA rounds and one Hiring Manager round.

DSA Round 1:
1. Rotting Oranges - A simple BFS question that I solved easily.
2. Binary Search in Rotated Array - Another straightforward question that I managed to solve.

DSA Round 2:
1. Maximum Gold in Grid - A DFS/BFS problem that I solved but had some difficulty with time and space complexity.
2. Transform String - A challenging question not on LeetCode. I came up with a solution but failed to handle edge cases and couldn't solve it in time.

Hiring Manager Round:
The round was relatively simple, focusing on discussing my career switch and shared interests in contact centers, as both the manager and I had prior experience in this domain.

During my LLD round at Salesforce, I encountered a fascinating problem: designing a cab booking service akin to Uber. The interviewer presented me with several key requirements that my design needed to incorporate. These included the fundamental ability for passengers to request rides and for available drivers to accept and fulfill those requests. It was also critical for the system to support passenger-initiated cancellations seamlessly. Users needed to specify both their pickup locations and desired destinations. A crucial component of the design was the fare calculation mechanism, which had to intelligently factor in variables like the distance traveled, the specific type of ride chosen, and the duration of the journey. I approached this by outlining the key architectural components, data models, and API endpoints necessary to support these functionalities, considering scalability and real-time updates.

During my interview, I was given a comprehensive system design problem: to architect a Meeting Room Reservation Platform. The goal was to enable employees to efficiently book meeting rooms, check their availability, and manage existing reservations within an organization. I had to consider core functionalities, various entities involved, and crucial operational aspects.

The discussion covered several key functional requirements, such as viewing available rooms, booking, cancellation, gracefully handling overlapping requests, and listing bookings for specific rooms or employees. We also touched upon the optional enhancement of supporting recurring meetings.

I then moved on to identifying the main entities: Employee, MeetingRoom, Booking, and TimeSlot, and defined the essential operations for the system. Important constraints like preventing double-booking, ensuring extensibility, and tackling concurrency issues (e.g., race conditions during simultaneous bookings) were also part of the design considerations. The interviewer expected me to define classes with proper responsibilities and address potential edge cases like invalid time ranges or unavailability of rooms.

I recently interviewed online with Salesforce for an LMTS position. The round consisted of two coding questions, to be completed within an hour. I successfully solved the first problem, "Number of Islands." For the second problem, "House Robber II," I managed to come up with a partial dynamic programming solution, but I ran out of time before completing it. Ultimately, I received a rejection as the team expected a fully working solution for both problems.

I applied for the Senior Member of Technical Staff (Frontend) role through the Salesforce career site. My application was acknowledged, and I received a recruiter call after about 3-4 days.

Round 1: Online HackerRank Assessment (60 minutes)

This round required me to solve two coding questions to proceed. I encountered a graph-based problem and a dynamic programming problem focused on strings, which I completed.

Round 2: Hiring Manager Round (45 minutes)

This round covered a mix of topics. We discussed my current work experience, including my tech stack and cultural fit. We also delved into frontend performance, specifically: what FPS is, why it's important, and which CSS properties to avoid animating, favoring transform and opacity for better performance. A system design problem was presented: to design the "Send message" functionality on Slack, including user tagging, UI component design, and communication protocols. Finally, we discussed Canvas and its performance benefits.

Round 3: JS, HTML, CSS and React Fundamentals (60 minutes)

This was a comprehensive frontend fundamentals round. I was asked about semantic HTML and its benefits, the differences between Flexbox and Grid, and how to implement responsive layouts using media queries and relative sizes. In JavaScript, I explained call, apply, and bind, and was asked to write a polyfill for bind. Other JS topics included the Critical Rendering Path, CSSOM, and the Event Loop. For React, the questions covered forwardRef and useImperativeHandle, designing a data model for a chat application, understanding and fixing props drilling, and the benefits of Client Side Rendering. The round concluded with questions on web performance, such as different resource hinting techniques and how to improve INP.

Round 4: System Design - Google Maps (60 minutes)

The challenge was to design maps.google.com. This was a highly interactive discussion, not about finding a single right answer. We explored various aspects like Canvas vs. DOM rendering, tile-based rendering, Level of Detail (LOD) based on zoom, and techniques like debouncing/throttling for gestures. We also touched upon state management, caching strategies, and the design of various APIs such as Tile, Geocoding, Directions, Places, and real-time data APIs. User interactions, web workers for heavy computations, responsive design, keyboard navigation, screen reader support, and error tracking were also part of the discussion. The interviewer was very helpful and guided me when I got stuck.

Round 5: System Design - WhatsApp Web (60 minutes)

I was asked to design web.whatsapp.com. Having studied this problem before, I felt confident and the discussion flowed well with the lead engineer. We explored some new scenarios presented by the interviewer, and I was able to propose viable approaches.

Round 6: Culture Fit and Collaboration (60 minutes)

This final round focused on behavioral aspects. I discussed how I handle conflicts, specifically conflicts with a QA team. I also shared an experience where I pushed a bug to production, detailing the RCA process, adding E2E tests, and other mitigation steps taken. Another question involved a scenario where I had to work with a difficult colleague and how I managed the situation. There were a few more general cultural questions as well.

I am delighted to share that I received an offer for the Senior Member of Technical Staff (Frontend) role!

My Salesforce USA SMTS Interview Experience

I recently interviewed for a Senior MTS role at Salesforce USA, and I'm thrilled to share that I received an offer. The interview process was quite extensive, covering multiple rounds with varied experiences. Here's a breakdown of how it went:

Hiring Manager Screen (45 mins)

This round primarily focused on my work experience, my role, and the impact I had in previous positions. It was almost entirely dedicated to behavioral questions, and we actually ran over the scheduled 45 minutes, extending to over an hour.

Online Assessment (60 mins)

The online assessment consisted of four standard LeetCode problems. The final problem boiled down to finding the longest increasing subsequence. Unfortunately, I couldn't code the optimal O(n log n) solution within the time limit, which resulted in 7-8 test cases failing.

Onsite Interviews

Coding (60 mins)

This round started with 1-2 behavioral questions. The main coding challenge was a standard linked list problem: reversing a sublist from a given 'fromIndex' to 'toIndex'. I discussed some simple follow-ups and optimization strategies. Towards the end, we also delved into system design aspects, specifically around the cloud service providers I've worked with, predominantly AWS. Discussions included DynamoDB, Lambda, and SQS.

System Design (60 mins)

Similar to the previous round, this also began with 1-2 behavioral questions. The initial part of the session was a rapid-fire Q&A, covering fundamental concepts like 'What is a REST API?', 'What is HTTPS?', and 'What is JWT?'. The interviewer aimed to test the depth of my foundational knowledge. With only 20 minutes left, we finally moved to the core system design question: designing a service similar to TicketMaster. This was an intense discussion where the interviewer meticulously grilled me on every statement. We had very in-depth conversations, touching upon ensuring atomicity in ACID-compliant databases (literally down to the thread level), why Elastic Search speeds up search queries, what an inverted index is, and potential problems with Elastic Search. This round also went significantly overtime, by about 25 minutes, which felt unprofessional and contributed to a rather poor candidate experience.

Coding / Design (60 mins)

This round also included 2 behavioral questions. It felt more like a knowledge-testing session rather than a typical coding or design round. We started with basic questions like 'What is the difference between Arrays and Lists?', 'What is caching?', and 'How to implement a hashmap?'. We also discussed cache eviction strategies when memory is full, and the implementation details of LRU and LFU caches. Following this, we moved to design discussions related to a Stock Broker app. The core problem was 'What is the best way to show historical prices of a stock to the client?', to which I suggested using a time-series database. We then discussed its pros/cons and why it speeds up time-related queries. We also covered 'How to handle stock ticker changes on the app?', where I proposed a pub/sub model instead of regular polling, leading to questions about 'What is a Pub/Sub?' and 'How does Redis pub/sub work?'. The conversation continued with discussions on Kafka, its internals, and message brokers in general. It was quite peculiar that I didn't write a single line of code in this round. For a senior/staff candidate, some of these foundational questions felt borderline insulting, suggesting a lack of a clear script for the interview.

Behavioral (45 mins)

This round was entirely behavioral. I was asked to pick a project of my choice, explain its design choices, detail my role's impact, and discuss challenges I faced. Standard behavioral questions included scenarios like taking calculated risks, experiences with project failures, examples of organization-wide or team-wide impact, and any processes I changed within my team.

Coding (60 mins)

The final round again started with 1-2 behavioral questions. The coding challenge was a problem from HackerRank. The prompt was quite lengthy, but the problem itself wasn't overly difficult. It took me some time to fully understand the problem statement, sample inputs, and expected outputs. Once coded, it passed all the provided test cases.

Overall, I found some of the interview rounds to be quite unstructured, with some questions feeling inappropriate for a senior/staff level candidate. Despite these observations, the recruiter reached out the very next day to extend an offer.

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.

I recently completed the interview process for a MTS role at Salesforce. The initial stage was an Online Assessment which included two coding questions: one was a map-based problem with simple logic, and the other involved a straightforward sliding window approach. I successfully solved both problems, which qualified me for the next round.

The subsequent stage was Round 1, primarily focused on Data Structures and Algorithms. The specific question I was given was titled "Maximum Knowledge After Attending K Conferences". Regrettably, I was unable to develop an optimal solution and solve the problem completely within the allocated time during the interview, which ultimately led to my rejection after this round.

Total Rounds : 4

Round 1(Hiring Manager) :

1. Discussion around prior experience and past projects. 
2. Was asked to walkthrough the architecture of one of the complex projects worked so far. Questions around the design decisions made, cost consideration etc.
3. Questions around the execution strategy of a project that requires collaboration. Strategy to get things prioritized with stakeholders etc.

Round 2 (1 hour, System Design) :

1. Design a system that delivers the campaign emails. There could be upto 100K emails to be sent per campaign. There could be millions of campaigns in total.

Round 3 (1 hour, System Design) :

1. Design a system like APNS/FCM that could deliver billions of push notifications. Handle the priority notifications like transactional notifications vs marketing notifications.
2. Focus was on push vs pull model for notification delivery, DB choices and how the system will scale to deliver billions of notifications.

Round 4 (1 hour, Coding) :

1. Design a LFU Cache. Expectation was to write the working code and run it.

Salesforce SMTS Interview loop (Aug 2025)

YOE: 6 Yrs Current Company: Reputable Tech Company Location: Bangalore

Round 0 (July last week):

Online Assessment: Solved both the problems successfully. And got a call from recruiter that I have cleared this round and he will contact me for the next rounds

Question 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

Question 2:
A popular social media platform provides a feature to connect people online. Connections between users are represented as an undirected graph, where each node represents a user, and edges represent connections between users. If a user is directly or indirectly connected to another user, they can view their profile.
The network consists of nodes:
- Each pair of connections is represented from 1 to nodes.
- Each pair of connections is given by two arrays u and v, where u[i] is connected to v[i].
- The queries array contains a list of user IDs. For each user ID in the queries array, return the number of profiles that user can view.

A user can view their own profile.
The result should be an array of integers where the i-th value corresponds to the result for the i-th query.

Example
Input:
edges:
  u = [2, 1, 4, 5]
  v = [1, 3, 5, 6]
queries = [1, 5, 7]

Output:
[3, 3, 1]

Round 1 (Data Structure and Algorithms):

The interviewer was a new joinee in the Salesforce and she came with a plan to ask 2 questions and pass only when both the answers will be running for all her test cases. There was a shadow with her, who was a senior and asked a few important questions at the end.

Question 1:
Longest Substring Without Repeting Characters

leetcode: https://leetcode.com/problems/longest-substring-without-repeating-characters/description/

Note: I initially said the space complexity would be O(N) in the worst case. The shadow interviewer nudged me on this and I corrected myself as it can go at max of number of ASCII characters so O(1).

Question 2:
Vertical order traversal of a binary tree

Leetcode https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/description/

Note: I used a map initially to store elements of each level in sorted order, which added O(log N) overhead. They pointed this out after all the test cases passed. I acknowledged and mentioned that using an unordered_map could eliminate the extra time complexity.

Feedback: They didn’t give a strong hire. The feedback was that I’m good and could be hired if I perform well in the next interviews. The overall impression was that they prefer candidates who don’t leave room for nitpicking. 😕

Round 2 (High Level Design):

Although the recruiter mentioned this would be a low-level design round, the interviewer went ahead with a high-level design question instead. After some clarification, we aligned and proceeded.

Question:
A property dealer currently owns a website that puts out the details of the properties listed by the brokers and merchants. 
The property details are added with photos, location, and basic details. As they do not wish to maintain the current system, 
They want to move it to a more scalable, faster, and secure system. 
Data consistency and performance is a major concern. They want to move from a traditional system to a cloud-based system architecture.

Ask questions, assess the architecture, review the additional requirements given below and design the whole system.

The system should be able to support all the necessary services and modules to allow users to do the following:

- Browse property listings
- Search for a property
- Perform actions like login, register, and logout
- The property in the listing page should be segregated with the merchant name

I covered:

• Functional and non-functional requirements
• Core entities
• Database schema
• API design covering all functionalities
• High-level system design

The main focus was on deep dives

• How do we make sure there won't be double booking (contention management) I proposed splitting the payment flow into two APIs:

POST /reserve (hold for 5 mins)  
POST /confirm (after successful payment)

And used a distributed lock (Redis) to manage contention.

• Merchant photo uploads and global availability
• Service segregation and individual scalability
• Search performance <500ms (ElasticSearch + caching layer)

Follow up:

• What if merchant has to do a bulk update for a category of property.
• This update will involve at least 1000s of property at one time, how can we handle this roubustly.
• Is it a good idea to keep the payment service segregated from other services? (Yes because it has to talk to 3rd party vendor and will have more strict and secure protocol to talk to them also it will have some complex reconsiliation logic which is better off segregated)
• How CDC actually works (I used CDC to hydrate the Elastic Search)

Feedback: Got a strong hire from this round and got a go ahead for the HM round. 😁

Round 3 (HM Round):

This was an in office face to face round with Hiring Manager. The HM was a delight to talk to and made me very confirtable with him, he was very polite and a good listener.

• Deep dive on a project you have worked on, what component you own and how did you implement that.
• How do you get your Design doc approved
• What are the tools, language and infra you used for the project.
• What were the most challenging part of your project
• If you have to do it all over again how you do your project, of you don't have any restriction of using Azure cloud and free to use open source.
• Talked about testing strategies and migration strategies of the feature making sure the existing feature would not break
• Rollback strategies and Monitoring dashboards and alerts.

Some standard behavioural questions:

• How did you resolve confict in your workplace?
• How do you handle on-call issues with example
• How do you convince your seniors and managers for a work related confict.

This round went well in my opinion. 🤞🏼 Waiting for the final verdict. Will update the post once I hear from the recruiters.

Hi All,

YOE : 3 Years

I recently had a chance to interview with salesforce for MTS position. Had 3 rounds of interviews,

Round 1 : DSA/Problem solving round

• First question was related to family tree heiriarchy, find out the siblings.- Solved fully follow up : find first second and second cousin.
• Second question was to find a element in rowwise and column wise sorted matrix. - Solved fully

Round 2 : DSA + LLD

• i was asked 3 DSA questions
• Sliding window - Solved fully
• Binary search - Solved fully
• 1 question of finding the reverse of a integer, the catch was i had to handle integer overflow, i strugguled in this, interviewer gave a hint, then was able to catch up on it. (Overall Mixed).

Round 3: HM

• HM asked quuestions around why do you want to change, some cross questioning and rapid fires, i got cought-up in between by contradicting my own words, had a intense HM round, Post that he asked about my curent projects and workflow of them .

Overall very formal discussion, Interviewer was expressionless and very uninterested in talking anything, related to company or anything else, a bit of rude as well. i guess, he was in the mood to reject.

No sure i will make it or not.

Does Anyone had a similar expirences with salesforce, What are the chances.

Was asked an easy question (just get max process runtime).

Along with this medium question: https://leetcode.com/problems/minimum-operations-to-reduce-an-integer-to-0/

Hiring drive interview - 26th July 2025

Yoe - 6

Past experience: PBC

Round1:

Asked about the project details. 1 API Schema

Then 3 DSA Questions:

1. Find max Subtree sum in a binary tree.

2. Find Max Square size in Binary matrix

3. Find Max rectangle size in binary matrix.

Questions has to be solved on whiteboard.

I was to solve 1st question completely. Struggled a bit on Time and Space complexity.

For 2nd Question, I was able to provide the intuition and the approach to solve the problem. Interviewer seems satistisfied with the appraoch. So they moved to 3rd Question.

For 3rd Question, I was able to somehow come up with the approach. And explained the same, the intuition and thought process behind it. But the time was over so could write the code for it.

Verdict: Rejected

Self Analysis: I think they were expecting me to write the code for the 3rd problem as well within in the given time. Overall it was a good experience. And i think expectations are lot now a days. 1 Medium + 2 Hard Questions + Project discussion in 1 hour is a lot.

Hacker Rank test

https://leetcode.com/problems/string-compression/description/

Modified version of https://leetcode.com/problems/delete-and-earn/description/

Hi Folks,

YOE: 6 Currently SSE @ Walmart

Recently gave OA for SMTS position at Salesforce India. Got the OA link after cold emailing a bunch of salesforce recruiters.

#1: Minimum Operations to Zero (Same as LeetCode problem #2571.) You are given an integer n. In one operation, you can either add or subtract any power of 2 (i.e., ±2⁰, ±2¹, ±2², ..., ±2ᵏ) to/from n.

Write a function that returns the minimum number of such operations required to reduce n to 0. public static int getMinOperations(int n)

Input: A single integer n (1 ≤ n ≤ 10⁹) Output: An integer representing the minimum number of operations to reduce n to 0.

Example: Input: 21 Output: 3

Explanation: 21 → 20 (subtract 1 = 2⁰)
20 → 16 (subtract 4 = 2²)
16 → 0 (subtract 16 = 2⁴)

#2: Integrity Score A data packet is represented as a string of lowercase English letters. The integrity score of the packet is defined as the number of substrings whose character values sum to a number divisible by the length of the substring.

Each character is assigned a value as follows: a,b -> 1 c,d,e -> 2 f,g,h -> 3 i,j,k -> 4 l,m,n -> 5 o,p,q -> 6 r,s,t -> 7 u,v,w -> 8 x,y,z -> 9

Write a function that returns the integrity score of the packet. public static int integrityScore(String dataPacket)

Input: A string dataPacket consisting of lowercase English letters (1 ≤ length ≤ 10⁵) Output: An integer representing the integrity score.

Example: Input: "cat" Output: 4

Solution:

public static int integrityScore(String dataPacket) {
    int n = dataPacket.length();
    int[] prefixSum = new int[n + 1];
    int count = 0;

    // Build prefix sum using custom mapping: 'a' = 1 etc
    for (int i = 0; i < n; i++) {
        char ch = dataPacket.charAt(i);
        prefixSum[i + 1] = prefixSum[i] + getValue(ch);
    }

    // Check all substrings
    for (int start = 0; start < n; start++) {
        for (int end = start + 1; end <= n; end++) {
            int length = end - start;
            int sum = prefixSum[end] - prefixSum[start];
            if (sum % length == 0) {
                count++;
            }
        }
    }

    return count;
}
  private static int getValue(char ch) {
    return switch (ch) {
      case 'a','b' -> 1;
      case 'c','d','e' -> 2;
      case 'f','g','h' -> 3;
      case 'i','j','k' -> 4;
      case 'l','m','n' -> 5;
      case 'o','p','q' -> 6;
      case 'r','s','t' -> 7;
      case 'u','v','w' -> 8;
      case 'x','y','z' -> 9;
      default -> 0;
    };
  }

Cleared and asked to appear for F2F rounds.

Salesforce MTS Interview loop (Mar, 2025)

YOE: 3.3 Yrs Current Company: Reputbable Fintech Location: Bangalore

Round 0:

Hacker Rank (OA) Haven't remembered questions.
But the questions were pretty diffuclt and need 80% cut-off.

Got call from HR after a week, for further rounds.

Round 1: (DSA)

Can't able to recal, the exact questions asked. But one was based on Priority Queue (LC Easy - Med) and another was graph (LC Med).

Solved it with O(n) space & runtime complexity. Missed an edge case alone, but due to time constrainst, the interviewer said, he is okay with above solution.

Round 2: (Design)

Started with asking to design HLD for sign up and log in page, for billion users and everyone will have unqiue username, started with multiple approach and then finally setlled with bloom filter and discussed more on that.

Then for follo up he asked to do LLD for the above and yeah did that also.

The round went very well, and missed few points in LLD. Self Rating: (4/5)

Round 3: (Manager Round) (IN-PERSON)

Got a Call from HR, and told to come to either Banglore/Hyderabad office for final round.

Director started by asking me to draw some system design for the given requirements, not completly but crisp.

And then asked a lot of Behavioral and culture fit questions. Some examples:

• How will u approach the work
• How will u react to PR comments
• How will handle critisim from seniors
• How will u react to design changes.

After 5 days I got a call from HR and told I've made it.

Get min. elements to be deleted to make array almost sorted. Almost sorted means- we can delete atmost 1 element to make it perfectly sorted.

Was only able to pass 5 of 13 tests :(

P.S : not solvable by chatGpt/Gemini.

#Salesforce #OA

Company: Salesforce Role: Software Developer - Fullstack Location: San Francisco, CA Interview Dates: 30th & 31st January 2025

Interview Process (4 Rounds — 45 mins each, included behavioral questions):

Round 1 — HackerRank Walkthrough: Walked through my solutions from the initial online HackerRank test. The interviewer asked me to explain my approach, discuss edge cases, and suggest possible optimizations.

Round 2 — Coding: Given two dates as input, implement a function to calculate the difference between them in days.

Round 3 — Coding: Classic problem: Check if two given strings are anagrams.

Round 4 — Low-Level Design & Whiteboard Coding: Discussed how to structure cron-like functions to run scheduled jobs.

Decision: Rejected

Posting my full interview loop for Salesforce. This one had a good mix of coding, design, and behavioral rounds. Hope this helps anyone preparing!

Online Assessment (75 mins - Hackerrank)

Problem 1:
Given an array of integers, for each index, return two strings indicating:

• If the current number has appeared before (in lower indices)
• If it appears after (in higher indices)

Problem 2:
After every update (turning a 0 to 1 in a binary array, input array for indicating which indexes to convert will be given), return the number of sweeps needed to sort the array into non-decreasing order.

DSA / Coding Round

• Problem 1: Find the K-th greatest element for every subarray ranging from size K to N.
• Problem 2: Reorder an array with both negative and positive numbers to place all negatives first, followed by positives — in-place.
  This involved several dry runs and careful edge-case handling.

Low-Level Design (LLD) Round

Topic: Job Scheduler System
Covered both LLD + HLD aspects.
Focus was on write LLD code for job creation, persistence, dispatching, and execution flow.

System Design (HLD) Round

Topic: Migration strategy from Memcached to Redis
Key discussion points:

• Zero-downtime migration
• Cache consistency during switchover
• Fallback mechanisms and rollout strategies
• Discussion on managing the whole process and ownership

Hiring Manager Round (80 mins, in-house)

Coding:
Check if a string is a k-tolerant palindrome (can delete at most k characters to make it a palindrome).

HLD:
Design a Distributed Priority Queue for job processing with multiple consumers.

Behavioral:
Project deep dives and leadership principle-style questions focused on ownership, technical decision-making, and collaboration.

Final Thoughts

Salesforce interviews emphasize:

• Strong dry-run habits in coding rounds
• Production-grade thinking in design rounds
• Final rounds are now in-house.

Let me know if anyone wants prep suggestions. Good luck to everyone applying!

Compensation Details

Verdict: Offer Rejected

Salesforce MTS Interview loop (Mar, 2025)

YOE: 3.1 Yrs
Current Company: Reputbable Fintech
Location: Bangalore

Round 0 (March last week):
Hacker Rank (OA) Haven't remembered questions.
But the questions were pretty diffuclt and need 80% cut-off.
Got call from HR after a week, for further rounds.

Round 1: (DSA) (1st week of April)

DSA: Product of Array except (LC Medium)
Solved it with O(n) space & runtime complexity.

DSA: Minimum Window Substring (LC Hard)
Solved it with O(n) space & runtime complexity.
Missed an edge case alone, but due to time constrainst, the interviewer said, he is okay with above solution.

--

Round 2: (DSA) (1st week of April, Same day as Round 2)

DSA: A problem given with stream of event objects and print it in the order of end time. Solved using two hashmaps. Tricky question but i would say it is LC Easy.
Solved it in O(n) & O(n) space & time complexity.

DSA: Variation of Daily Temperature LC Medium.
Solved it in O(n) & O(n) space & time complexity.

The round went very well, and answered all the problems with edge cases.
Self Rating: (5/5)

--
Round 3: (Tech + Manager Round) (1.5hr) (IN-PERSON) (2nd week of April)

Got a Call from HR, and told to come to either Banglore/Hyderabad office for final round.

Two people (SMTS & Director) were sitting in a conference room.

SMTS (DSA Round)
A Tree problem, where convert the given sorted list to balanced binary tree. Variation of List to Tree LC Medium. Need to write the code/algorithm in the white board.

Solved it in O(n) & O(n) space & time complexity.

Director (Behavioral Round)
He asked lot of Behavioral and culture fit questions. Some examples:

• How will u approach the work
• How will u react to PR comments
• How will handle critisim from seniors
• How will u react to design changes.

I have been moved to Team Matching Round. If someone can explain - what are the next steps and what to expect in there? Recruiter has just told me that if Team liked your resume, official offer letter would be the next step.

Here’s a quick summary of my interview journey so far:

Position: Full Stack Software Engineer

Interview Experience So Far:

Hiring Manager Call (45 mins)

Covered my resume in detail and included a few behavioral questions (around 3, with follow-ups).

I followed the STAR format for my answers and had 4–5 situations prepared. That really helped, and I cleared this round smoothly.

Got confirmation within 2 days to move forward.

Online Assessment

Consisted of 2 LeetCode-style questions:

• Almost Sorted Array
• Minimum Substitutions to Ensure No Two Adjacent Characters Are the Same

Both were on the easier side. I solved them successfully and moved to the next phase.

Super Day – Virtual Rounds

Round 1: System Design

• Design a 911 Call Handling System.

Round 2: Full Stack/Craft Round

While the role is backend-focused, the team also uses React extensively, so they tested some frontend knowledge.

• Discussed API design best practices, with follow-ups based on my answers.
• Coding Task: Implement a Traffic Light System in an infinite loop.

Initially gave a recursive JS solution, and later refined it to use Promises with Async/Await after a discussion with the interviewer.

Super Day 2 – Onsite Rounds

Round 1: System Design

• Design Real time Bidding System (Auction System)

Round 2: LLD + Leetcode

• Leetcode was easy question - on the lines of Anagram however character involved was everything a user can type from keyboard with single stroke
• LLD : Cron Job Parser So Given a string which suggest when cron job would run "0/5 8,12 1 * 1-5" {"Minute", "Hour", "Day", "Month", "DayOfWeek"} Expand this expression to be CRON Job parser

There were two problems to be solved within 45 mins irrespective of you solving the first one or not

Initially we wasted 15 mins talking about my projects and all I dont know why that was needed.

Q1 : https://leetcode.com/problems/fruit-into-baskets/description/ Q2: https://leetcode.com/problems/zigzag-conversion/description/

Solved first one barely , gave the algo for the second one and barely could write the code because of the time.

Current Designation :SDE-2
Years of experience : 5.5

Round 1: Elimination Round - Problem Solving
Technical Problem:
https://leetcode.com/problems/longest-substring-without-repeating-characters/description/
https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/
Wasn't able to provide full working solution for the second problem, but explain my approach
Verdict : hire

Round2(LLD + HLD)
Was asked to create an LLD for Zomato Food delivery app
taking care of core functionalities, follow up question was asked about tracking of order. what table you will create to track order.
Also some high level design question around the same, how the notification will be sent to the user and basically a verbal explanation of how the HLD of zomato food delivery app will work.
how the closest delivery partner assigning will take place (proximity service Alex xu book)
Verdict : hire

Round 3(DS + Database schema design + Cultural)
Was asked to implement merge sort implementaiton(wasn't able to provide the working implmentation)
Was asked to desgin database schema. The problem statement was like this.
You have multiple rule conditions. The user can select multiple rule conditions from the UI and then these rules will be applied.
The user can select rules like (c1&c2)||c3

The ask was how i am gonna store the data in database and fetch the data from it.
The interviewer was expected to store groups of conditions as an entity, but i reccomending the solution in which each condition will be an entity
Overall i felt interview was fine with the schema design

Questions asked in culture
The time when you did a mistake and messed up the task ? what was the reaction of your team lead and what steps you took to avoid such mistakes.
The time when you received a feedback from someone ? what was your reaction ? what steps did you take regarding that feedback.

Verdict : No hire, because i wasn't able to provide merge sort implemnetation

Prior Experience

• 3 months Intern at Agoda(Gurugram)
• 3 months Intern at Wayfair(Us based Ecommerce)
• 5 months full time experience

Process

Online Assesment followed by 2 rounds of interview. 1 st round Interview: Completely DSA Based on hackerrank platform. Interviewer had the access too.I was given 2 DSA Based one was hard and other one was medium-hard.I was expected to code the optimised approach for all the question and passing the testcases.

Question 1: Was related to Sliding window optimised approach used dequeue data structure. Question 2: Binary tree parent child sum with little tweak.I was expected to even write treenode class and construct a binary tree on own.

2 nd round Interview: Was based on past Experiences && Internship.I was cross questioned on certain topics so I had to choose what I say wisely.

Overall

I had given the Online Assesment in September.Received the Interview call in Mid of March.Two rounds were held in span of two weeks.Got the offer after 1 week of getting Interviewed.

I applied for a MTS position at Salesforce and received a referral, which led me to the interview process. The first stage was a technical online assessment, where I had to solve two coding problems. I'm providing a detailed account of the second problem I encountered, along with different code implementations and a discussion of their complexities. Following the OA, there was a second round, which was a standard interview. That concludes my experience with the process.

Recently took a Salesforce online assessment. Format: 2 coding questions, 90 mins time Questions below-

1. https://leetcode.com/problems/string-compression

A sorted list is where all numbers are sorted in ascending order.
An almost sorted list is where when you remove one number and it becomes sorted.
Eg: 1 3 5 4 7. You can remove 4 to make it a sorted list.
Given a list of numbers, what is the **minimum** numbers you need to remove so that the final list is **almost sorted**.

Contraints expect an O(n log n) solution.

(**Hint**: Think LIS)

Solved both in ~15mins. Recruiter reached out for interview, but never scheduled. :)

I recently participated in the Hackerrank Online Assessment for a Software Member of Technical Staff (SMTS) position at Salesforce, located in the USA. The assessment consisted of two distinct coding challenges.

I recently interviewed for the SMTS (IC3) position at Salesforce, Bangalore, with 6.5 years of experience. The interview process consisted of three rounds: Data Structures & Algorithms, Low-Level and High-Level Design, and a Director round focused on career achievements and behavioral aspects.

My first round was focused on Data Structures and Algorithms. The interviewer presented two coding problems. The first was a variation similar to the Coin Change problem on LeetCode. The second problem was Search a 2D Matrix II. I solved both.

The second round was dedicated to Low-Level and High-Level Design. I was asked to design a notification service. I began by outlining the high-level architecture, detailing the various components and discussing database design. After about 40 minutes, we moved into the low-level design aspects. Here, I elaborated on class diagrams, API specifications, handling various edge cases, and incorporated relevant design patterns for such a system.

The final round was with a Director. This was a more conversational round where I discussed my career journey and highlighted my major accomplishments from my current role. We had an in-depth discussion about key projects I've worked on. Additionally, the interviewer posed several standard leadership and behavioral questions, which allowed me to demonstrate my problem-solving abilities and collaboration skills.

My interview journey for the SMTS position at Salesforce began with an Online Assessment. The OA included the LeetCode problem 'Distinct Subsequences', and another medium-difficulty question whose specifics I couldn't recall. Following the OA, I had two distinct coding rounds.

In the first coding round, I was presented with the LeetCode problem 'Construct Quad Tree'. Additionally, there was a custom question that involved a sliding window technique. This problem required me to process a 2D list of person IDs and their card swipe times, determining the maximum number of swipes made by any single person within a specific time window.

The second coding round focused on more advanced data structure challenges. I was asked to solve 'Binary Tree Maximum Path Sum' and 'Encode and Decode Strings', both well-known problems from LeetCode.

My journey with Salesforce began when a recruiter reached out via Instahyre for an SMTS role. I was asked to complete a Hackerrank test within two days.

Hackerrank Test:
This round featured a couple of questions that I would categorize as easy to medium LeetCode level. I encountered The Kth Factor of N and Implement Trie (Prefix Tree).

After clearing this round, I received an email scheduling two more rounds.

Problem Solving and LLD:
This round involved a problem that was described as a little extension to LeetCode's Two Sum questions. I was also asked to design a data structure to query a set of different data, optimizing for space and time complexity, which felt like a medium-level problem. Additionally, I had to create class diagrams for a Monopoly game and discuss best practices while defining an API endpoint.

LLD (Second Round):
In this round, I was given a design and coding question: implement a cart for an e-commerce website. The focus was on writing workable, easy-to-ship code while following proper design patterns. We had a detailed discussion about the reasoning behind my implementation choices.

Following these rounds, I again received a call from the recruiter confirming I had cleared and scheduling the third round for the very next day.

HLD:
This round focused on the High-Level Design (HLD) of a recommendation system. We had a healthy discussion around each aspect of the design steps.

The recruiter then informed me that they would like to proceed with the HM (Hiring Manager) round, which was scheduled a day later.

HM Round:
This was purely a managerial round. I was asked about my motivations for joining Salesforce, what I was expecting from the role, and standard behavioral questions concerning conflicts and challenges I had faced. This round felt like it went smoothly.

A few days later, I inquired about feedback and was informed of a mixed response from my second LLD round, resulting in a reject. I perceived that the interviewer was keen on a Java implementation, while I had used Python, leading to much of the LLD discussion revolving around static-typed paradigms instead of dynamic-typed ones. This experience made me feel the interview had a mixed outcome. My key takeaway was that while I performed well in other rounds, I need to concentrate more on LLD from a static-type perspective for future interviews.

Round 1: HackerRank Screening

I completed a 60-minute HackerRank screening that featured one medium-difficulty question. I managed to solve the problem, passing all test cases successfully.

Round 2: Data Structures and Algorithm

This round began with introductions, followed by a discussion where I explained my current project. Afterward, the interviewer presented a lengthy story-style problem that, while not directly hinting at it, turned out to be a sliding window problem.

Round 3: System Design

After introductions and a brief discussion about one of my projects, I was challenged with a system design problem: 'How to design Google Docs.' I was expected to present a comprehensive design, including back-of-the-envelope calculations, identifying Single Points of Failure (SPOF), and proposing various optimizations.

Round 4: Hiring Manager Round

This was a behavioral round with the hiring manager. I was asked about my reasons for leaving my current company, why I was interested in joining Salesforce, and my expectations for the role. We also delved into my previous projects, my specific contributions to their design and development, and how I've handled conflicts and collaborated effectively with other teams.

I recently interviewed for the MTS role at Salesforce. I have 2.5 years of experience.

Round 1: Online Assessment
This round lasted an hour and consisted of two easy-medium Data Structures and Algorithms questions. I completed this round successfully.

Round 2: Online - Data Structures & Algorithms
After a brief introduction, I was presented with two DSA questions.

1. The first problem asked me to find K strings with the most occurrences from an array of N strings. If frequencies were equal, lexicographically lower strings were preferred, and results needed to be in decreasing order of frequency. I managed to write working code for this with some help from the interviewer.
2. The second question was to find the number of islands using DFS. Due to time constraints, I couldn't write the full code but I explained my approach clearly.

1. The first question was Target Sum. I initially proposed a recursive solution and then optimized it with memoization. I got a bit stuck on how to fully implement it using dynamic programming, so we moved on to the next problem without completely coding this one.
2. The second problem was Product of Array Except Self. I discussed various approaches, starting from a brute-force method and gradually refining it to an optimal solution, which I then implemented with working code.

Round 1: HackerRank (1 hour)

This round began with two coding challenges. The first was a HackerRank problem titled What Type of Triangle, requiring me to classify triangles based on their side lengths. The second problem was from LeetCode: Search Suggestions System.

Round 2: Onsite | DSA (1 hour)

This round started with a discussion about my projects and Object-Oriented Programming (OOPs) concepts. Following this, I was presented with a LeetCode problem: Rank Transform of an Array. I successfully provided a running O(n) solution that passed all test cases on HackerRank, and I also addressed a follow-up question on space optimization for the given constraints. The final problem was a GFG question titled Count of Distinct Graphs That Can Be Formed With N Vertices. Despite receiving a hint from the interviewer, I couldn't come up with the exact solution for this particular problem.

Round 3: Onsite | DSA (1 hour)

The third round involved another LeetCode problem: Nearest Exit from Entrance in Maze. This round also included one behavioral question, though the specific details were not provided.

Verdict

After the third round, I was informed that my status was 'tentative,' which usually implies a borderline performance leading to a likely rejection. An update is expected within a week. I'm not entirely sure about the expectation, as I felt I performed well in the second round (which I believe should have been a hire) and even better in the third round (a strong hire).

Additional Info

Salesforce provided a 2k Uber voucher for my travel to their Hyderabad office. I was required to bring my own personal laptop for the interview, and breakfast was provided at the office.

I recently got a call from a Salesforce recruiter who reached out to me via LinkedIn. I showed my interest, and with over 5 years of experience, I was asked to go through an Online Assessment first.

The test was conducted on HackerRank and lasted 60 minutes. Two questions were asked:

1. Find the Kth Factor of N
2. Search Suggestions System

Round 1: DS/Algo

1. MAXPARTY
2. Count pairs: Given an array arr[] of length N and an integer K, the task is to count the number of pairs (i, j) such that i < j and arr[i] > K * arr[j]. This problem was similar to count inversion, like Count of Smaller Numbers After Self.

Round 2: LLD + DSA

1. Count the number of distinct contiguous substrings that are palindromes.
2. Max Path Sum in a Binary Tree

Round 3: HLD + Behavioural

Round 4: HM (Hiring Manager)

I took an onsite interview with Salesforce on October 14th, and the entire process spanned approximately 1.5 months. I have 8 years of professional experience.

Round 1: Data Structures & Algorithms

I felt I performed very well in this round. The questions I was asked were:

• Print all paths from the top-left corner to the bottom-right corner of a grid.
• Evaluate an expression, a problem similar to a Calculator-III type question involving complex operations and parentheses.

Round 2: High-Level Design (HLD)

I believed I did extremely well in this round and thought it would lead to a strong hire recommendation. The core problem was to:

• Design a rule engine for a banking system. An example scenario was given: if a user's salary is X and their account is 10 years old, they should be given a Z% discount.

Round 3: Hiring Manager (HM)

This round also went very well. It consisted of:

• A technical discussion about my past projects, where the interviewer asked me to suggest modifications to certain aspects, which I handled successfully.
• A system design question: Design a system for displaying live match scores, akin to what platforms like Hotstar offer. I managed to design this effectively.
• Additionally, there were other typical behavioral questions.

Following these initial rounds, HR contacted me to inform me that I had cleared the SMTS level. However, my desired compensation was higher than their band for SMTS. Consequently, she mentioned that she would process my profile for an LMTS position.

Final Round: Low-Level Design (LLD) for LMTS

This round was an LLD focused on:

• Designing Stack Overflow. I was asked to design the database schema for it, which I did very well, and I also wrote code for parts of the system.
• The discussion then moved to the search functionality. I explained thoroughly what considerations are necessary for such a feature.
• The interviewer then challenged me to write code demonstrating how ElasticSearch performs its searching, specifically asking about the underlying data structures, such as LSM trees. I acknowledge that I did not perform well on this particular aspect.

Despite my strong overall performance, I was ultimately informed that it was a "no-go" for the LMTS position. The HR offered to re-process my profile for another LMTS opening, but I decided to accept the rejection and move on.

Round 1: Online Assessment (1 hour)

This round consisted of two Data Structures and Algorithms questions, ranging from easy to medium difficulty. I solved both of them successfully.

Round 2: Onsite - DSA/SQL (1 hour 30 minutes)

The round began with an introduction and a discussion about my current project and work. Following that, I was given a DSA question based on stocks, where I had to find the maximum profit within a given period. Next was an SQL question involving an employees table, where I needed to identify managers with two employees sharing the same name. We also discussed Java, OOPs concepts, the Collection framework, and a bit about SOLID principles.

Round 3: Onsite - Design (1 hour 15 minutes)

This round started with an introduction and an explanation of my current project's design and data flow using a whiteboard. The main task was to design the data model with an ER diagram for a Hotel Booking system on the whiteboard, explaining the required APIs. Key considerations included handling multiple room types in one hotel, allowing future bookings for the same room, and implementing dynamic pricing based on booking requests. Finally, an easy puzzle was posed: given N number of coins, split them into two groups having the same number of heads.

Round 4: Online - Behavioral (50 minutes)

This round commenced with an introduction and a discussion of my older projects and the details mentioned in my resume. Behavioral questions followed, such as asking about any recent good review comments I had given, how I handle conflicts with a manager, how I mentor my juniors or new hires, and why I was interested in Salesforce. Additionally, there were questions on development practices: how I debug APIs, my general approach, API patterns, and data flow in the frontend. We also discussed scenarios like a table population API payload not populating data and the possible reasons, as well as strategies to increase table population performance. Questions on API protocols and the differences between one-page and multi-page web pages were also part of this round.

I am happy to share that I was selected for the role.

I applied for the SMTS position at Salesforce through an employee referral and received a call for an interview within a week. The entire process, from initial contact to receiving the offer, took about 4-5 weeks.

Round 1: Technical (Data Structures & Algorithms)

This round focused on my problem-solving skills with data structures and algorithms. I was asked to:

• Check if characters of a given string can be rearranged to form a palindrome.
• Find the smallest string divisible by two given strings.
• Write a program to count the number of connected components in an undirected graph.

Round 2: Technical (System Design)

The second technical round was dedicated to system design. I had to provide a High-Level Design (HLD) and schema diagrams for a Vaccination slot booking system, detailing the involved entities.

Round 3: Managerial

This managerial round involved a lot of discussions about my previous work experience. I faced standard managerial questions, such as:

• What would I do if I were new to a project and my manager assigned me a production issue? How would I react?
• What does my typical day look like in my current organization?
• How much code do I write versus how much time I spend on designing?

Round 4: Managerial

The final round, also managerial, involved a deeper discussion on my current project. There were quick questions about concurrency, throttling, and how AWS Serverless services like Lambda work internally. Later, typical operational questions were posed:

• How do I tackle conflicts?
• What would be my ideal team?
• What do I look for in my team members?
• How would I react if I didn't get enough credit for my work?

I answered all these questions confidently.

Verdict

I was selected for the role!

I was initially contacted by a recruiter on LinkedIn regarding this opening at Salesforce.

Online Assessment

1. The first question asked to check if parentheses were valid in a given list of strings.
2. The second question involved finding the maximum gap of unused road given starting and ending locations of cars on a road of size 'n'.

Onsite Rounds

Round 1: Coding (1 hour)

Round 2: Coding + System Design (1 hour)

Round 3: Hiring Manager

Result

My interview journey at Salesforce for the MTS role, with 1.5 years of experience, was quite thorough and well-structured, ultimately leading to an offer. I found the interviewers to be very helpful and polite throughout the process, which made the experience even better.

Round 1: Technical

This round began with introductions, after which I was asked to explain my current project in detail. Following the project discussion, the interviewer presented a problem on topological sorting, specifically related to course scheduling. I was given the problem similar to Course Schedule. After successfully discussing my approach for this problem, I was then given a low-level design problem to solve.

Round 2: Technical

Similar to the first round, this round started with introductions and a detailed discussion about one of my projects. Subsequently, the interviewer gave me a problem to find the minimum meeting rooms required, which was analogous to Meeting Rooms II. Towards the end of this round, I was asked a few behavioral questions.

Round 3: Technical

This round was entirely focused on my resume. The interviewer thoroughly grilled me on every aspect mentioned in my resume, starting with an extensive discussion on my projects. We delved deep into the technologies I used, and there were specific discussions on MVC architecture, REST APIs, core Java concepts, OOPS principles, and even some cross-questions related to Machine Learning.

Round 4: Technical

After an initial discussion, I was given two coding problems in this round. The first problem involved sorting given IP addresses. Following that, the interviewer presented another problem to find the longest substring with unique characters within a given string.

Round 5: Managerial

This final round was entirely dedicated to behavioral questions. I was asked about my reasons for leaving my current company, why I was interested in joining Salesforce, and we had a discussion regarding my expectations from the role and the company.

I am pleased to share that the final verdict was an offer.

I recently interviewed at Salesforce for an SMTS position in Bangalore, India. At the time, I had 7 years of experience and was working as an SDE2 at a top e-commerce firm. My interview process consisted of four rounds.

Round 1: Online Assessment
This round involved a coding question where I had to write code replicating functionalities similar to certain Linux commands.

Round 2: PS/DS Round
In this round, I was given two problems. The first was a LeetCode Medium problem focused on Linked Lists. The second question was the classic Sudoku problem, for which I explained a backtracking approach and provided detailed pseudocode.

Round 3: Coding++ Round
This round had multiple parts. I was asked to implement a function to move all zero elements to the front of an array. Additionally, there were questions specifically on operating system concepts such as Semaphores and Locking mechanisms.

Round 4: Director Round
The final round was conducted by a Director. It included a question on writing an SQL query that specifically utilized a Left Outer Join. I was also tasked with designing the classes required for a Chess game. Towards the end, there were several leadership-focused questions.

I received positive feedback from the recruiter who confirmed that an offer would be rolled out. However, I am still waiting for the official offer letter and feel a bit ghosted at the moment.

Hi Leetcoders, I recently cleared the Salesforce interview for the Hyderabad location. The process initially started in March 2020, where I attended the first round after a recruiter call, which went well. However, due to the lockdown, I never received feedback, and the position was eventually closed in April. Finally, in October, the same recruiter reached out, offering to restart the interview process for a new position from the beginning. Below is a detailed account of my interview experience:

Round 1: Online Assessment (HackerRank ALOHA-5) [90 mins]

1. Contiguous Subarray Sum
2. Maximum sub-matrix sum in a given matrix (I was able to solve the first question quickly, which gave me enough time to work on the second one).

Round 2: (60 min)

1. Maximum path sum in a triangular matrix from top to bottom (Only two directions allowed - down and down-right)
2. Split BST with given value k

Round 3: (90 min)

1. Top K repeated words in a given paragraph (with punctuations and delimiter)
2. LLD of a given scenario on cricket match (Observer design pattern). I was asked to write down running code along with classes. (The scenario was: if I hit a six, my friend will cheer, my dog will bark, my car will blow its horn, etc.)
3. DB Design related to employee and multiple addresses with some scenario-based questions.

Round 4: Managerial (45 mins)

This round was mostly related to my past experience, previous projects, and some behavioral questions.

Final Verdict: Offer

The overall interview experience was very good, and I found the interviewers to be polite.