Rippling Software Engineer Phone Screen Questions

First Round (filter) for SSE at #Rippling. Rippling provides use of AI(optional). So I told interviewer that **I will not use AI tools.** I was expected to solve three parts of the below question bu

For starters use an LLM. I was told there would be two different questions depending on if you use an LLM, that is a lie. You're given a list of doordash employees that make a certain amount per hour

**YOE: 6 years** # Part 1 – Basic Implementation **Problem Statement:** We are given a list of drivers and the deliveries they are making. Implement a service to compute the total cost of all deliveri

They interviewed staff, and the first round was a phone interview with a sales manager. The question was actually mentioned online: design Google News. I felt I did alright, maybe a 75 out of 100, but

Round 1: White guy, the interview was smooth. I finished most of the questions, but there was still some expansion to cover, which I didn't have time for. I gave a general overview: Design a key-value

This post was last edited by Anonymous on 2025-10-12 23:51 Order: 1. Coding round -> Manager -> 2. Coding + SD Three rounds of coding, all questions were from various sources. Here are the key points:

I recently interviewed for a Senior Software Engineer role at Rippling, consisting of an initial HR screen and a subsequent coding round. The technical challenge required designing a Delivery System.

## Problem Design a class hierarchy for an article management system. Support the following operations: - `publish(article_id, title, body, author_id, tags)` - store and index the article. - `get(article_id) -> Article` - retrieve by ID. - `search(query) -> List[Article]` - full-text search across title and body. - `by_tag(tag) -> List[Article]` - return all articles with the given tag, sorted by publish time descending. - `by_author(author_id) -> List[Article]` - all articles by that author. ```python class Article: id: str title: str body: str author_id: str tags: List[str] published_at: datetime class ArticleSystem: def publish(self, title: str, body: str, author_id: str, tags: List[str]) -> Article: ... def get(self, article_id: str) -> Article: ... def search(self, query: str) -> List[Article]: ... def by_tag(self, tag: str) -> List[Article]: ... def by_author(self, author_id: str) -> List[Article]: ... ``` ## Follow-ups 1. How would you implement `search` efficiently at scale - what index structure? 2. How do you handle concurrent `publish` calls without duplicate IDs? 3. Add a `draft` state so articles are not searchable until explicitly published. 4. How would you paginate `by_tag` results?

## Problem Given a hand of 5 playing cards, return its poker rank as a string. Cards are represented as two-character strings: rank (`2-9`, `T`, `J`, `Q`, `K`, `A`) followed by suit (`s`, `h`, `d`, `c`). Ranks in descending order: `"straight_flush"`, `"four_of_a_kind"`, `"full_house"`, `"flush"`, `"straight"`, `"three_of_a_kind"`, `"two_pair"`, `"one_pair"`, `"high_card"`. ```python def evaluate_hand(cards: List[str]) -> str: ... ``` **Example:** ``` Input: ["As", "Ks", "Qs", "Js", "Ts"] Output: "straight_flush" Input: ["2h", "2d", "2c", "3s", "3h"] Output: "full_house" Input: ["Ah", "7c", "3d", "9s", "Jh"] Output: "high_card" ``` ## Follow-ups 1. Extend to compare two hands and return the winner. 2. Handle the edge case where Ace can be low (A-2-3-4-5 straight). 3. How would you evaluate a 7-card hand (Texas Hold'em) efficiently? 4. Describe how you would test this function for correctness.

## Problem Find the best exchange rate between currencies using graph traversal (Bellman-Ford or DFS with multiplication). ## Likely LeetCode equivalent LC 399 (Evaluate Division) is the direct match. ## Tags graph, BFS, DFS

## Problem Design a delivery tracking system. A delivery moves through states: `CREATED -> PICKED_UP -> IN_TRANSIT -> OUT_FOR_DELIVERY -> DELIVERED` (or `FAILED`). Implement: - `create_delivery(package_id, origin, destination) -> Delivery` - `update_status(delivery_id, new_status, location, timestamp)` - `get_status(delivery_id) -> DeliveryStatus` - `get_history(delivery_id) -> List[StatusEvent]` - `deliveries_by_driver(driver_id) -> List[Delivery]` ```python class Delivery: id: str package_id: str origin: str destination: str driver_id: Optional[str] current_status: str class StatusEvent: status: str location: str timestamp: datetime class DeliverySystem: def create_delivery(self, package_id: str, origin: str, destination: str) -> Delivery: ... def update_status(self, delivery_id: str, status: str, location: str, ts: datetime): ... def get_status(self, delivery_id: str) -> str: ... def get_history(self, delivery_id: str) -> List[StatusEvent]: ... ``` ## Follow-ups 1. How do you enforce state machine transitions (reject invalid state changes)? 2. How would you notify customers in real time when status changes? 3. If a driver handles 200 deliveries/day, how do you query their active deliveries efficiently? 4. How would you handle clock skew if status updates arrive out of order?

