Yelp interview questions & answers

20 real Yelp interview questions with full model answers — Coding, Product & growth, Technical. Drawn from the same verified bank ChannelPulse drills from (38 Yelp questions in total).

CodingEasyYelpSoftware Engineer

1. Minimum Index Sum of Two Lists (LeetCode)

Model answer

The task

Given two lists of strings, return every string that appears in both lists and has the smallest sum of its positions across the two lists. If several strings tie for the minimum, include all of them.

Key idea

Store each string’s position in the first list in a hash table. Scan the second list once, computing the position sum for each shared string and keeping track of the smallest sum seen so far.

Approach

  1. Build a map from strings in the first list to their positions.
  2. Initialize the best position sum and an empty result list.
  3. Scan the second list with its positions.
  4. For each shared string, calculate the position sum.
  5. Replace the result when the sum is smaller; append when it ties.
class Solution:
    def findRestaurant(self, list1: list[str], list2: list[str]) -> list[str]:
        # Map each string to its position in the first list.
        first_index = {name: i for i, name in enumerate(list1)}

        best_sum = float("inf")
        result = []

        # Check shared strings and track all minimum-sum ties.
        for j, name in enumerate(list2):
            if name not in first_index:
                continue

            index_sum = first_index[name] + j

            if index_sum < best_sum:
                best_sum = index_sum
                result = [name]
            elif index_sum == best_sum:
                result.append(name)

        return result

Complexity:

  • Time: O(n + m), for building the map and scanning the second list.
  • Space: O(n), for the position map.

Common follow-ups

  • Return only the minimum position sum as well: track and return best_sum alongside the result.
  • Handle case-insensitive matching: normalize strings, such as with casefold(), before storing and comparing.
  • Process a very large second list as a stream: scan it incrementally while maintaining the current best sum and matching strings.
CodingEasyYelpSoftware Engineer

2. Two Sum (LeetCode)

Model answer

The task

Given a list of integers and a target, return the indices of two distinct elements whose values add up to the target. The usual version guarantees a valid pair.

Key idea

As we scan the list, store each value’s index in a hash table. For the current value, check whether its needed complement has already appeared; this finds a pair in one pass.

Approach

  1. Create a dictionary mapping previously seen values to their indices.
  2. For each element, compute the complement needed to reach the target.
  3. If that complement is in the dictionary, return its stored index and the current index.
  4. Otherwise, store the current value and index, then continue.
from typing import List

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # Map each value already visited to its index.
        seen = {}

        for index, value in enumerate(nums):
            complement = target - value

            # A match must come from an earlier, distinct element.
            if complement in seen:
                return [seen[complement], index]

            seen[value] = index

        # The standard problem guarantees a solution.
        raise ValueError("No two elements sum to the target")

Complexity:

  • Time: O(n), where n is the number of elements; each lookup and insertion is O(1) on average.
  • Space: O(n), for the dictionary of values seen so far.

Common follow-ups

  • What if there may be multiple valid pairs? Return the first pair found, or keep searching and collect pairs according to the required output rules.
  • What if the input is sorted? Use two pointers from opposite ends for O(1) extra space; preserve original indices if those are required.
  • What if values repeat? The dictionary stores indices, and checking before insertion ensures the current element is not paired with itself.
CodingEasyYelpSoftware Engineer

3. Longest Common Prefix (LeetCode)

Model answer

The task

Given a list of strings, return the longest string that is a prefix of every entry. If there is no shared prefix, return an empty string.

Key idea

Compare characters at the same position across all strings, starting from the first string. Stop at the first mismatch or when any string runs out.

Approach

  1. If the list is empty, return an empty string.
  2. Scan each character of the first string from left to right.
  3. For each position, compare that character with the character at the same position in every other string.
  4. If a string is too short or a character differs, return the matching prefix before that position.
  5. If all positions match, return the first string.
from typing import List

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ""

        first = strs[0]

        for i, char in enumerate(first):
            for word in strs[1:]:
                if i == len(word) or word[i] != char:
                    return first[:i]

        return first

Complexity:

  • Time: O(S), where S is the total number of characters inspected.
  • Space: O(1) auxiliary space, excluding the returned prefix.

Common follow-ups

  • How would you handle many prefix queries over the same set of strings? Build a trie once, then traverse it to find shared prefixes.
  • Could sorting help? Yes. Sort the strings and compare only the first and last; their common prefix is shared by all strings.
  • What if strings arrive as a stream? Keep a running prefix and shorten it as each new string arrives.
CodingEasyYelpSoftware Engineer

4. Reverse Linked List (LeetCode)

