Confluent Software Engineer Interview Questions

Got interview through referral. ## Qualifier Round: Analyze potential revenue for football (soccer) clubs based on their stadium capacity and historical performance. Use HTTP GET requests to access a

The original poster (OP) interviewed with Confluent and reviewed interview experiences and questions from other users. They expressed gratitude and offered some information to help others. The coding

This post was last edited by leehen on 2025-10-09 15:04 Please give me points!!! It was a fellow countryman who interviewed me. He was very nice, explained things very clearly, was very patient, and e

During the post-qualifier coding round for an SSE2 position at Confluent, I was tasked with solving a search-related problem. I successfully implemented the code for the first half of the requirements

Phone Screen: Implement a data structure to store key-value entries within a time-based interval. Slight variation to LRU Cache. Round 1: Implement a Word Search Engine, given a list of documents with text,...

My experience regarding recent SSE interview rounds with Confluent - I took a referral. After 20 days, recruiter called me and asked to schedule a Qualifer round. Qualifier Round: I was asked a DSA+LLD...

Phone Screen - Modified LRU Cache - Implemented a working solution using map + pair data structure. Coding Round 1 [Hire] - Word Search in a List of Documents - Implemented a working...

Coding round 1 ---------------- you\'re given k v pairs funA: [\'int\',\'bool\'] funB: [\'int\',\'int\'] and queries like [\'int\',\'int\'] return all functions that match the description follow-up you\'re also given a flag is variadic funA: [\'int\',\'bool\'] , isVariadic: true funC: [\'int\',\'int\']...

exp - 5.5yrs current company - product based MNC college - Tier 3 Screening Round- Design a cache with time based eviction policy \t Expectation Implement get(), put(), getAverage() methods Onsite : Round 1 :...

Applied directly on career portal, got a call from recruiter to schedule screening call. exp - 3.5yrs Screening Round: Design a cache with time based eviction policy Expectation Implement get(), put(), getAverage() methods Onsite : Round...

College and all : Tier 1 CSE total yoe : 5 designation offered SSE 5 rounds total 1st Round Find words in a list of docs, extended later to find phrases in those docs 2nd...

We use a distributed worker platform to asynchronously process tasks (\u201Cunits of work\u201D) outside of the scope of a user request. A starting point for such a system could be...

Telephonic. 1.) Do basic string match. Assume only one in the pattern. Follow up: Assume any number of s Onsite 1.) Windowed Average. Your are given a...

LeetCode #37: Sudoku Solver. Difficulty: Hard. Topics: Array, Hash Table, Backtracking, Matrix. Asked at Confluent in the last 6 months.

LeetCode #36: Valid Sudoku. Difficulty: Medium. Topics: Array, Hash Table, Matrix. Asked at Confluent in the last 6 months.

LeetCode #1797: Design Authentication Manager. Difficulty: Medium. Topics: Hash Table, Linked List, Design, Doubly-Linked List. Asked at Confluent in the last 6 months.

## Problem You are furnishing a venue. There are `n` types of chairs available; chair type `i` holds `capacity[i]` people and costs `price[i]` dollars. You need to seat exactly `guests` people. You can buy multiple chairs of the same type. You must seat every guest (no guest left standing). Return the minimum total cost to buy a set of chairs that seats at least `guests` people. ```python def min_cost_to_seat(capacity: list[int], price: list[int], guests: int) -> int: ... ``` ``` Input: capacity = [4, 6, 2], price = [10, 15, 5], guests = 10 Output: 25 Explanation: Buy 1 chair of type 1 (4 seats, $10) + 1 chair of type 2 (6 seats, $15) = 10 seats, $25. Alternatively: 5 x type 3 (10 seats, $25) = same cost. Input: capacity = [3], price = [7], guests = 10 Output: 28 Explanation: Need 4 chairs (ceil(10/3)=4), 4*7=28. ``` ## Follow-ups 1. What if you can only buy each chair type once (0/1 knapsack variant)? 2. How does your solution change if you want to minimize chairs purchased (not cost), breaking ties by cost? 3. What if `guests` can be up to 10^9 — how do you handle the scale? 4. Suppose some chairs require a delivery fee that applies once per type purchased. How do you model that?

