Sierra Software Engineer Interview Questions

Hi everyone! I recently received an interview invitation from Sierra.ai for a Software Engineer/Product role. There are almost no systematic interview experiences online, and the few reviews I find me

## Problem You are building a spreadsheet engine. Each cell has an ID (e.g., "A1"), a declared type (`int`, `float`, `string`, `formula`), and a value. Formula cells reference other cells (e.g., `=A1 + B2`). Implement a validator that checks: (1) type constraints, (2) formula reference validity (no references to undefined cells), and (3) circular dependency detection. ```python class SpreadsheetValidator: def load(self, cells: dict[str, dict]) -> None: """ cells = {cell_id: {"type": str, "value": Any, "refs": list[str]}} """ def validate(self) -> list[str]: """Return list of error messages.""" ``` **Example:** ``` cells = { "A1": {"type": "int", "value": 42, "refs": []}, "B1": {"type": "formula", "value": "=A1+C1", "refs": ["A1","C1"]}, "C1": {"type": "formula", "value": "=B1", "refs": ["B1"]} } validate() -> ["Circular dependency: B1 -> C1 -> B1", "C1 references undefined A1? No..."] ``` ## Follow-ups 1. How do you detect circular dependencies efficiently — DFS with coloring? 2. If a formula cell's value must equal a specific type, how do you infer the return type of a formula? 3. How would you compute evaluation order for valid formulas (topological sort)? 4. What should happen when a referenced cell's type changes — how do you propagate re-validation?

## Problem Split or partition a data stream or array into fixed-size chunks, handling remainder chunks at the boundary. ## Likely LeetCode equivalent No close equivalent. ## Tags coding, arrays, chunking, phone-screen

## Round 1 - System Design ## Problem An e-commerce platform has inventory split across 5 regional warehouses. When a customer places an order, the system must decrement inventory at the appropriate warehouse. Design a system that keeps inventory consistent: no overselling, eventual consistency across the central view, and the ability to transfer stock between warehouses. **Key constraints:** - Orders peak at 50K/sec globally - Customers should see approximate availability (eventual), but orders must not oversell - Stock transfers take minutes and must be tracked ## Follow-ups 1. How do you prevent two simultaneous orders from both succeeding when only 1 unit remains? 2. Describe how you'd implement stock reservation with a TTL (reserve -> confirm or release). 3. If a warehouse node goes offline, how do orders for its stock behave? 4. How would you reconcile the global inventory view after a network partition heals?

## Problem Build a simple streaming pipeline framework. A `Stream` accepts items, applies a transform function, and fans out to multiple downstream consumers. If a consumer is slow (its internal queue is full), the producer should block (backpressure) rather than drop items. ```python class Stream: def __init__(self, transform: Callable, buffer_size: int): ... def subscribe(self, consumer: 'Stream') -> None: """Add a downstream consumer.""" def publish(self, item: Any) -> None: """Apply transform and push to all consumers. Block if any consumer is full.""" def start(self) -> None: ... def stop(self) -> None: ... ``` **Example:** ``` source = Stream(transform=lambda x: x * 2, buffer_size=100) logger = Stream(transform=print, buffer_size=50) source.subscribe(logger) source.publish(5) # logger receives 10 ``` ## Follow-ups 1. What synchronization primitives do you use — threading.Queue, asyncio.Queue, or semaphores? 2. If one consumer is permanently slow, should it block all other consumers? How do you design around this? 3. How would you add a `filter` operator that drops items not matching a predicate without losing backpressure? 4. Describe how Kafka solves the same fan-out and backpressure problems at scale.