logoNEURAL COOK
SearchAll PostsTagsNotesAuthor
instagramtwitterfacebookyoutubelinkedinmailgithubrss
Copyright © 2026 All rights reserved.
•
VIKI
Built with Vikramaditya Singh
Built with
VIKI - A posts created with Next.js and Tailwind.css
About
Composition, Asociation & Aggregation
Database locking / atomic updates
The Four Pillars of OOP
60-Day LLD & Machine Coding Mastery Roadmap
Class Design
Advanced Class Design & Robust Architecture
Clean Code
Don't Repeat Yourself (DRY) Principle
Keep it Simple, Stupid (KISS) Principle
You Aren't Gonna Need It (YAGNI) Principle
Design Patterns
Design pattern
Problems
Design a Library Management System (LMS)
Design a Parking Lot
Vending Machine
SOLID
D : Dependency Inversion
I : The Interface Segregation Principle
The SOLID Foundation
L : The Liskov Substitution Principle
O : The Open/Closed Principle
S : The Single Responsibility Principle
UML
UML Activity Diagrams: Modeling Process and Workflow
UML Class Diagrams: Static Structure Modeling
Unified Modeling Language (UML): Comprehensive Guide
UML Sequence Diagrams: Modeling Dynamic Interactions
Use Case Diagrams: Functional Requirement Modeling
Low Level Design

60-Day LLD & Machine Coding Mastery Roadmap

DayProblemConcepts to Learn
1Parking LotEncapsulation, abstraction, interfaces, inheritance vs composition, SRP, Factory, Strategy, class relationships
2Vending MachineState machines, State pattern, transitions, invariants, enum vs State objects, validation
3ATMTransaction boundaries, State, Chain of Responsibility, error handling, hardware/business logic separation
4Elevator SystemControllers, scheduling Strategy, state, command queues, extensible algorithms
5ChessPolymorphism, OCP, inheritance vs composition, legal moves, Command and undo
6Splitwise / Expense SharingSOLID, dependency injection, Strategy, value objects, rounding, money invariants
7Library ManagementEntities vs value objects, Book vs BookCopy, Repository abstraction, lending lifecycle
8Car RentalFactory, Strategy, reservation lifecycle, interface segregation, dependency inversion
9Notification FrameworkStrategy, Factory, Adapter, Observer, provider abstraction, test doubles
10Food Delivery / Order ManagementAggregate boundaries, composition, state transitions, events, immutable price snapshots
11Movie Ticket BookingSeat inventory, holds, pricing Strategy, atomic reservation
12Meeting Room BookingInterval overlap, recurrence, availability, concurrency, conflict prevention
13Doctor Appointment BookingScheduling, rescheduling, cancellation, idempotency, reminders
14Hotel ReservationRoom types vs physical rooms, date ranges, pricing policies, cancellation
15Flight Booking & Seat AssignmentFlight segments, seat maps, multi-leg bookings, inventory consistency
16E-commerce Cart & CheckoutCart vs Order, immutable price snapshots, checkout orchestration, transactions
17Payment ProcessingState, Strategy, Adapter, idempotency keys, duplicate callbacks, refunds, compensation
18Coupon & Promotion EngineStrategy, Chain of Responsibility, rule composition, priorities, conflicting discounts
19Subscription BillingBilling lifecycle, proration, retries, failed payments, time-based operations
20Ride SharingMatching Strategy, fare calculation, driver assignment, state transitions, events
21In-memory File SystemComposite, tree modeling, recursion, path resolution
22Organization Directory / File ExplorerComposite, Iterator, recursive traversal, filtering
23Logger FrameworkChain of Responsibility, Decorator, Strategy, asynchronous logging
24Configuration ManagementAdapter, Observer, configuration precedence, validation
25Metrics Collection LibraryFactory, Template Method, Strategy, thread safety, efficient APIs
26LRU CacheHashMap + doubly linked list, O(1) operations, invariants, encapsulation
27LFU CacheFrequency buckets, eviction rules, data structure invariants
28In-memory Key-Value Store with TTLExpiration, lazy vs eager cleanup, clock abstraction, atomic operations
29Rate LimiterStrategy, Token Bucket, Sliding Window, concurrent counters
30Pub-Sub Message BrokerObserver, subscriptions, acknowledgments, delivery semantics, retries, backpressure
31Thread PoolProducer-Consumer, worker lifecycle, bounded queues, shutdown, rejection
32Thread-safe Blocking QueueMutexes, condition variables, wait/notify, bounded buffers, spurious wakeups
33Read-Write LockMutual exclusion, fairness, starvation, lock semantics
34Concurrent LRU CacheAtomic compound operations, critical sections, lock granularity, deadlocks
35Task SchedulerPriority queues, delayed jobs, worker pools, retries, cancellation
36Job Orchestration EngineDAG dependencies, parallel execution, failure propagation, task states
37VM Upgrade SchedulerBounded concurrency, atomic task claims, leases, retries, health checks, rollback
38Distributed Lock / Lease ManagerExpiry, ownership tokens, fencing tokens, stale owners, safe release
39Concurrent Ticket / Inventory ReservationRace conditions, atomic holds, expiry, double booking, idempotency
40Parallel Batch Processing EngineTask decomposition, partitioning, Fork-Join, backpressure, cancellation, partial failure
41Tic-Tac-ToeGame engine, board abstraction, polymorphism, validation, extensible rules
42Snake and LadderBoard, dice abstraction, turn management, deterministic tests
43Connect FourBoard state, move validation, win detection, rule encapsulation
44Card Game / BlackjackDeck, Hand, Card value objects, polymorphism, lifecycle
45Task Management / Kanban BoardEntities, state transitions, filtering/sorting Strategy, notifications
46Shopping Cart with Multiple Pricing RulesDecorator, Strategy, discount composition, tax, money precision
47Text Editor with Undo/RedoCommand, Memento, history stacks, snapshots vs reversible operations
48Spreadsheet EngineCell dependencies, Observer, dependency graph, recalculation, cycle detection
49Search & Filtering FrameworkSpecification pattern, composable predicates, sorting, pagination
50Workflow / Rules EngineState, Strategy, Chain of Responsibility, rule evaluation, configurable workflows
51API Client / SDK FrameworkAdapter, Builder, Decorator, middleware, request/response abstractions
52Resilient Service ClientRetries, exponential backoff, timeouts, circuit breaker, bulkhead, fallback
53File Synchronization EngineConflict-resolution Strategy, versioning, checksums, incremental updates
54In-memory Database with TransactionsUnit of Work, Command, rollback, isolation concepts
55Dependency Injection ContainerObject graphs, Factory, constructor injection, lifecycle scopes
56Extensible Plugin FrameworkPlugin contracts, Factory/Registry, Adapter, lifecycle, Open/Closed Principle
57Event Processing EngineRouting, filters, ordering, retries, duplicate delivery, idempotent handlers
58Resource / Connection PoolBounded resources, reuse, timeouts, validation, safe return, shutdown