Model answer

The task

Given the head of a singly linked list, reverse its links in place and return the new head.

Key idea

Recursively reverse the list starting at the second node. As the recursion unwinds, point each node’s successor back to it, then clear its old forward link.

Approach

  1. If the list has zero or one node, it is already reversed.
  2. Recursively reverse the list after the head and save its new head.
  3. Point the next node back to the current node.
  4. Set the current node’s next pointer to None to finish the reversed list.
  5. Return the saved new head.
class Solution:
    def reverseList(self, head):
        # An empty or single-node list is already reversed.
        if head is None or head.next is None:
            return head

        # Reverse the remainder of the list.
        new_head = self.reverseList(head.next)

        # Put the current node after its former successor.
        head.next.next = head
        head.next = None

        return new_head

Complexity:

  • Time: O(n), where n is the number of nodes.
  • Space: O(n), for the recursive call stack.

Common follow-ups

  • Can you do it iteratively with O(1) extra space? Use previous, current, and next_node pointers to reverse links while traversing.
  • What if the list is empty or has one node? The base case returns it unchanged.
  • Can you reverse only a portion of the list? Track the sublist boundaries and reconnect them after reversing that segment.
CodingEasyYelpSoftware Engineer

5. Destination City (LeetCode)

Model answer

The task

Given a list of directed city-to-city paths, return the city that has no outgoing path.

Key idea

A destination city has no path leaving it, so it never appears as a source city. Put every source in a set, then find the destination that is absent from that set.

Approach

  1. Collect the source city from each path into a set.
  2. Visit each path’s destination.
  3. Return the first destination not in the source set.
  4. The problem guarantees a unique destination city.
from typing import List

class Solution:
    def destCity(self, paths: List[List[str]]) -> str:
        # Cities with outgoing paths.
        sources = {source for source, _ in paths}

        # The destination city has no outgoing path.
        for _, destination in paths:
            if destination not in sources:
                return destination

        # The input guarantees a destination, so this is unreachable.
        raise ValueError("No destination city found")

Complexity:

  • Time: O(n), for building the set and scanning the paths.
  • Space: O(n), to store the source cities.

Common follow-ups

  • What if there can be multiple destination cities? Return all destinations absent from the source set.
  • What if paths arrive as a stream? Keep a set of sources, then track destinations and remove any that later appear as sources.
  • What if city names have inconsistent capitalization? Normalize names before inserting or comparing them.
CodingEasyYelpSoftware Engineer

6. Check If a Word Occurs As a Prefix of Any Word in a Sentence (LeetCode)

Model answer

The task

Given a sentence and a search word, return the 1-based position of the first sentence word that starts with the search word. Return -1 if no word matches.

Key idea

Check each word from left to right and stop at the first prefix match. Python’s startswith handles the comparison directly.

Approach

  1. Split the sentence into words.
  2. Visit each word with its 1-based position.
  3. Return the position of the first word that starts with the search word.
  4. If none match, return -1.
class Solution:
    def isPrefixOfWord(self, sentence: str, searchWord: str) -> int:
        for position, word in enumerate(sentence.split(), start=1):
            if word.startswith(searchWord):
                return position
        return -1

Complexity:

  • Time: O(n + m), where n is the sentence length and m is the search word length. The total prefix comparisons are bounded by the characters in the words checked.
  • Space: O(n) for the list of words created by split().

Common follow-ups

  • What if the search word is empty? startswith("") matches the first word; define a different behavior if the specification requires it.
  • How would you avoid allocating a list of words? Scan the sentence by word boundaries and compare each word’s prefix.
  • How would you return every matching position? Collect each matching word’s 1-based position instead of returning immediately.
CodingEasyYelpSoftware Engineer

7. Minimum Value to Get Positive Step by Step Sum (LeetCode)

Model answer

The task

Given an integer array, find the smallest positive starting value such that adding the array’s values one at a time always leaves a positive running total.

Key idea

The running total is the starting value plus a prefix sum. The smallest valid start is therefore the larger of 1 and 1 - the smallest prefix sum.

Approach

  1. Initialize the running prefix sum and its minimum to zero, accounting for the empty prefix.
  2. Scan the array, adding each value to the prefix sum.
  3. Track the smallest prefix sum seen.
  4. Return at least 1, or enough to raise that minimum prefix sum to 1.
class Solution:
    def minStartValue(self, nums: list[int]) -> int:
        prefix_sum = 0
        min_prefix_sum = 0

        for value in nums:
            prefix_sum += value
            min_prefix_sum = min(min_prefix_sum, prefix_sum)

        return max(1, 1 - min_prefix_sum)

