System Design (Low-Level to High-Level)

Build a rock-solid object-oriented foundation so every design you draw compiles into clean, extensible Java code.

• Classes, objects, and encapsulation in Java
• Abstraction vs implementation hiding
• Inheritance vs composition trade-offs
• Polymorphism: compile-time and runtime
• Interfaces vs abstract classes
• Association, aggregation, and composition relationships
• UML class diagrams and sequence diagrams
• Object lifecycle, constructors, and immutability
• Cohesion and coupling in class design
• Identifying classes and responsibilities from a problem statement
• Modeling real-world entities: parking lot, library, ATM examples
• Common OOP interview pitfalls (god classes, anemic models)

Internalize SOLID and companion principles so your designs stay maintainable as requirements evolve under interview pressure.

• Single Responsibility Principle with refactoring examples
• Open/Closed Principle via strategy-style extension points
• Liskov Substitution Principle and subtype contracts
• Interface Segregation Principle vs fat interfaces
• Dependency Inversion Principle and constructor injection
• DRY, KISS, and YAGNI in interview code
• Law of Demeter and reducing coupling
• Composition over inheritance revisited
• Design by contract: pre/post-conditions and invariants
• Code smells that signal a principle violation
• Applying principles under interview time constraints
• Trade-offs: over-engineering vs under-engineering

Master the Gang-of-Four patterns interviewers actually probe, so you can name, justify, and code the right pattern on demand.

• Creational patterns: Singleton and thread-safe lazy init
• Factory Method and Abstract Factory
• Builder pattern for complex object construction
• Prototype pattern and object cloning
• Structural patterns: Adapter, Decorator, Facade
• Composite and Proxy patterns
• Behavioral patterns: Strategy and Observer
• Command, State, and Template Method patterns
• Chain of Responsibility and Iterator
• Choosing a pattern from a problem description
• Anti-patterns and when NOT to apply a pattern
• Patterns in real frameworks (Spring beans, Java Streams)

Turn ambiguous prompts into working, well-tested class hierarchies within a 45-60 minute machine-coding round.

• LLD interview framework: requirements to classes to code
• Clarifying functional and non-functional requirements
• Designing a Parking Lot system end-to-end
• Designing an Elevator System with scheduling strategies
• Designing a Splitwise / expense-sharing system
• Designing a Tic-Tac-Toe / board game engine
• Designing a Library Management System
• Designing a Movie Ticket Booking system with seat locking
• Concurrency-safe design: locks, synchronized blocks, atomics
• Extensibility: adding new features without breaking contracts
• Writing testable code with JUnit during machine coding
• Handling edge cases and thread-safety in live coding
• Live coding etiquette: talking through trade-offs while typing

Model entities and access patterns correctly upfront so schema decisions don't collapse under real production load.

• Entity-relationship modeling for system design interviews
• Normalization vs denormalization trade-offs
• Choosing relational vs document vs wide-column models
• Schema design in PostgreSQL: keys, indexes, constraints
• Document modeling in MongoDB: embedding vs referencing
• Wide-column modeling in Cassandra: partition and clustering keys
• Modeling for read-heavy vs write-heavy access patterns
• Designing indexes for query patterns, not just tables
• Search-optimized modeling with Elasticsearch inverted indexes
• Time-series and event data modeling
• Data modeling for a news feed / social graph
• Handling schema evolution and migrations at scale

Learn the core levers—caching, load balancing, and partitioning—that let a single-server design survive millions of users.

• Vertical vs horizontal scaling
• Back-of-the-envelope estimation: QPS, storage, bandwidth
• Load balancing algorithms: round robin, least connections, consistent hashing
• NGINX as reverse proxy and load balancer
• Caching strategies: cache-aside, write-through, write-back
• Redis for caching, sessions, and rate limiting
• CDN fundamentals and edge caching
• Database replication: leader-follower and multi-leader
• Sharding and partitioning strategies
• Consistent hashing for distributed caches
• CAP theorem and PACELC trade-offs
• Designing a rate limiter (token bucket, sliding window)
• Identifying and eliminating single points of failure

Choose and tune the right database engine for each workload so your architecture survives real interview follow-up questions.

• SQL vs NoSQL decision framework
• ACID transactions and isolation levels in PostgreSQL
• Indexing strategies: B-tree, hash, and composite indexes
• Query optimization and explain plans
• MongoDB replica sets and sharded clusters
• Cassandra's ring architecture and tunable consistency
• Read replicas, connection pooling, and failover
• Database partitioning: range, hash, and directory-based
• Handling hot partitions and rebalancing
• Caching layers with Redis in front of a database
• Eventual consistency vs strong consistency trade-offs
• Designing a key-value store from scratch
• Backup, disaster recovery, and multi-region replication

Design reliable service-to-service communication so features stay decoupled, resilient, and easy to evolve independently.

• REST vs gRPC vs GraphQL trade-offs
• Synchronous vs asynchronous communication patterns
• gRPC fundamentals: protobuf, streaming, deadlines
• Apache Kafka architecture: topics, partitions, brokers
• Producer/consumer semantics and consumer groups
• At-least-once, at-most-once, and exactly-once delivery
• Designing a distributed message queue
• Pub/sub vs point-to-point messaging patterns
• Event-driven architecture and event sourcing basics
• Webhooks and long polling vs WebSockets
• API gateway patterns with NGINX
• Designing a notification system (push, SMS, email fanout)
• Backpressure, dead-letter queues, and retry strategies

Architect systems that stay correct and available when networks partition, services crash, and traffic spikes unpredictably.

• Monolith vs microservices trade-offs
• Service decomposition and bounded contexts
• Service discovery and API gateways
• Containerization fundamentals with Docker
• Distributed consensus basics: Paxos and Raft intuition
• Leader election and heartbeat mechanisms
• Distributed transactions: two-phase commit and sagas
• Idempotency keys and exactly-once processing patterns
• Circuit breakers, retries, and timeout strategies
• Observability: distributed tracing, metrics, and logging
• Designing a unique ID generator (Snowflake-style)
• Handling cascading failures and graceful degradation
• Designing a distributed cache and a distributed lock
• Multi-region deployment and data residency trade-offs

Rehearse full end-to-end architectures on the exact case studies interviewers ask, so the real interview feels like a repeat.

• The system design interview framework: requirements, estimation, HLD, deep dive
• Designing a URL shortener end-to-end
• Designing a rate limiter for an API gateway
• Designing a news feed / social media timeline
• Designing a chat application (WhatsApp-style)
• Designing a ride-hailing / proximity service (Uber-style)
• Designing a video streaming platform (YouTube-style)
• Designing a web crawler and search autocomplete system
• Designing an e-commerce checkout and order system
• Designing a real-time leaderboard and notification system
• Trade-off articulation: consistency vs availability vs latency
• Mock interview structure and time management (45-minute rounds)
• Common interviewer follow-ups and how to handle unknowns
• Practicing full mocks on KodPrep Practice with peer feedback