## Problem Build a registration form component with the following requirements: - Fields: `username` (3-20 chars, alphanumeric), `email` (valid format), `password` (min 8 chars, at least one digit). - Validate on blur; show inline error messages below each field. - The Submit button is disabled until all fields are valid. - On submit, call `onSubmit(formData)` and display a success banner; reset the form. ```jsx // Implement this component function RegistrationForm({ onSubmit }) { // ... } ``` **Expected behavior:** ``` User types "ab" in username -> on blur shows: "Username must be 3-20 characters" User fixes it -> error clears, Submit enables if other fields are also valid User submits -> onSubmit({username, email, password}) called, form resets ``` ## Follow-ups 1. How would you debounce async username-availability checks as the user types? 2. How do you make this form accessible (ARIA attributes, focus management)? 3. Describe how to lift this validation logic into a reusable `useForm` hook. 4. How would you handle server-side validation errors returned from the submit call?

## Problem Simulate Conway's Game of Life, evolving a grid based on neighbor count rules for one or more steps. ## Likely LeetCode equivalent LC 289 (Game of Life) is the direct match. ## Tags matrix, simulation, arrays

## Problem Design an in-memory key-value store supporting get, set, delete, and possibly TTL or versioning. ## Likely LeetCode equivalent LC 1396 (Design Underground System) or LRU Cache (LC 146) are conceptually related. ## Tags hash_table, design, system_design

## Problem Simulate infection spread through a network, finding the time for all nodes to become infected via BFS. ## Likely LeetCode equivalent LC 2039 (The Time When the Network Becomes Idle) or LC 994 (Rotting Oranges) are related. ## Tags graph, BFS, simulation

## Problem Determine if a series of patches covers an entire range, similar to the jump game or interval coverage problem. ## Likely LeetCode equivalent LC 330 (Patching Array) is closely related. ## Tags arrays, greedy, intervals

## Problem You are given a list of performance events for athletes in a competition. Each event has `{athlete_id, event_type, value, timestamp}`. Implement: - `top_k(event_type, k) -> List[Athlete]`: athletes with the highest aggregate value for that event type. - `personal_best(athlete_id, event_type) -> float`: the single best value recorded. - `trend(athlete_id, event_type) -> str`: `"improving"`, `"declining"`, or `"stable"` based on the last 5 events. ```python class PerformanceAnalytics: def __init__(self, events: List[dict]): ... def top_k(self, event_type: str, k: int) -> List[str]: ... def personal_best(self, athlete_id: str, event_type: str) -> float: ... def trend(self, athlete_id: str, event_type: str) -> str: ... ``` **Example:** ``` events = [ {"athlete_id": "a1", "event_type": "sprint", "value": 10.5, "timestamp": 1}, {"athlete_id": "a1", "event_type": "sprint", "value": 10.2, "timestamp": 2}, {"athlete_id": "a2", "event_type": "sprint", "value": 10.8, "timestamp": 1} ] top_k("sprint", 1) -> ["a1"] # lowest sprint time = best personal_best("a1", "sprint") -> 10.2 trend("a1", "sprint") -> "improving" ``` ## Follow-ups 1. How do you define "improving" vs "stable" - linear regression slope, or simple delta? 2. How would you update analytics incrementally as new events stream in? 3. How do you handle athletes with fewer than 5 recorded events for `trend`? 4. What index structures would you use to make `top_k` O(log n)?

## Problem Group phrases or sentences that are anagrams of each other or share a canonical form. ## Likely LeetCode equivalent LC 49 (Group Anagrams) is closely related. ## Tags hash_table, strings, sorting

## Problem Schedule project tasks respecting dependencies, using topological sort to find a valid execution order. ## Likely LeetCode equivalent LC 207 (Course Schedule) is the direct match. ## Tags graph, topological-sort, DFS

## Problem Group or detect strings that are similar based on a defined similarity rule such as one swap or matching characters. ## Likely LeetCode equivalent LC 839 (Similar String Groups) is the direct match. ## Tags strings, union-find, graph