Complexity:

  • Time: O(n), for one pass through the array.
  • Space: O(1), using only a few variables.

Common follow-ups

  • What if the running total must stay nonnegative instead? Use max(0, -min_prefix_sum) as the smallest nonnegative start.
  • What if values arrive as a stream? Track the running sum and its minimum as values arrive; the final answer uses the same formula.
  • Can the method handle an empty array? Yes; the initial minimum prefix sum is zero, so it returns 1.
CodingEasyYelpSoftware Engineer

8. Valid Anagram (LeetCode)

Model answer

The task

Determine whether two strings contain the same characters with the same frequencies, regardless of order.

Key idea

Anagrams have identical character counts. Count the characters in each string and compare the resulting frequency maps.

Approach

  1. If the strings have different lengths, return False.
  2. Build a frequency map for each string.
  3. Return whether the maps are equal.
from collections import Counter

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        # Different lengths cannot have matching character counts.
        if len(s) != len(t):
            return False

        # Anagrams have exactly the same character frequencies.
        return Counter(s) == Counter(t)

Complexity:

  • Time: O(n), where n is the length of either string; counting and comparison are linear.
  • Space: O(k), where k is the number of distinct characters stored in the frequency maps.

Common follow-ups

  • Can you do this without two maps? Update one frequency map using s, then decrement counts using t; verify all counts return to zero.
  • What if the input is guaranteed to contain only lowercase English letters? Use a fixed-size array of 26 counters instead of maps.
  • What if sorting is allowed? Sort both strings and compare them; this takes O(n log n) time.
CodingMediumYelpSoftware Engineer

9. Course Schedule (LeetCode)

Model answer

The task

Given a number of courses and prerequisite pairs, decide whether it’s possible to complete every course. A prerequisite pair means one course must be taken before another.

Key idea

Represent courses as a directed graph, with an edge from each prerequisite to the course that depends on it. A cycle means the courses in that cycle depend on one another, so not all courses can be completed.

Use Kahn’s topological-sort algorithm: repeatedly take courses with no remaining prerequisites and remove their outgoing edges.

Approach

  1. Create an adjacency list and count each course’s prerequisites (its indegree).
  2. Add every course with indegree zero to a queue.
  3. Remove courses from the queue, counting each as completed.
  4. Decrease the indegree of each dependent course; enqueue it when its indegree reaches zero.
  5. Return whether the number completed equals the total number of courses.
from collections import deque
from typing import List

class Solution:
    def canFinish(
        self, numCourses: int, prerequisites: List[List[int]]
    ) -> bool:
        # Edges point from prerequisite to the course that depends on it.
        graph = [[] for _ in range(numCourses)]
        indegree = [0] * numCourses

        for course, prerequisite in prerequisites:
            graph[prerequisite].append(course)
            indegree[course] += 1

        # Begin with courses that have no prerequisites.
        ready = deque(
            course
            for course in range(numCourses)
            if indegree[course] == 0
        )

        completed = 0

        while ready:
            course = ready.popleft()
            completed += 1

            for dependent in graph[course]:
                indegree[dependent] -= 1
                if indegree[dependent] == 0:
                    ready.append(dependent)

        return completed == numCourses

Complexity:

  • Time: O(V + E), where V is the number of courses and E is the number of prerequisite pairs.
  • Space: O(V + E) for the graph, indegrees, and queue.

Common follow-ups

  • How can you return a valid course order? Record courses as they are removed from the queue; return the order if it includes every course.
  • How can DFS detect a cycle? Track nodes as unvisited, visiting, or finished; reaching a visiting node reveals a cycle.
  • What if there are no courses? The algorithm returns True, since zero courses can all be completed.
CodingMediumYelpSoftware Engineer

10. Reverse Words in a String (LeetCode)

Model answer

The task

Return the words of a string in reverse order, with exactly one space between words and no leading or trailing spaces. Treat any run of whitespace as a separator.

Key idea

Reverse the entire character array, then reverse each word to restore its letters. While scanning, compact words in place and write only one space between them.

Approach

  1. Convert the string to a mutable character array and reverse it.
  2. Scan past whitespace to find each word.
  3. Reverse the letters within that word.
  4. Copy the word to the next write position, inserting one space if needed.
  5. Join the compacted portion of the array.