## Problem You are building a health monitor for a distributed system. Nodes send heartbeat pings to a central registry. Implement a class that tracks heartbeats and answers liveness queries: - `ping(node_id, timestamp)` — record that `node_id` was alive at `timestamp`. - `is_alive(node_id, timestamp, timeout)` — return `True` if the node sent a ping within `[timestamp - timeout, timestamp]`. - `get_dead_nodes(timestamp, timeout)` — return all nodes that have NOT pinged within the timeout window. ```python class LivenessMonitor: def ping(self, node_id: str, timestamp: int) -> None: ... def is_alive(self, node_id: str, timestamp: int, timeout: int) -> bool: ... def get_dead_nodes(self, timestamp: int, timeout: int) -> list[str]: ... ``` ``` ping("A", 100) ping("B", 105) ping("A", 150) is_alive("A", 160, 20) -> True # last ping at 150, within 20s is_alive("B", 160, 20) -> False # last ping at 105, 55s ago get_dead_nodes(160, 20) -> ["B"] ``` ## Follow-ups 1. Nodes can re-register after being declared dead. How does your data structure handle that cleanly? 2. How would you scale this to 1 million nodes pinging every second? 3. `get_dead_nodes` is O(n) in your current implementation. Can you make it faster using a sorted structure? 4. What happens if node clocks are skewed by up to 5 seconds relative to the server?

## Round 1 - Coding ## Problem Design and implement a food ordering system for a single restaurant. Your system must support: 1. A `Menu` that holds `Item(name, price, category, available)`. Items can be enabled/disabled. 2. A `Cart` per user: `add_item`, `remove_item`, `update_quantity`, `get_total`. 3. An `Order` created from a cart: transitions through states `PLACED -> PREPARING -> OUT_FOR_DELIVERY -> DELIVERED`. Cancellation only allowed before `PREPARING`. ```python class Item: def __init__(self, name: str, price: float, category: str): ... class Cart: def add_item(self, item: Item, qty: int) -> None: ... def remove_item(self, item_name: str) -> None: ... def get_total(self) -> float: ... class Order: def advance_state(self) -> None: ... def cancel(self) -> bool: ... def get_receipt(self) -> str: ... ``` ``` Item("Burger", 9.99, "Mains") cart.add_item(burger, 2) cart.get_total() -> 19.98 order = Order(cart) order.advance_state() # PREPARING order.cancel() -> False (too late) ``` ## Follow-ups 1. How would you apply a discount code that takes 10% off orders above $30? 2. Support multiple restaurants — how does your design change? 3. Where would you add tax calculation, and should it live in `Cart` or `Order`? 4. How do you handle an item becoming unavailable after it's already in a customer's cart?

## Problem You are given a list of function definitions, each with a name and a typed parameter list. You are also given a list of call expressions, each with a function name and argument types. Implement a matcher that returns, for each call, the best matching definition — or `"NO_MATCH"` if none apply. Matching rules (in priority order): 1. Exact type match on all positional arguments. 2. A parameter typed `"any"` matches any argument type. 3. If multiple definitions match, prefer the one with fewer `"any"` parameters. ```python def match_function( definitions: list[dict], # [{"name": str, "params": [str]}] calls: list[dict] # [{"name": str, "args": [str]}] ) -> list[str]: # definition id or "NO_MATCH" per call ... ``` ``` Definitions: {"id": "f1", "name": "foo", "params": ["int", "str"]} {"id": "f2", "name": "foo", "params": ["any", "str"]} Calls: {"name": "foo", "args": ["int", "str"]} -> "f1" (exact beats any) {"name": "foo", "args": ["float", "str"]}-> "f2" (any matches float) {"name": "foo", "args": ["int", "int"]} -> "NO_MATCH" ``` ## Follow-ups 1. Add support for variadic parameters (`*args`) that match zero or more trailing arguments. 2. How do you handle ambiguous matches where two definitions tie on specificity? 3. Support subtype relationships: `int` is a subtype of `number`. How does this change your matching logic? 4. What data structure would you precompute to make repeated matching fast?