Locker Management System

Design a Locker Management System for warehouse packages with size-based assignment, state management, access control, and multi-location support.

What is the Locker Management System Problem?

Design a Locker Management System for warehouse packages that assigns packages to available lockers based on size, manages locker states (Available, Occupied, Out of Order), generates secure access codes for package pickup, notifies recipients when packages are stored, handles package expiration and cleanup, supports searching by tracking number/recipient/locker number, and operates across multiple warehouse locations.

In this problem, you’ll design a system that efficiently manages package storage and retrieval using lockers of various sizes, while incorporating key design patterns to ensure scalability, maintainability, and flexibility.

Problem Overview

Design a comprehensive system that manages warehouse lockers for package storage, ensuring efficient space utilization, secure access, and automated expiration handling.

Core Requirements

Functional Requirements:

Locker Assignment: Assign incoming packages to available lockers based on package size and locker availability.
Locker Sizes: Manage lockers of different sizes (Small, Medium, Large, XL) and match packages to appropriate locker sizes.
Access Control: Generate unique, secure access codes (6-digit alphanumeric) when packages are assigned to lockers.
Locker States: Track locker states (Available, Occupied, Out of Order) and manage state transitions properly.
Notification: Notify recipients when their packages are stored, providing locker number and access code.
Expiration: Handle package expiration (e.g., 7 days) and automatically release expired packages and their lockers.
Search: Support searching for packages by tracking number, recipient information (name/email), or locker number.
Multi-location: Support multiple warehouse locations, with each location having its own set of lockers.
Retrieval: Allow recipients to retrieve packages using the access code.
Maintenance: Allow staff to mark lockers as Out of Order and restore them to Available state.

Non-Functional Requirements:

Object-Oriented Design: Clear separation of concerns with well-defined roles for each class.
Modularity: Easy to add new locker sizes, assignment strategies, or notification methods without modifying existing code.
Thread Safety: Package assignment, retrieval, and state transitions must be safe from race conditions.
Performance: Efficient locker assignment and search operations even with large numbers of lockers and packages.
Maintainability: Core locker management logic should be robust, testable, and maintainable over time.
State Management: Locker state management should be robust and prevent invalid state transitions.

What’s Expected?

1. System Architecture

The system manages multiple warehouses, each with its own set of lockers. Packages are assigned to lockers based on size matching strategies.

2. Key Classes to Design

classDiagram
    class LockerManagementSystem {
        -Map~String,Warehouse~ warehouses
        -Map~String,Locker~ lockers
        -Map~String,Package~ packages
        +storePackage(Package, String) String
        +retrievePackage(String, String) Package
        +searchByTrackingNumber(String) Package
    }
    
    class Locker {
        -LockerState state
        -Package pkg
        -String accessCode
        +assignPackage(Package) boolean
        +releasePackage(String) Package
    }
    
    class LockerState {
        <<interface>>
        +assignPackage(Locker, Package) boolean
        +releasePackage(Locker, String) Package
    }
    
    class LockerAssignmentStrategy {
        <<interface>>
        +assignLocker(Package, List~Locker~) Locker
    }

    LockerManagementSystem --> Locker
    Locker --> LockerState
    LockerManagementSystem --> LockerAssignmentStrategy
    LockerState <|.. AvailableState
    LockerState <|.. OccupiedState
    LockerAssignmentStrategy <|.. SmallestFitStrategy

System Flow

Package Storage Flow (State Transitions)

Package Retrieval Flow

Key Design Challenges

1. Managing Locker States

Lockers can be in three states: Available, Occupied, or Out of Order. Each state has different allowed operations.

Solution: Use the State Pattern. Create state classes (AvailableState, OccupiedState, OutOfOrderState) that encapsulate state-specific behavior. The Locker class delegates all operations to its current state object, eliminating complex if-else chains.

2. Matching Packages to Lockers

A small package can fit into small, medium, large, or XL lockers, but we want to optimize space by using the smallest available locker.

Solution: Use the Strategy Pattern. Create assignment strategy classes (SmallestFitStrategy, ExactMatchStrategy) that encapsulate different matching algorithms. The system can swap strategies at runtime without modifying existing code.

3. Access Control & Security

Recipients need secure access codes to retrieve packages. Codes must be unique, random, and validated.

Solution: Generate 6-character alphanumeric codes when packages are assigned. Store codes in lockers and validate them during retrieval. Clear codes after successful retrieval.

4. Package Expiration

Packages should expire after 7 days and be automatically released to free up lockers.

Solution: Track storedAt and expiresAt timestamps in packages. Use an ExpirationHandler that periodically checks for expired packages and releases them automatically.

What You’ll Learn

By solving this problem, you’ll master:

✅ State Pattern - Managing complex state transitions with clear behavior encapsulation.
✅ Strategy Pattern - Implementing flexible, swappable algorithms for package-to-locker matching.
✅ Factory Pattern - Creating objects without exposing creation logic.
✅ Access Control - Secure code generation and validation mechanisms.
✅ Multi-location Architecture - Managing distributed resources across locations.
✅ Thread Safety - Ensuring concurrent access safety with fine-grained locking.

View Complete Solution & Practice

Ready to see the full implementation? Open the interactive playground to access:

🎯 Step-by-step guidance through the 8-step LLD approach
📊 Interactive UML builder to visualize your design
💻 Complete Code Solutions in Python, Java, C++, TypeScript, JavaScript, C#
🤖 AI-powered review of your design and code

🚀 View Solution in Playground

After mastering the Locker Management System, try these similar problems:

Parking Lot System - Similar state management and space allocation challenges.
Vending Machine - State pattern and inventory management.
Car Rental System - State pattern, strategy pattern, and resource management.