Prep by Company
Every design problem, grouped by the companies known to ask it. Tap a company to see its questions by difficulty.
Adobe1 problem
Akamai2 problems
Amazon56 problems
EasyAdapter Pattern: Make Two Interfaces That Weren't Built to Talk, TalkEasyFacade Pattern: One Door Into a Room Full of MachineryEasyIterator Pattern: Walk a Collection Without Knowing Its ShapeEasySingleton: One Instance, and the Global It Smuggles InEasyStrategy Pattern: Swap Behavior Without Touching the CallerEasyTemplate Method: Freeze the Recipe, Swap the IngredientsEasyDesigning Tic-Tac-Toe: A Low-Level Design WalkthroughMediumAbstract Factory: Ship a Whole Family, Never a Mismatched PairMediumThe API Gateway: One Front Door for a Hundred ServicesMediumBehavioral Patterns: How Objects Talk and DecideMediumBloom Filters: The Yes/No That Saves a Disk SeekMediumBuilder: Assemble Complex Objects Without the Telescoping ConstructorMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumDesigning a Parking Lot: A Low-Level Design WalkthroughMediumCDNs: Move the Bytes to the User, Not the User to the BytesMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumCommand Pattern: Make a Request Something You Can Hold in Your HandMediumComposite Pattern: One size() Call for a File or Ten ThousandMediumHow Consistent Hashing Powers Distributed SystemsMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDatabase Replication: Copies That Disagree With Each OtherMediumDecorator Pattern: Stack Behavior at Runtime Without a Subclass BombMediumDependency Inversion: Point the Arrow at an AbstractionMediumDesign a Distributed ID GeneratorMediumFactory Method: Let the Subclass Decide What to BuildMediumIdempotency: How to Retry a Payment Without Charging TwiceMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMemento Pattern: Undo Without Cracking the Object OpenMediumMessage Queues & Event Streaming: Stop Making Users Wait for Work They Don't Care AboutMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumPrototype: Clone a Ready-Made Object Instead of Rebuilding ItMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumRate Limiting: How a Bucket of Tokens Keeps Your API AliveMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumState Pattern: Make Illegal Transitions ImpossibleMediumStructural Patterns: Composing Objects Into Bigger ThingsMediumDesign a URL ShortenerHardBridge Pattern: When Two Things Vary, Stop Multiplying ThemHardDesign a Chat SystemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDatabase Sharding: When One Machine Stops Being EnoughHardDesign a Distributed Rate LimiterHardDistributed Transactions: When One Business Action Spans Many ServicesHardInterpreter Pattern: When Your Config Grows a GrammarHardDesign a Key-Value StoreHardDesign a News FeedHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesHardVisitor Pattern: Add Operations Without Editing the ClassesOpen Amazon
Apple2 problems
Atlassian5 problems
EasyAdapter Pattern: Make Two Interfaces That Weren't Built to Talk, TalkMediumCommand Pattern: Make a Request Something You Can Hold in Your HandMediumMediator Pattern: Turn a Mesh of Dependencies Into a StarMediumMemento Pattern: Undo Without Cracking the Object OpenHardInterpreter Pattern: When Your Config Grows a GrammarOpen Atlassian
Bloomberg1 problem
Cloudflare7 problems
MediumBloom Filters: The Yes/No That Saves a Disk SeekMediumCDNs: Move the Bytes to the User, Not the User to the BytesMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumRate Limiting: How a Bucket of Tokens Keeps Your API AliveHardDesign a Distributed Rate LimiterHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesOpen Cloudflare
Discord3 problems
DoorDash1 problem
Figma3 problems
GitHub2 problems
Google53 problems
EasyFacade Pattern: One Door Into a Room Full of MachineryEasyIterator Pattern: Walk a Collection Without Knowing Its ShapeEasySingleton: One Instance, and the Global It Smuggles InEasyStrategy Pattern: Swap Behavior Without Touching the CallerEasyTemplate Method: Freeze the Recipe, Swap the IngredientsEasyDesigning Tic-Tac-Toe: A Low-Level Design WalkthroughMediumAbstract Factory: Ship a Whole Family, Never a Mismatched PairMediumBehavioral Patterns: How Objects Talk and DecideMediumBloom Filters: The Yes/No That Saves a Disk SeekMediumBuilder: Assemble Complex Objects Without the Telescoping ConstructorMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumDesigning a Parking Lot: A Low-Level Design WalkthroughMediumCDNs: Move the Bytes to the User, Not the User to the BytesMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumCommand Pattern: Make a Request Something You Can Hold in Your HandMediumComposite Pattern: One size() Call for a File or Ten ThousandMediumHow Consistent Hashing Powers Distributed SystemsMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDatabase Replication: Copies That Disagree With Each OtherMediumDecorator Pattern: Stack Behavior at Runtime Without a Subclass BombMediumDependency Inversion: Point the Arrow at an AbstractionMediumFactory Method: Let the Subclass Decide What to BuildMediumFlyweight: One 'e' for a Million LettersMediumIdempotency: How to Retry a Payment Without Charging TwiceMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMediator Pattern: Turn a Mesh of Dependencies Into a StarMediumMemento Pattern: Undo Without Cracking the Object OpenMediumMessage Queues & Event Streaming: Stop Making Users Wait for Work They Don't Care AboutMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumPrototype: Clone a Ready-Made Object Instead of Rebuilding ItMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumRate Limiting: How a Bucket of Tokens Keeps Your API AliveMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumState Pattern: Make Illegal Transitions ImpossibleMediumStructural Patterns: Composing Objects Into Bigger ThingsMediumDesign a URL ShortenerHardBridge Pattern: When Two Things Vary, Stop Multiplying ThemHardDesign a Chat SystemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDatabase Sharding: When One Machine Stops Being EnoughHardDesign a Distributed Rate LimiterHardInterpreter Pattern: When Your Config Grows a GrammarHardDesign a News FeedHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesHardVisitor Pattern: Add Operations Without Editing the ClassesOpen Google
Instagram2 problems
JetBrains2 problems
LinkedIn4 problems
Meta41 problems
EasyIterator Pattern: Walk a Collection Without Knowing Its ShapeEasySingleton: One Instance, and the Global It Smuggles InEasyStrategy Pattern: Swap Behavior Without Touching the CallerEasyDesigning Tic-Tac-Toe: A Low-Level Design WalkthroughMediumAbstract Factory: Ship a Whole Family, Never a Mismatched PairMediumBehavioral Patterns: How Objects Talk and DecideMediumBloom Filters: The Yes/No That Saves a Disk SeekMediumBuilder: Assemble Complex Objects Without the Telescoping ConstructorMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumDesigning a Parking Lot: A Low-Level Design WalkthroughMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumComposite Pattern: One size() Call for a File or Ten ThousandMediumHow Consistent Hashing Powers Distributed SystemsMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDatabase Replication: Copies That Disagree With Each OtherMediumDependency Inversion: Point the Arrow at an AbstractionMediumFactory Method: Let the Subclass Decide What to BuildMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMediator Pattern: Turn a Mesh of Dependencies Into a StarMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumPrototype: Clone a Ready-Made Object Instead of Rebuilding ItMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumReal-Time Updates: Polling, Long Polling, SSE, and WebSocketsMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumStructural Patterns: Composing Objects Into Bigger ThingsHardDesign a Chat SystemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDatabase Sharding: When One Machine Stops Being EnoughHardDistributed Transactions: When One Business Action Spans Many ServicesHardDesign a Key-Value StoreHardDesign a News FeedHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesHardVisitor Pattern: Add Operations Without Editing the ClassesOpen Meta
Microsoft44 problems
EasyAdapter Pattern: Make Two Interfaces That Weren't Built to Talk, TalkEasyFacade Pattern: One Door Into a Room Full of MachineryEasyIterator Pattern: Walk a Collection Without Knowing Its ShapeEasySingleton: One Instance, and the Global It Smuggles InEasyStrategy Pattern: Swap Behavior Without Touching the CallerEasyTemplate Method: Freeze the Recipe, Swap the IngredientsEasyDesigning Tic-Tac-Toe: A Low-Level Design WalkthroughMediumAbstract Factory: Ship a Whole Family, Never a Mismatched PairMediumBehavioral Patterns: How Objects Talk and DecideMediumBuilder: Assemble Complex Objects Without the Telescoping ConstructorMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumDesigning a Parking Lot: A Low-Level Design WalkthroughMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumCommand Pattern: Make a Request Something You Can Hold in Your HandMediumComposite Pattern: One size() Call for a File or Ten ThousandMediumHow Consistent Hashing Powers Distributed SystemsMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDecorator Pattern: Stack Behavior at Runtime Without a Subclass BombMediumDependency Inversion: Point the Arrow at an AbstractionMediumFactory Method: Let the Subclass Decide What to BuildMediumFlyweight: One 'e' for a Million LettersMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMediator Pattern: Turn a Mesh of Dependencies Into a StarMediumMemento Pattern: Undo Without Cracking the Object OpenMediumMessage Queues & Event Streaming: Stop Making Users Wait for Work They Don't Care AboutMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumPrototype: Clone a Ready-Made Object Instead of Rebuilding ItMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumState Pattern: Make Illegal Transitions ImpossibleMediumStructural Patterns: Composing Objects Into Bigger ThingsMediumDesign a URL ShortenerHardBridge Pattern: When Two Things Vary, Stop Multiplying ThemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDistributed Transactions: When One Business Action Spans Many ServicesHardInterpreter Pattern: When Your Config Grows a GrammarHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardVisitor Pattern: Add Operations Without Editing the ClassesOpen Microsoft
Netflix39 problems
EasyFacade Pattern: One Door Into a Room Full of MachineryEasyIterator Pattern: Walk a Collection Without Knowing Its ShapeEasyTemplate Method: Freeze the Recipe, Swap the IngredientsMediumThe API Gateway: One Front Door for a Hundred ServicesMediumBehavioral Patterns: How Objects Talk and DecideMediumBloom Filters: The Yes/No That Saves a Disk SeekMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumCDNs: Move the Bytes to the User, Not the User to the BytesMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumCommand Pattern: Make a Request Something You Can Hold in Your HandMediumComposite Pattern: One size() Call for a File or Ten ThousandMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDatabase Replication: Copies That Disagree With Each OtherMediumDecorator Pattern: Stack Behavior at Runtime Without a Subclass BombMediumDependency Inversion: Point the Arrow at an AbstractionMediumIdempotency: How to Retry a Payment Without Charging TwiceMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMessage Queues & Event Streaming: Stop Making Users Wait for Work They Don't Care AboutMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumReal-Time Updates: Polling, Long Polling, SSE, and WebSocketsMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumState Pattern: Make Illegal Transitions ImpossibleMediumStructural Patterns: Composing Objects Into Bigger ThingsHardBridge Pattern: When Two Things Vary, Stop Multiplying ThemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDatabase Sharding: When One Machine Stops Being EnoughHardDistributed Transactions: When One Business Action Spans Many ServicesHardInterpreter Pattern: When Your Config Grows a GrammarHardDesign a Key-Value StoreHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesOpen Netflix
Oracle2 problems
Pinterest1 problem
Slack3 problems
Stripe6 problems
EasyAdapter Pattern: Make Two Interfaces That Weren't Built to Talk, TalkEasyFacade Pattern: One Door Into a Room Full of MachineryMediumThe API Gateway: One Front Door for a Hundred ServicesMediumIdempotency: How to Retry a Payment Without Charging TwiceMediumRate Limiting: How a Bucket of Tokens Keeps Your API AliveHardDesign a Distributed Rate LimiterOpen Stripe
Twitter3 problems
Uber46 problems
EasyAdapter Pattern: Make Two Interfaces That Weren't Built to Talk, TalkEasyFacade Pattern: One Door Into a Room Full of MachineryEasySingleton: One Instance, and the Global It Smuggles InEasyStrategy Pattern: Swap Behavior Without Touching the CallerEasyTemplate Method: Freeze the Recipe, Swap the IngredientsEasyDesigning Tic-Tac-Toe: A Low-Level Design WalkthroughMediumAbstract Factory: Ship a Whole Family, Never a Mismatched PairMediumThe API Gateway: One Front Door for a Hundred ServicesMediumBehavioral Patterns: How Objects Talk and DecideMediumBuilder: Assemble Complex Objects Without the Telescoping ConstructorMediumCaching Strategies: The Bet That Reads RepeatMediumCAP Theorem: The Choice You Only Make When the Network BreaksMediumDesigning a Parking Lot: A Low-Level Design WalkthroughMediumChain of Responsibility: Let the Request Find Its Own HandlerMediumHow Consistent Hashing Powers Distributed SystemsMediumCreational Patterns: Who Decides What Gets BuiltMediumDatabase Indexing: Why B-Trees Read Fast and LSM-Trees Write FastMediumDatabase Replication: Copies That Disagree With Each OtherMediumDecorator Pattern: Stack Behavior at Runtime Without a Subclass BombMediumDependency Inversion: Point the Arrow at an AbstractionMediumDesign a Distributed ID GeneratorMediumFactory Method: Let the Subclass Decide What to BuildMediumFlyweight: One 'e' for a Million LettersMediumIdempotency: How to Retry a Payment Without Charging TwiceMediumInterface Segregation: Don't Make Callers Depend on What They Don't UseMediumLoad Balancing: One Front Door for a Fleet That Keeps ChangingMediumLiskov Substitution: If Clients Must Check the Type, You Broke ItMediumMediator Pattern: Turn a Mesh of Dependencies Into a StarMediumMessage Queues & Event Streaming: Stop Making Users Wait for Work They Don't Care AboutMediumObserver Pattern: Broadcast State Without Knowing Who's ListeningMediumOpen/Closed: Add a Channel Without Touching the CoreMediumPrototype: Clone a Ready-Made Object Instead of Rebuilding ItMediumProxy Pattern: The Stand-In Your Code Can't Tell ApartMediumReal-Time Updates: Polling, Long Polling, SSE, and WebSocketsMediumSOLID, Actually: Five Rules for Code That Survives ChangeMediumSQL vs NoSQL: Model the Access Pattern, Then Pick the StoreMediumSingle Responsibility: One Reason to Change, One OwnerMediumState Pattern: Make Illegal Transitions ImpossibleMediumStructural Patterns: Composing Objects Into Bigger ThingsHardBridge Pattern: When Two Things Vary, Stop Multiplying ThemHardConsensus & Leader Election: How a Cluster Agrees on One TruthHardDatabase Sharding: When One Machine Stops Being EnoughHardDistributed Transactions: When One Business Action Spans Many ServicesHardDesign a Key-Value StoreHardRaft, Driven: Watch a Cluster Elect, Replicate, and HealHardStorage Engines: LSM-Trees vs B-TreesOpen Uber