# 60-Day LLD Plan (1 problem/day) — Java

DayPhaseProblemConcepts it teaches
1FoundationsParking LotRequirements gathering, SRP, OCP, Strategy (pricing, spot allocation), Factory, enums vs polymorphism
2FoundationsTic-Tac-ToeEncapsulation, O(1) win detection, generalizing to NxN, player abstraction
3FoundationsVending MachineState pattern, illegal transitions, replacing if/else chains
4FoundationsLibrary ManagementEntity modeling, composition over inheritance, Repository, Observer (due-date alerts)
5FoundationsSnake and LadderFactory, Strategy (dice), Builder (board config), separating game rules from game loop
6FoundationsCoffee MachineDecorator (add-ons), Template Method (brew steps), recipes as data, Builder
7FoundationsATMState, Chain of Responsibility (cash dispensing), Liskov Substitution
8FoundationsTraffic SignalState with timers, Observer, scheduling basics
9FoundationsLogging FrameworkSingleton (and pitfalls), Chain of Responsibility, appenders, Factory, thread-safe init
10FoundationsNotification ServiceStrategy, Bridge, Adapter, retries, Interface Segregation, Dependency Inversion
11Pattern-heavy domainsSplitwiseStrategy (split types), BigDecimal money, debt simplification graph
12Pattern-heavy domainsElevator SystemState, SCAN/LOOK scheduling, Command, Observer
13Pattern-heavy domainsChessPolymorphism, Template Method, Flyweight, Command (move undo), move validation
14Pattern-heavy domainsText EditorCommand, Memento, undo/redo stacks, Flyweight
15Pattern-heavy domainsShopping Cart and PricingDecorator and Strategy for discounts, Chain of Responsibility, value objects
16Pattern-heavy domainsCoupon and Promotion Rules EngineSpecification, Composite rules, Interpreter-style rule evaluation
17Pattern-heavy domainsMovie Ticket BookingSeat holds with TTL, State, first concurrency hazards (double booking)
18Pattern-heavy domainsHotel and Flight BookingDate-range overlap, inventory modeling, reservation lifecycle
19Pattern-heavy domainsCar RentalBuilder, pricing strategies, availability search, Specification filters
20Pattern-heavy domainsFood DeliveryOrder lifecycle (State), Observer, Strategy for agent assignment
21Pattern-heavy domainsRide SharingStrategy (matching, pricing), State, Observer, geo abstractions
22Pattern-heavy domainsDigital WalletLedger design, immutability, idempotency keys, Command
23Pattern-heavy domainsPayment GatewayAdapter, Facade, Strategy routing, retries, idempotency
24Pattern-heavy domainsOrder Matching EnginePriority queues, price-time priority, Strategy, Observer (trade events)
25Pattern-heavy domainsOnline AuctionObserver, Template Method, concurrent bids, closing rules
26Frameworks and infraSocial FeedObserver, Iterator, Strategy (ranking), pagination design
27Frameworks and infraChat ApplicationMediator, Observer, State (message status), Composite (groups)
28Frameworks and infraPub-Sub SystemGenerics, topic registry, subscriber isolation, Observer done right
29Frameworks and infraFile SystemComposite, Iterator, Visitor (size, search), path handling
30Frameworks and infraLinux findSpecification, fluent API design, Visitor, Composite
31Frameworks and infraSpreadsheetDependency graph, topological sort, cycle detection, Observer
32Frameworks and infraIn-Memory KV Store with TTL and TransactionsNested transactions, Memento or Command, lazy vs active expiry
33Frameworks and infraLRU CacheHashMap + doubly linked list, generics, API design
34Frameworks and infraLFU and Pluggable EvictionStrategy, policy abstraction, O(1) LFU
35Frameworks and infraRate LimiterStrategy (token bucket, sliding window), Factory, per-key state
36Frameworks and infraMiddleware PipelineChain of Responsibility, Decorator, Proxy, ordering and short-circuiting
37Frameworks and infraFeature Flags and Config ManagerObserver (hot reload), Proxy, Singleton vs DI, immutable snapshots
38Frameworks and infraDI ContainerReflection, Registry, Factory, Abstract Factory, Dependency Inversion in depth
39Frameworks and infraWorkflow and State Machine EngineState, Strategy, Builder DSL, guards and transitions
40Frameworks and infraDocument and Report GeneratorBuilder, Visitor, Template Method, Bridge (PDF/HTML/DOCX), Prototype
41ConcurrencyProducer-Consumer and Blocking QueueMonitors, wait/notify, ReentrantLock + Condition, bounded buffers
42ConcurrencyFooBar, Zero-Even-Odd and H2OThread ordering, Semaphore, CyclicBarrier, CountDownLatch
43ConcurrencyDining PhilosophersFour deadlock conditions, lock ordering, tryLock, starvation
44ConcurrencyCustom Thread PoolWorker lifecycle, task queue, rejection policy, graceful shutdown, Future
45ConcurrencyRead-Write Lock, Semaphore and Latch from ScratchFairness, reentrancy, how AQS-style synchronizers work
46ConcurrencyThread-Safe Cache with TTLConcurrentHashMap, lock striping, cleanup threads, memory visibility
47ConcurrencyJob SchedulerCron and delay scheduling, DelayQueue, priorities, retry with backoff
48ConcurrencyDAG Task ExecutorDependency resolution, parallel execution, CompletableFuture, failure propagation
49ConcurrencyIn-Memory Message QueuePartitions, consumer groups, offsets, concurrent producers/consumers
50ConcurrencyOverselling-Proof Inventory and TicketingPessimistic vs optimistic locking, CAS, versioning, AtomicInteger, LongAdder
51ConcurrencyBank TransfersAtomicity, deadlock-free multi-lock acquisition, consistency invariants
52ConcurrencyParallel Web Crawler and Fork/Join Merge SortWork stealing, thread-safe visited sets, parallel streams and pitfalls
53ConcurrencyCircuit Breaker and Retry LibraryState, Decorator, sliding-window metrics, atomics
54ConcurrencyAsync Pipeline and Mini Actor FrameworkCompletableFuture composition, message passing, backpressure, mailboxes
55ConcurrencyMetrics LibraryLock-free counters, histograms, Observer, low-contention design
56Staff capstonesRBAC and PermissionsProxy, Composite roles, policy evaluation, clean authorization API
57Staff capstonesAudit Log and Event SourcingImmutable events, Command, replay, CQRS-lite at class level
58Staff capstonesMini-GitComposite, content hashing, commit DAG, Memento, branching
59Staff capstonesMulti-Tenant SaaS BillingMany patterns together, money and proration, extensibility, plugin-style pricing plans
60Staff capstonesFinal Mock DayTimed 45-min mock on an unseen problem (e.g., Calendar/Meeting Scheduler), then redo Parking Lot and compare with Day 1
61Inventory with Optimistic Locking (standalone)Version columns, CAS, retry with exponential backoff and jitter, when to pick optimistic vs pessimistic techinterview+1
62Chunked File UploadUpload session state machine, chunk manifest, idempotent part IDs, resumable transfers, checksum validation, parallel chunk upload techinterview+2
63Sync Cursor Design (offline-first sync)Cursor/version vectors, delta sync, conflict detection, last-write-wins vs merge, tombstones for deletes
64Collaborative Document Editing with OTInsert/Delete operations, transform function, server as ordering authority, operation log, snapshotting every N ops techinterview+1
65Real-Time Presence and Cursor SyncEphemeral cursor events over pub/sub, throttling to ~10 Hz, cursor adjustment after remote ops applied techinterview+2
66CRDT vs OT comparison designCharacter-level vs operation-level CRDTs, causal context, convergence guarantees, when to pick CRDT over OT techinterview+1
PreviousThe Four Pillars of OOPNextAdvanced Class Design & Robust Architecture