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 You are given an employee table with `(employee_id, name, manager_id)`. Write a function that returns all direct and indirect reports of a given manager, at any depth. ```python def all_reports(employees: List[dict], manager_id: int) -> List[int]: # employees: [{"id": int, "name": str, "manager_id": int | None}] # returns list of employee IDs reporting under manager_id (inclusive of all levels) ... ``` **Example:** ``` employees = [ {"id": 1, "name": "Alice", "manager_id": None}, {"id": 2, "name": "Bob", "manager_id": 1}, {"id": 3, "name": "Carol", "manager_id": 1}, {"id": 4, "name": "Dave", "manager_id": 2}, {"id": 5, "name": "Eve", "manager_id": 2} ] all_reports(employees, 1) -> [2, 3, 4, 5] all_reports(employees, 2) -> [4, 5] ``` ## Follow-ups 1. How would you express this as a recursive CTE in SQL? 2. What is the time complexity if the org chart has N employees and depth D? 3. How would you detect cycles (invalid data where A reports to B and B reports to A)? 4. Extend to return the full subtree as a nested dict.

## Problem Given two tables: ```sql employees(id INT, name VARCHAR, department_id INT, salary DECIMAL) departments(id INT, name VARCHAR) ``` Write queries for each of the following: **Q1:** For each department, return the department name, average salary, and the name of the highest-paid employee. **Q2:** Return employees whose salary is above the average salary of their own department. **Q3:** For each department, rank employees by salary descending. Return all employees with their rank. **Example output for Q3:** ``` dept_name | emp_name | salary | rank -----------+----------+--------+----- Engineering| Alice | 120000 | 1 Engineering| Bob | 95000 | 2 Marketing | Carol | 85000 | 1 ``` ## Follow-ups 1. What is the difference between `RANK()`, `DENSE_RANK()`, and `ROW_NUMBER()`? 2. Rewrite Q2 without a subquery using a window function. 3. How would you find the second-highest salary per department? 4. If the employees table has 10M rows, how do you optimize Q1?

## Problem You are building an expense reimbursement system. Given a list of expense items and a policy configuration, determine which expenses are approved, flagged for review, or rejected. Policy rules (provided as config): - Each `category` has a per-item limit and a monthly limit per employee. - Receipts are required above a configurable threshold. - Certain categories are entirely disallowed. ```python def evaluate_expenses( expenses: List[dict], policy: dict ) -> List[dict]: # Each expense: {"id", "employee_id", "category", "amount", "has_receipt", "date"} # Returns same list with added "status": "approved"|"flagged"|"rejected" and "reason" ... ``` **Example:** ``` policy = { "per_item_limits": {"meals": 75, "travel": 500}, "monthly_limits": {"meals": 300}, "receipt_threshold": 25, "disallowed": ["entertainment"] } expense = {"id": 1, "employee_id": "e1", "category": "meals", "amount": 80, "has_receipt": True, "date": "2025-03-15"} -> {"id": 1, ..., "status": "rejected", "reason": "exceeds per-item limit"} ``` ## Follow-ups 1. How would you handle policies that change mid-month? 2. How do you efficiently compute running monthly totals across a large batch? 3. What if multiple rules conflict - how do you define precedence? 4. How would you make the rule engine extensible for new policy types?

## 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)?