Group Anagrams (LeetCode 49) — given an array of strings, group the anagrams together.

The key insight is that two strings are anagrams if and only if their sorted characters are identical, so you can use a sorted-string as a hash map key mapping to a list of original words. Iterate once, sort each word (O(k log k) per word where k is word length), and append to the map. Total time O(n * k log k), space O(n * k). A common follow-up is to use a character-frequency tuple as the key instead of sorting, reducing to O(n * k). Correct use of hash maps for grouping, ability to spot the canonical-form insight quickly, and awareness of the sorting vs. frequency-count trade-off.

Kth Largest Element in every subarray of size K to N — given an array, for every i from k to n return the kth largest element in the subarray arr[0..i].

A min-heap of size k is the standard approach: iterate through the array, push each element, pop if heap exceeds size k, and the heap top is the kth largest at each step. Time O(n log k), space O(k). An alternative is binary-search insertion into a sorted structure. Follow-ups typically probe whether the candidate can articulate why a max-heap of size n would be wasteful. Heap and priority queue intuition, correct handling of the running-window variant, and clear time and space complexity articulation.

Rearrange Array — given an array with both negative and positive numbers, rearrange in-place so all negatives appear before all positives while preserving relative order.

A naive two-pointer swap loses relative order; the correct approach is a stable partition using an insertion-sort-style shift. Shift each negative element left past all positives encountered. Time O(n^2) worst case in-place; if extra space is allowed, a single pass into two queues merged back is O(n). In-place stable partition in O(n) is an advanced follow-up. Understanding the in-place constraint, awareness that a simple swap breaks relative order, and ability to walk through a dry run with edge cases.

Design a Job Scheduler system — covering both HLD and LLD. Write LLD code for job creation, persistence, dispatching, and execution flow.

Start by clarifying requirements: recurring vs. one-time jobs, distributed vs. single-node, at-least-once vs. exactly-once execution. HLD: a job store (database with job status state machine), a dispatcher polling for due jobs and pushing to a message queue, and worker nodes consuming from the queue. LLD: define Job, JobStore, Dispatcher, and Worker interfaces; implement a thread-safe priority queue ordered by next-run timestamp; handle retries with exponential back-off. Key trade-offs: polling interval vs. push-based triggers, leader election for the dispatcher, idempotency tokens on jobs. Follow-ups: how to handle missed jobs across a restart, how to scale to millions of jobs. Ability to move between high-level distributed design and class-level implementation code, thread safety awareness, and a clear state machine for job lifecycle.

Design a Rate Limiter — HLD of a distributed rate limiter with algorithm choices discussed (e.g. token-bucket vs. sliding window); follow-up on LLD for the core algorithm.

Identify the scope (per user, per IP, per API key) and the algorithm (fixed window is simple but has boundary bursts; sliding window log is accurate but memory-heavy; token bucket is the industry standard for APIs). HLD: a centralized Redis store with Lua scripts for atomic increment plus expire, a sidecar or middleware layer in the gateway. LLD: implement a TokenBucket class with last-refill timestamp, capacity, and rate. Follow-ups: clock skew across nodes, Redis as a single point of failure. Knowledge of at least two algorithms and their trade-offs, understanding of atomicity requirements in distributed counters, and practical operability concerns.

Design a Notification System supporting multiple channels — email, SMS, and push notifications — at scale, starting with HLD then moving to LLD class diagrams and APIs.

Clarify fan-out patterns (one event to many users), delivery guarantees (at-least-once), and user preference management. Architecture: an event bus receives notification events, a fan-out service reads user preferences and routes to channel-specific workers (email, SMS, push). Rate-limit per user per channel. Store a notification log for deduplication and delivery status tracking. Key follow-up: partial failures when one channel is down, dead-letter queues. Understanding of async event-driven design, realistic handling of partial failures across channels, and operability (observability, deduplication).

Tell me about a time you received negative feedback. How did you react and how did you resolve it?

Choose a real example where the feedback was substantive. Structure: describe the feedback and context, acknowledge what made it hard to hear, explain the concrete steps you took to address it and what you changed, and share the measurable outcome. Tie back to Salesforce's Trust value by showing you can earn trust through transparency and accountability. Avoid framing the feedback as wrong. Self-awareness, growth mindset, and willingness to change behavior based on input — a proxy for coachability and psychological safety on the team.

Describe a situation where you had a disagreement with a team member or manager about a technical direction. How did you handle it?

Pick an example where you genuinely disagreed and stakes were real. Establish why the disagreement arose, describe how you listened and sought to understand the other perspective before presenting your case with data, explain how you reached a decision (your view prevailed, theirs did, or a third path), and describe the outcome. Salesforce interviewers look for disagree-and-commit maturity. Ability to handle conflict constructively, data-driven persuasion rather than positional arguments, and respect for the team after a decision is made.

Tell me about a time you had to juggle multiple competing priorities or projects. How did you decide what to focus on?

Frame the situation with real competing deadlines, explain your prioritization framework (impact to the customer, deadlines, dependencies, stakeholder alignment), describe how you communicated trade-offs proactively rather than silently dropping items, and quantify the outcome. Salesforce's Customer Success value means customer impact should be a factor in your reasoning. Structured thinking under ambiguity, proactive communication with stakeholders, and evidence that prioritization was rational rather than reactive.

Salesforce Interview Questions

Salesforce SWE interviews span levels labeled MTS (Member of Technical Staff, roughly SDE-2), SMTS (Senior), and LMTS (Lead). The loop typically runs 3 to 5 rounds: a proctored HackerRank or Quip-based online assessment (60-90 minutes, 2 medium DSA problems), two coding rounds, a system design round (LLD and/or HLD, more prominent at SMTS and above), and a hiring manager behavioral round. Behavioral questions carry more weight than at many peer companies and are often interspersed throughout every technical round, not siloed to a single slot. Salesforce sometimes asks candidates to write code in Quip (their own Google Docs-like tool) rather than a standard coding IDE, and interviewers may ask for language-specific implementation rather than language-agnostic pseudocode.

17 real questions across 3 rounds

Reported via LeetCode Discuss: Salesforce MTS September 2024 (leetcode.com/discuss/5815567) — Group Anagrams confirmed; Salesforce MTS July 2024 (leetcode.com/discuss/5526715) — count valid words confirmed; Salesforce LMTS April 2025 (leetcode.com/discuss/6857467) — kth largest subarray and rearrange array confirmed; Salesforce MTS 2026 (leetcode.com/discuss/7561138) — Sudoku Solver confirmed via a February 2026 report; GeeksforGeeks Salesforce MTS Set 4

4 more coding questions Salesforce actually asks, each with how to approach it and exactly what the interviewer is evaluating. Unlock the full set across every round.

Continue with Google

Or run a Salesforce mock with the AI interviewer. It asks questions like these, follows up on your answers, and tells you exactly what to fix. The only score that means anything is the one on your real answers.

Continue with Google

Keep prepping

All company interviews