DraftKings — Case Study

Context & Problem

The shift to native

DraftKings made a deliberate move away from cross-platform approaches toward native Android — prioritizing platform fidelity, performance, and long-term maintainability. The bet: native quality compounds over time in ways that hybrid can't match.

The stakes

Real-money sports betting means reliability is non-negotiable. A crash or stall during a live in-game wager isn't a UX inconvenience — it's a lost bet, a support ticket, and a dent in user trust. The system has to hold under Super Bowl load.

What I Did

🛡️

Hardened reliability

Drove crash-free session rates up and kept them there. Owned on-call rotation for Android — diagnosing and resolving incidents under live betting load with no tolerance for extended downtime.

📡

Performance & observability

Instrumented the Android app end-to-end for performance visibility. Built Perfetto traces to identify CPU/render bottlenecks. Established metrics that gave the team signal before users noticed degradation.

⚡

Operated under peak load

Shipped and maintained features that ran in production through Super Bowl — the single highest-traffic event in the sports betting calendar. Scale is not theoretical; the system has been tested at ~59K bets/min.

🏗️

Native Android craft

Delivered production features in Jetpack Compose, wired real-time odds and bet updates through WebSocket streams, managed concurrency via coroutines/flows, and kept the architecture clean in an MVVM pattern at scale.

Impact

12M+ bets handled

2.5M users

Super Bowl peak

Production scale — DraftKings Android Sportsbook

Highlights

🛡️
Reliability
Hardened crash-free session rates across the Android Sportsbook. Systematic root-cause work — symbolication, trace analysis, regression detection — kept stability high under continuous feature velocity.
Stability

🚨
On-call Response
Rotated on-call for live Android incidents during active betting windows. Learned to triage fast under pressure — distinguish crash vs. network vs. backend root cause — and resolve without a rollback when possible.
Incident Response

🏟️
Super Bowl Scale
Features shipped and held through Super Bowl — the peak stress test for any US sportsbook. ~59K bets per minute at load, 2.5M concurrent users. The system did not flinch.
Peak Load

📶
Real-time
Live odds, in-play bet updates, and market state driven through persistent WebSocket connections. Concurrency managed via Kotlin coroutines and flows so the UI stays responsive while the stream never lags.
WebSockets

Technical Highlights

Jetpack Compose — declarative UI

Production Compose UI across Sportsbook features. Leveraged composable reuse, state hoisting, and side-effect APIs to keep UI logic clean and testable as the surface area grew.

Coroutines/Flows — concurrency

Structured concurrency via coroutines for all async work; StateFlow/SharedFlow for reactive UI state. Eliminated callback hell and made back-pressure handling predictable under bursty network conditions.

WebSockets — real-time

Persistent WebSocket connections deliver live odds, market state, and bet confirmations. Handled reconnect logic, back-off strategy, and ensuring the UI reflects the latest server state without drift.

Perfetto — profiling

Used Perfetto system traces to surface jank, long frames, and CPU pressure in the Sportsbook app. Traced method-level timings to pinpoint bottlenecks that were invisible in high-level metrics alone.