Cloudkitchens Software Engineer Interview Questions
3+ questions from real Cloudkitchens Software Engineer interviews, reported by candidates.
Round Types
Top Topics
Questions
## Problem You are given a multi-line string representing a restaurant menu. Sections are indicated by lines in ALL CAPS, and items follow as `item_name: $price`. Parse it into a nested dictionary: `{section_name: [{name: str, price: float}]}`. ```python def parse_menu(raw: str) -> dict[str, list[dict]]: pass ``` **Example:** ``` raw = """ APPETIZERS Spring Rolls: $6.50 Soup of the Day: $4.00 MAIN COURSE Grilled Salmon: $18.00 Pasta Primavera: $14.50 """ -> { "APPETIZERS": [{"name": "Spring Rolls", "price": 6.50}, {"name": "Soup of the Day", "price": 4.00}], "MAIN COURSE": [{"name": "Grilled Salmon", "price": 18.00}, {"name": "Pasta Primavera", "price": 14.50}] } ``` ## Follow-ups 1. How do you handle items that appear before any section header? 2. What if prices use different currencies or formats (e.g., `EUR 6,50`)? How do you make price parsing robust? 3. How would you extend this to support sub-sections (indented ALL CAPS headers)? 4. If this parser is used in a scraping pipeline, what logging and error recovery would you add for malformed input lines?
## Problem Design an `OrderManager` system that manages the lifecycle of orders. An order moves through states: `PENDING -> CONFIRMED -> SHIPPED -> DELIVERED`. It can also be `CANCELLED` from `PENDING` or `CONFIRMED` only. Invalid transitions should raise an error. ```python from enum import Enum class OrderStatus(Enum): PENDING = "PENDING" CONFIRMED = "CONFIRMED" SHIPPED = "SHIPPED" DELIVERED = "DELIVERED" CANCELLED = "CANCELLED" class OrderManager: def __init__(self): ... def create_order(self, order_id: str, items: list[str]) -> None: ... def transition(self, order_id: str, new_status: OrderStatus) -> None: ... def get_status(self, order_id: str) -> OrderStatus: ... ``` **Example:** ``` om = OrderManager() om.create_order("ORD-1", ["shirt", "jeans"]) om.transition("ORD-1", OrderStatus.CONFIRMED) # OK om.transition("ORD-1", OrderStatus.DELIVERED) # raises InvalidTransitionError om.transition("ORD-1", OrderStatus.SHIPPED) # OK ``` ## Follow-ups 1. How would you store transition history (audit log) with timestamps for each state change? 2. What design pattern formalizes this kind of state machine, and how does it differ from a simple `if/elif` chain? 3. How would you add hooks (callbacks) that fire when an order enters a specific state (e.g., send email on `SHIPPED`)? 4. If this system must handle thousands of concurrent orders, what persistence layer and locking strategy would you choose?
## Problem You have two tables: `customers(id, name)` and `orders(id, customer_id, amount, created_at)`. Write a SQL query to find the top 5 customers by total spend, along with their order count and average order value. ```sql -- customers: id INT, name VARCHAR -- orders: id INT, customer_id INT, amount DECIMAL, created_at TIMESTAMP SELECT c.name, COUNT(o.id) AS order_count, SUM(o.amount) AS total_spend, AVG(o.amount) AS avg_order_value FROM customers c JOIN orders o ON c.id = o.customer_id GROUP BY c.id, c.name ORDER BY total_spend DESC LIMIT 5; ``` **Example output:** ``` name | order_count | total_spend | avg_order_value ------------|-------------|-------------|---------------- Alice | 12 | 4800.00 | 400.00 Bob | 8 | 3200.00 | 400.00 ``` ## Follow-ups 1. How would you modify the query to show top spenders per month using a window function? 2. What index would you add to `orders` to speed up this aggregation? 3. Rewrite this in Python using pandas from a DataFrame -- what is the equivalent `groupby` chain? 4. How would you handle customers who have placed no orders (LEFT JOIN behavior)?
What Cloudkitchens Looks for in Software Engineer Interviews
Cloudkitchens Software Engineer interviews are calibrated against the level and scope expected of the role. Across 3+ verified candidate reports on LeakCode, the consistent signals interviewers look for: clear problem decomposition before coding, explicit complexity reasoning, structured handling of edge cases, and the ability to articulate trade-offs between two reasonable approaches.
The discriminator between candidates who advance and candidates who do not is rarely the final correctness of the solution. It is the path to the solution: did you ask clarifying questions, did you state your approach before coding, did you handle edge cases without prompting, and did you communicate your reasoning throughout. Reports tagged "no hire" frequently cite a working solution with poor communication; reports tagged "strong hire" cite clear thinking even when the final solution was incomplete.
How To Use This Question Set
Real interview reports are a calibration tool, not a memorization target. Companies update their question pools every 2-4 months; memorizing exact problems risks misleading you when the interviewer uses a variant. The high-leverage use: identify the patterns that appear repeatedly in Cloudkitchens Software Engineer reports, practice those patterns on similar (not identical) problems, and use the reports to understand the interviewer's typical follow-up depth.
Filter the questions below by round type, difficulty, and recency. Focus first on reports from the past 6-12 months; older reports may reference questions that have since rotated out of Cloudkitchens's pool. Reports tagged with quantified difficulty (e.g., "medium-hard") are higher-signal than reports without difficulty tags.
Round-by-Round Expectations
Cloudkitchens Software Engineer loops typically span 4-6 rounds across phone screens and on-site or virtual on-site interviews. The structure varies by company: some run 1 recruiter screen + 1 technical phone + 3-4 on-site rounds; others run 1 recruiter screen + 1 OA + 4-5 on-site rounds. The recruiter screen is logistics and culture-light; the technical phone screen is medium-difficulty coding; the on-site loop covers coding, system design (at L4+ levels), and behavioral rounds.
Each round is designed to surface a specific signal. Coding rounds: correctness, code quality, complexity reasoning, communication. System design rounds: requirements clarification, design judgment, operational thinking. Behavioral rounds: ownership scope, leadership, ambiguity tolerance, conflict navigation. Strong candidates explicitly hit each signal dimension out loud during the round; weak candidates focus only on solving the prompt.
Common Interview Mistakes At This Combination
Reports tagged "no hire" at Cloudkitchens Software Engineer commonly cite: jumping into code without clarifying requirements, coding silently for 10+ minutes without verbalizing approach, missing edge cases (empty input, single element, very large input, overflow), and producing a working solution that the candidate cannot explain or refactor when probed. Strong candidates avoid these patterns by following a consistent template: clarify, verbalize approach, code with narration, test with examples.
Behavioral and design rounds have their own failure modes. Behavioral: stories that use "we" instead of "I" diluting individual signal, stories with no quantified outcome, defensiveness when probed about failure. Design: not asking clarifying questions, not stating requirements out loud, designing for a single server when the prompt clearly implies scale, ignoring operational concerns (deployment, monitoring, rollback). These show up in roughly half of Cloudkitchens Software Engineer interview retrospectives on LeakCode.
See All 3 Cloudkitchens Software Engineer Questions
Full question text, answer context, and frequency data for subscribers.
Get Access