Draftkings Software Engineer Interview Questions
4+ questions from real Draftkings Software Engineer interviews, reported by candidates.
Round Types
Top Topics
Questions
This post was last edited by leehen on 2025-10-4 16:22. Requesting points!! Another round of interviews is about to begin, I want to read some interview experiences to boost my confidence. I didn't pa
Promotion Validation: Validate and Apply Discount Promotions With Stacking and Exclusion Rules
## Problem An e-commerce checkout applies promotional codes. Each promo has: a discount type (`percent` or `flat`), a value, minimum cart total to qualify, and an `exclusive` flag (exclusive promos cannot be stacked with others). Given a cart total and a list of applied promo codes, validate and compute the final discounted price. ```python def apply_promotions( cart_total: float, promo_codes: list[str], promo_db: dict # {code: {type, value, min_cart, exclusive}} ) -> dict: """ Returns { "final_price": float, "applied": [codes], "rejected": {code: reason} } """ ``` **Example:** ``` promo_db = { "SAVE10": {"type":"percent","value":10,"min_cart":50,"exclusive":False}, "FLAT20": {"type":"flat", "value":20,"min_cart":100,"exclusive":True} } apply_promotions(120.0, ["SAVE10","FLAT20"], promo_db) -> {"final_price": 88.0, "applied":["FLAT20"], "rejected":{"SAVE10":"exclusive conflict"}} ``` ## Follow-ups 1. If multiple non-exclusive promos are applied, what order should percent vs. flat discounts be applied? Does order matter? 2. How do you handle a promo that would make the final price negative? 3. How would you design the promo schema to support "buy X get Y free" style promotions? 4. If promo validation logic is complex, how do you test it without integration testing the whole checkout?
## Round 1 - OOD ## Problem Design the object model for a robot-staffed restaurant. The system must handle: table management, order taking by robots, kitchen preparation with cook stations, order delivery by a different set of robots, and billing. Different robot types have different capabilities. **Core entities to model:** - `Table`, `Order`, `MenuItem`, `KitchenStation` - `Robot` (base), `WaiterRobot`, `RunnerRobot`, `KitchenRobot` - `RestaurantController` (orchestrator) ```python class Robot: def __init__(self, robot_id: str, capabilities: list[str]): ... def assign_task(self, task: 'Task') -> bool: ... def status(self) -> str: ... class Order: def __init__(self, table: 'Table'): ... def add_item(self, item: 'MenuItem', qty: int): ... def total(self) -> float: ... def state(self) -> str: # PLACED, PREPARING, READY, DELIVERED ``` ## Follow-ups 1. How do you assign tasks to robots — what scheduling algorithm do you use (round-robin, nearest-robot, load-based)? 2. If a WaiterRobot breaks mid-order, how does the system reassign responsibility? 3. How do you model the kitchen pipeline — is it a queue per station or a global queue? 4. What design pattern handles state transitions for an Order (State, Strategy, or explicit FSM)?
## Problem A fantasy sports team has a lineup of `n` slots, each requiring a specific position (e.g., PG, SG, SF, PF, C, FLEX). Each player has one or more eligible positions. Determine whether a given player-to-slot assignment is valid, and if not, find if a valid assignment exists (using backtracking or bipartite matching). ```python def is_valid_lineup(lineup: dict[str, str], players: dict[str, list[str]]) -> bool: # lineup = {slot: player_name} # players = {player_name: [eligible_positions]} # Each player used at most once; each slot filled exactly once pass def find_valid_lineup(slots: list[str], players: dict[str, list[str]]) -> dict | None: # Return a valid assignment or None if impossible pass ``` **Example:** ``` slots = ["PG", "SG", "FLEX"] players = {"CurryS": ["PG"], "ThompsonK": ["SG"], "PooleJ": ["SG","FLEX"]} find_valid_lineup(slots, players) -> {"PG": "CurryS", "SG": "ThompsonK", "FLEX": "PooleJ"} ``` ## Follow-ups 1. This is a bipartite matching problem — describe the Hopcroft-Karp algorithm and its complexity. 2. If a slot can be filled by any of 3 position types (FLEX), how do you model that in the bipartite graph? 3. How does the problem change if you want to maximize total projected points across all valid lineups? 4. How would you use constraint propagation to prune the search space early?
What Draftkings Looks for in Software Engineer Interviews
Draftkings Software Engineer interviews are calibrated against the level and scope expected of the role. Across 4+ 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 Draftkings 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 Draftkings's pool. Reports tagged with quantified difficulty (e.g., "medium-hard") are higher-signal than reports without difficulty tags.
Round-by-Round Expectations
Draftkings 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 Draftkings 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 Draftkings Software Engineer interview retrospectives on LeakCode.
See All 4 Draftkings Software Engineer Questions
Full question text, answer context, and frequency data for subscribers.
Get Access