class Solution:
    def reverseWords(self, s: str) -> str:
        chars = list(s)
        n = len(chars)

        def reverse(left: int, right: int) -> None:
            while left < right:
                chars[left], chars[right] = chars[right], chars[left]
                left += 1
                right -= 1

        # Reversing the whole string puts the words in reverse order.
        reverse(0, n - 1)

        read = 0
        write = 0

        while read < n:
            # Skip any whitespace between words.
            while read < n and chars[read].isspace():
                read += 1

            if read == n:
                break

            start = read

            # Find the end of the current word.
            while read < n and not chars[read].isspace():
                read += 1

            end = read - 1
            reverse(start, end)

            # Keep exactly one space between output words.
            if write > 0:
                chars[write] = " "
                write += 1

            # Compact this word into the output prefix.
            for i in range(start, end + 1):
                chars[write] = chars[i]
                write += 1

        return "".join(chars[:write])

Complexity:

  • Time: O(n), where n is the string length.
  • Space: O(n) for the mutable character array.

Common follow-ups

  • How would you handle only ordinary spaces as separators? Replace isspace() with comparisons to " ".
  • Can this be done in place? The character operations are in place, but Python strings are immutable, so the array requires O(n) space.
  • What if the input is a stream too large to fit in memory? Use an external or chunked representation, while preserving word boundaries between chunks.
CodingMediumYelpSoftware Engineer

11. Insert Delete GetRandom O(1) (LeetCode)

Model answer

The task

Design a collection that supports adding and removing values, plus returning a uniformly random stored value. Each operation should take average O(1) time.

Key idea

Store values in a list for constant-time random indexing, and map each value to its index for fast lookup. To remove an item without shifting the list, swap it with the last item and then pop.

Approach

  1. Keep a list of stored values and a dictionary from value to its list index.
  2. For insertion, return False if the value is already present; otherwise append it and record its index.
  3. For removal, return False if absent. Otherwise, move the last value into the removed value’s slot, update its index, then pop and delete the removed value from the dictionary.
  4. For random selection, choose a uniformly random index in the list.
  5. Assume random selection is called only when the collection is nonempty.
import random

class RandomizedSet:
    def __init__(self):
        self.values = []
        self.index_by_value = {}

    def insert(self, val: int) -> bool:
        if val in self.index_by_value:
            return False

        self.index_by_value[val] = len(self.values)
        self.values.append(val)
        return True

    def remove(self, val: int) -> bool:
        if val not in self.index_by_value:
            return False

        index = self.index_by_value[val]
        last_value = self.values[-1]

        # Fill the removed value's slot with the last value.
        self.values[index] = last_value
        self.index_by_value[last_value] = index

        self.values.pop()
        del self.index_by_value[val]
        return True

    def getRandom(self) -> int:
        return random.choice(self.values)

Complexity:

  • Time: O(1) average per operation; dictionary operations are expected O(1).
  • Space: O(n), for the list and index map storing n values.

Common follow-ups

  • How would you support duplicates? Store each value’s set of indices and update that set during swaps.
  • What if random selection must be weighted? Maintain cumulative weights and use binary search, or use a dynamic weighted-sampling structure.
  • What happens if getRandom is called when empty? Define a clear error or sentinel behavior; the implementation assumes at least one value exists.
CodingMediumYelpSoftware Engineer

12. String Compression (LeetCode)

Model answer

The task

Compress consecutive runs of identical characters in a character array, modifying it in place. Keep one character per run and append the run’s count as decimal digits when it is greater than one; return the length of the compressed prefix.

Key idea

Use one pointer to scan each run and another to write the compressed result. Since the write pointer never moves ahead of the read pointer, writing the result cannot overwrite characters that are still needed.

Approach

  1. Start read and write pointers at the beginning of the array.
  2. For each run, remember its character and count its length.
  3. Write the character at the next output position.
  4. If the run has multiple characters, write its count one digit at a time.
  5. Return the final write position.
from typing import List

class Solution:
    def compress(self, chars: List[str]) -> int:
        read = 0
        write = 0
        n = len(chars)

        while read < n:
            char = chars[read]
            run_start = read

            while read < n and chars[read] == char:
                read += 1

            count = read - run_start
            chars[write] = char
            write += 1

            if count > 1:
                # Find the highest power of ten in the count.
                divisor = 1
                while divisor <= count // 10:
                    divisor *= 10

                # Write the count's digits from most to least significant.
                while divisor > 0:
                    digit = (count // divisor) % 10
                    chars[write] = str(digit)
                    write += 1
                    divisor //= 10

        return write

Complexity:

  • Time: O(n), since each character is scanned once and the output has at most O(n) digits.
  • Space: O(1) auxiliary space; the array is modified in place.

Common follow-ups

  • What if counts use a different base? Find the digits in that base and write them from most significant to least.
  • What if the input cannot be modified? Build and return a separate output sequence.
  • What if runs are streamed and the input is unbounded? Retain the current character and count, emitting each run when it ends.
CodingMediumYelpSoftware Engineer

13. Decode String (LeetCode)

Model answer

The task

Decode a string where a number before brackets indicates how many times to repeat the bracketed section. Sections may be nested.

Key idea

Parse the input into a compact tree of literal fragments and repeat nodes instead of expanding nested sections immediately. Then traverse that tree to produce the decoded string, avoiding repeated copying of large intermediate strings.

Approach

  1. Scan the input, accumulating each repetition count.
  2. On an opening bracket, save the current fragment list and count, then start a new list.
  3. On a closing bracket, wrap the current list in a repeat node and add it to its parent.
  4. Traverse the resulting structure with an explicit stack, yielding literal fragments as they are needed.
  5. Join the yielded fragments into the result.
class Solution:
    def decodeString(self, s: str) -> str:
        # Each repeat node is a (count, fragments) tuple.
        current = []
        stack = []
        count = 0

        for char in s:
            if "0" <= char <= "9":
                count = count * 10 + int(char)
            elif char == "[":
                stack.append((current, count))
                current = []
                count = 0
            elif char == "]":
                parent, repeat = stack.pop()
                # Omit zero repetitions so traversal skips empty sections.
                if repeat:
                    parent.append((repeat, current))
                current = parent
            else:
                current.append(char)

        def fragments():
            # Frames contain a fragment list, its next index, and
            # how many times to traverse that list.
            frames = [[current, 0, 1]]

            while frames:
                parts, index, remaining = frames[-1]

                if index == len(parts):
                    remaining -= 1
                    if remaining == 0:
                        frames.pop()
                    else:
                        frames[-1][1] = 0
                        frames[-1][2] = remaining
                    continue

                node = parts[index]
                frames[-1][1] += 1

                if isinstance(node, str):
                    yield node
                else:
                    repeat, nested = node
                    frames.append([nested, 0, repeat])

        return "".join(fragments())

Complexity:

  • Time: O(n + m), where n is the encoded length and m is the decoded length.
  • Space: O(n + m) for the parsed structure and returned string.

Common follow-ups

  • How would you handle malformed input? Validate bracket balance and ensure each opening bracket has a preceding count.
  • How could this support streaming output? Yield decoded fragments to a consumer instead of joining them into one string.
  • What if the grammar adds escaping or other operators? Extend the parser with explicit rules and represent each operation as a distinct node.
CodingMediumYelpSoftware Engineer

14. Filter Restaurants by Vegan-Friendly, Price and Distance (LeetCode)

Model answer

The task

Given restaurants with an ID, rating, vegan-friendly flag, price, and distance, return the IDs that meet the requested filters. Order them by rating descending, breaking ties by ID descending.

Key idea

Filter out restaurants that violate any active limit, then sort the remaining entries by the required ranking. A tuple key with negated values expresses descending order using Python’s ascending sort.

Approach

  1. Iterate through each restaurant record.
  2. If vegan-friendly is required, skip records without that flag.
  3. Skip records whose price or distance exceeds its limit.
  4. Sort the survivors by descending rating, then descending ID.
  5. Return their IDs in that order.
from typing import List

class Solution:
    def filterRestaurants(
        self,
        restaurants: List[List[int]],
        veganFriendly: int,
        maxPrice: int,
        maxDistance: int,
    ) -> List[int]:
        # Each record is [id, rating, veganFriendly, price, distance].
        eligible = []

        for restaurant in restaurants:
            restaurant_id, rating, is_vegan, price, distance = restaurant

            if veganFriendly == 1 and is_vegan == 0:
                continue
            if price > maxPrice or distance > maxDistance:
                continue

            eligible.append(restaurant)

        # Negating both fields sorts rating and ID in descending order.
        eligible.sort(key=lambda r: (-r[1], -r[0]))

        return [restaurant[0] for restaurant in eligible]

Complexity:

  • Time: O(n log n), where n is the number of restaurants, due to sorting.
  • Space: O(n) for the list of eligible restaurants.

Common follow-ups

  • How would you handle a third ranking criterion? Add it to the sort key in the required priority order.
  • What if there are many queries over the same restaurant data? Pre-index or sort by relevant fields to reduce repeated filtering and sorting.
  • What if the input is too large to keep all survivors in memory? Use an external sort or process data in chunks and merge sorted results.
Product & growthMediumYelpProduct Manager

15. Our search tool is our most used feature - how would you measure it's success?

The full question

Our search tool is our most used feature - how would you measure it's success?

Make it harder? Evaluate at least three different behaviors.

Model answer

1. Clarify the goal

I’d define search success as helping someone complete the task behind their query, not simply returning results or generating clicks. On Yelp, that task might be finding a suitable restaurant, comparing options, or locating a specific business. I’d distinguish a successful search from a quick exit, while recognizing that not every useful search ends in a transaction we can observe.

2. Define the metrics

My North Star would be successful search sessions per search session: the share of sessions where the user reaches a meaningful outcome, such as contacting, saving, requesting a quote from, or getting directions to a business. I’d pair it with a user-reported success signal because some offline outcomes are invisible to us.

I’d evaluate at least these three behaviors:

  1. Result selection: Does the user open a relevant business from the results? I’d measure result-to-detail click-through, but segment it by query type and position. A click alone is not success; misleading snippets can inflate it.
  2. Meaningful follow-through: After opening a result, does the user take an intent signal such as calling, requesting a quote, saving, or getting directions? I’d track the rate per search session and by business category and device.
  3. Search friction or abandonment: Does the user reformulate, add filters, paginate repeatedly, or leave without engaging? Repeated reformulations and rapid backtracking can indicate poor relevance. But a no-click session may still be successful if the user found a phone number or address on the results page.

3. Break down the journey

flowchart LR
  A[Search query] --> B[Results viewed]
  B --> C[Business opened]
  C --> D[Meaningful action]
  B --> E[Refine or reformulate]
  B --> F[Leave or no click]
Diagram

4. Investigate and decide

I’d instrument the full journey, then segment by query intent, new versus returning users, location, device, and result position. I’d combine behavioral data with a lightweight “Did you find what you needed?” survey and review query reformulations for relevance failures. I’d also compare cohorts or run a randomized experiment before attributing a lift to a ranking change.

5. Guardrails and trade-offs

I’d monitor latency, zero-result rate, business coverage, ad load, and downstream user satisfaction. A ranking change that increases clicks but also increases quick backs or reduces successful actions is not an improvement. I’d optimize for task completion and trust, using clicks as diagnostic signals rather than the goal.

Product & growthMediumYelpProduct Manager

16. How do you think we track our product's success?

The full question

How do you think we track our product's success?

Make it harder? Evaluate at least three different user behaviors.

Model answer

Clarify

I’d define product success as creating repeated, trustworthy matches between consumers and local businesses—not simply increasing time spent in the app. The right measures depend on the user’s intent, so I’d evaluate the full journey and separate leading indicators from outcomes.

Define metrics

My north star would be successful local decisions per active consumer: a meaningful business action, followed where measurable by evidence that the experience met the user’s need. Actions might include a reservation, order, call, or directions request. I’d pair the action data with sampled post-visit feedback because an action by itself does not prove a good match.

Break down by behavior

  1. Search and discovery: Are users finding relevant options? Track successful-search rate (a search followed by a business action), time to first useful result, and reformulation or abandonment. Break down by query type, market, device, and new versus returning users.
  2. Evaluation: Are business pages helping users decide? Track page-to-action conversion, useful engagement with reviews/photos, and repeated comparison behavior. I’d avoid treating scroll depth or time-on-page as inherently positive; longer sessions can mean confusion.
  3. Intent fulfillment: Do users complete what they came to do? Measure booking/order completion where integrated, call or directions actions, cancellations, and failures. Separate actions by type and destination, since a directions tap is not equivalent to a completed reservation.
  4. Contribution and return: Do people come back and contribute useful information? Track retained consumers, review/photo contribution, and contribution quality signals such as policy compliance and helpfulness—not raw review volume alone.

Investigation

I’d look at cohort funnels and trends, then segment by intent, geography, business category, and platform. I’d combine event data with surveys, usability tests, support contacts, and business feedback. For a feature change, I’d use a randomized experiment when feasible, validate event instrumentation first, and check that exposure and experiment assignment are balanced.

Decision & guardrails

I’d ship when the experiment improves successful decisions or demonstrated task completion without harming trust, business outcomes, or access to smaller/local businesses. Guardrails include review integrity, cancellations and complaints, latency, accessibility, and distribution of traffic across businesses. I’d report both average effects and meaningful segment differences: a positive overall result can hide a worse experience for a particular market or user group. Finally, I’d keep a small set of diagnostic metrics rather than declaring every dashboard movement a measure of success.

Product & growthMediumYelpProduct Manager

17. One of the main activities for anyone here is lunch.

The full question

One of the main activities for anyone here is lunch. We occasionally have catered lunches and we have a bar/cafe that provides drinks. However, one big problem is waiting in lines for these lunches can be long. Design a product that would help Yelp engineers pick up their catered lunch without having to line up.

Make it harder? Whiteboard your solution.

Model answer

Clarify & scope

I’d design for Yelp employees picking up a catered lunch at a fixed location, with limited food, a known service window, and a kitchen or catering team that needs predictable handoff. The goal is to remove avoidable waiting without creating a new bottleneck or wasting food. I’d first confirm whether employees can choose meals in advance and how frequently the menu or supply changes.

User segments & pain points

The primary user is an engineer with a short lunch break who wants to know what is available and collect it quickly. They may be in a meeting, arrive at a different time than expected, or have dietary needs. The caterer needs a simple, reliable count and a way to identify each order; workplace operations needs visibility into demand and leftovers.

Goals & success metrics

The north star is successful lunch pickups with minimal wait and waste. I’d measure median and 90th-percentile pickup time, share of orders collected, stockouts, food waste, and satisfaction. Guardrails include accessibility, dietary/allergen accuracy, order fairness for people who cannot pre-order, and workload for the catering team.

Solutions

I’d consider scheduled pickup slots, a virtual queue with live wait estimates, or a pre-order and express-pickup flow. I’d recommend pre-ordering with capacity-limited pickup windows, plus a walk-up option for unreserved meals. Employees select a meal and slot before a cutoff; the system confirms only while inventory and slot capacity remain. At pickup, a rotating QR code or short order code lets staff mark the meal as handed over. Employees can cancel before the cutoff, returning the allocation to inventory.

flowchart LR
  A[View menu and allergens] --> B[Choose meal and slot]
  B --> C[Check capacity and confirm]
  C --> D[Receive pickup code]
  D --> E[Arrive in slot]
  E --> F[Staff verifies and hands off]
  F --> G[Record pickup or no-show]
Diagram

Prioritization & trade-offs

I’d start with a lightweight mobile-friendly web page and staff-facing order list rather than building a full app feature. Pickup slots smooth arrivals but may feel restrictive; walk-up inventory and easy cancellation preserve flexibility. I’d avoid promising exact wait times until we have reliable service-time data. Dietary details should be confirmed by the caterer, not inferred from menu text.

MVP, measurement & rollout

Pilot for one lunch service with a limited menu, published cutoff, and a few pickup slots. Compare wait time and leftovers with similar prior lunches, and collect brief employee and staff feedback. Instrument reservation, cancellation, arrival, pickup, and no-show events. If wait falls but no-shows or waste rise, adjust slot sizes, reminders, or the cutoff before expanding. After the pilot, test across different lunch sizes and service setups; keep a staffed fallback for outages or employees who cannot use the online flow.

Product & growthMediumYelpProduct Manager

18. We're always looking for ways to improve our app experience for our users.

The full question

We're always looking for ways to improve our app experience for our users. Based on your research, how would you improve Yelp?

Make it harder? Use data to validate your solution.

Model answer

Clarify & scope

I’d treat “improve Yelp” as helping people confidently choose a local business that fits their needs, while also creating valuable, sustainable demand for businesses. I wouldn’t assume a particular feature is the answer; I’d first use research and behavioral data to find where people struggle in that decision.

User segments & pain points

I’d focus on someone choosing an unfamiliar restaurant for a specific occasion—say, a group dinner with dietary constraints and a limited budget. They may find many plausible options, but still have to reconcile ratings, recent reviews, photos, price, availability, and whether the business actually fits their needs. A high average rating alone may not answer “Is this right for tonight?”

I’d validate that problem with interviews and usability sessions, then quantify it: search reformulations, back-and-forth between business pages, exits without an action, and post-visit feedback. I’d compare new versus returning users and high-intent versus exploratory searches. That helps distinguish a discovery problem from, for example, missing inventory or a supply gap in a neighborhood.

Goals & success metrics

My north star would be successful local decisions: users who take a meaningful action—such as booking, ordering, calling, or requesting directions—and later report that the business met their needs. I’d track action rate and a lightweight, sampled post-visit satisfaction signal together. Guardrails would include business exposure fairness, cancellation or complaint rates, review trust, and performance across neighborhoods and business sizes. Clicks alone are not success if they create poor visits or concentrate demand unfairly.

Solutions

I’d explore three options: clearer filters for occasion and constraints; more relevant review and photo summaries; and availability-aware recommendations that incorporate hours or booking availability.

Recommendation: Test a decision-support experience for high-intent searches: let users state a few needs, then show a small set of matching businesses with the evidence behind each match, including relevant recent review themes. I’d make the rationale visible rather than presenting an opaque “best” ranking.

flowchart LR
  A[Search and needs] --> B[Relevant shortlist]
  B --> C[Compare evidence]
  C --> D[Business action]
  D --> E[Post-visit feedback]
Diagram

Prioritization & trade-offs

I’d prioritize by expected lift in successful decisions, confidence from research, and engineering effort. A constrained pilot is preferable to a broad ranking change: it limits risk to business visibility and makes the result easier to interpret.

MVP, measurement & rollout

Run an experiment in a few high-volume categories and markets, comparing the experience with the current search journey. Check both short-term actions and delayed satisfaction, with guardrails for latency, cancellations, and distribution of exposure. If users act more but report worse outcomes, I would not ship; I’d use the qualitative sessions and segment results to refine the matching criteria first.

Product & growthMediumYelpProduct Manager

19. What's your favorite consumer product?

The full question

What's your favorite consumer product? Please don't use Yelp.

For this problem we'll be using Discord.

Make it harder? Follow along and use Discord as your answer.

Model answer

My pick: Discord

Discord is my favorite consumer product because it makes ongoing community feel natural rather than forcing every interaction into a one-to-one chat. A server can hold different conversations in channels, while voice rooms make it easy to drop in without scheduling a call. That combination serves both lightweight socializing and more organized communities.

Why it works for me

The product gives users a clear mental model: servers are communities, channels are topics, and presence shows who is around. It also supports different levels of commitment. I can read along quietly, join a text conversation, or move into voice when I want a more immediate interaction. That flexibility helps a community stay useful between big events, not just during them.

I also like how Discord supports community identity through roles, moderation tools, and server-specific norms. Those tools let communities shape the experience without making every server feel like the same generic feed. The trade-off is that a new user can find a busy server overwhelming: there may be too many channels, unfamiliar jargon, or unclear expectations about where to start.

The product lesson I take from it

Discord shows how a product can create value not only through individual features, but through the relationships and habits that form around them. If I were improving the first-run experience, I’d help new members identify a good first channel and understand the community’s norms, while keeping the experience lightweight for existing members. I’d measure whether that increases meaningful first-week participation—not just time spent or messages sent—and watch guardrails like mutes, notification opt-outs, and reports.

That balance between helping people connect and respecting their attention is what makes Discord especially compelling to me as a product.

TechnicalMediumYelpProduct Manager

20. What is the benefit of having a control group when testing?

The full question

What is the benefit of having a control group when testing?

Make it harder? Give an example to help illustrate your point.

Model answer

  1. A control group gives us a counterfactual. It estimates what would have happened to comparable users without the change. Without it, a before-and-after improvement could be caused by seasonality, marketing, or a change in the types of users arriving—not the feature we shipped.
  2. Random assignment makes the comparison credible. If eligible users are randomly assigned to treatment or control, the groups should be similar on average. We can then attribute a difference in outcomes to the tested change, subject to measurement quality and statistical uncertainty.
  3. Example: Suppose Yelp tests a new search ranking intended to help people find relevant local businesses. We randomly assign eligible users to either the new ranking or the existing ranking. After the test, we compare a preselected outcome—such as the rate of search sessions that lead to a meaningful action like directions or a call—along with guardrails such as latency and quick returns to results.
flowchart LR
  A[Eligible users] --> B[Random assignment]
  B --> C[Control: current experience]
  B --> D[Treatment: new ranking]
  C --> E[Measure outcome and guardrails]
  D --> E
  E --> F[Compare groups]
Diagram
  1. The comparison helps avoid a misleading conclusion. If both groups improve because more users are searching for businesses during a holiday weekend, the control reveals that common trend. The treatment-control difference is a better estimate of the feature’s incremental effect than the treatment group’s raw change over time.
  2. I’d still check the experiment carefully. I’d choose the assignment unit to avoid spillover (often user or account), verify that assignment and exposure are logged correctly, run the test long enough to cover normal usage patterns, and report uncertainty. I’d also watch for sample-ratio mismatch and avoid stopping early just because the result looks favorable.

A control group does not guarantee a good experiment, but it is the foundation for separating the effect of a change from everything else happening at the same time.

Practice these out loud, don't memorise them

Reading an answer is not the same as being able to give one under pressure. ChannelPulse plays the interviewer, asks the follow-ups, and scores each answer with feedback and a model answer so you can hear the gap between what you said and what lands.

Get ChannelPulse Browse all questions