Program to interface not implementation in LLD - System Design Exercise

Design: Interface-based Modular System

Focus on designing the architecture and interaction patterns that enforce programming to interfaces. Implementation details of specific components are out of scope.

Functional Requirements

FR1: Design a system where components interact only through defined interfaces, not concrete implementations

FR2: Allow easy replacement or upgrade of components without affecting others

FR3: Support multiple implementations of the same interface

FR4: Ensure components are loosely coupled and highly maintainable

Non-Functional Requirements

NFR1: System should handle up to 1000 concurrent component interactions

NFR2: Response time for component communication should be under 100ms

NFR3: System availability target is 99.9% uptime

NFR4: Design must be language-agnostic and support future technology changes

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Interface definitions or contracts

Component implementations

Dependency injection or service locator

Interface registries or repositories

Communication protocols between components

Design Patterns

Dependency Injection

Service Locator

Adapter Pattern

Facade Pattern

Strategy Pattern

Reference Architecture

  +-------------------+       +-------------------+       +-------------------+
  |   Component A     |       |   Component B     |       |   Component C     |
  |  (implements IA)  |       |  (implements IB)  |       |  (implements IA)  |
  +---------+---------+       +---------+---------+       +---------+---------+
            |                           |                           |
            |                           |                           |
            |                           |                           |
            |                           |                           |
  +---------v---------------------------v---------------------------v---------+
  |                          Interface Registry / Injector                      |
  |  - Holds interface definitions and implementations                         |
  |  - Provides components with interface references                           |
  +-----------------------------------------------------------------------------+

Components

Interface Definitions

IDL (Interface Definition Language) or abstract classes

Define contracts that components must follow without specifying implementation

Component Implementations

Any programming language or module

Concrete classes or modules that implement the interfaces

Interface Registry / Injector

Dependency Injection framework or service locator pattern

Manages interface implementations and injects them into components at runtime

Communication Layer

In-process calls, RPC, or messaging depending on deployment

Facilitates interaction between components via interfaces

Request Flow

1. 1. Component requests an interface reference from the Interface Registry.

2. 2. Interface Registry returns a reference to a concrete implementation of the requested interface.

3. 3. Component interacts with the implementation only through the interface methods.

4. 4. If a new implementation is deployed, Interface Registry updates the reference without changing the component.

5. 5. Components remain unaware of the concrete classes, relying solely on interface contracts.

Database Schema

Not applicable as this design focuses on interface-based component interaction rather than data storage.

Scaling Discussion

Bottlenecks

Interface Registry becoming a single point of failure or performance bottleneck

Complexity in managing multiple interface versions and backward compatibility

Overhead of dependency injection in large-scale systems

Difficulty in debugging due to abstraction layers

Solutions

Distribute Interface Registry or use caching to reduce load and increase availability

Implement versioning strategies and interface evolution policies

Optimize dependency injection with compile-time injection or lightweight containers

Use logging, tracing, and monitoring tools to improve observability

Interview Tips

Time: Spend 10 minutes understanding and clarifying requirements, 20 minutes designing the interface-based architecture, and 15 minutes discussing scaling and trade-offs.

Explain the importance of programming to interfaces for loose coupling and flexibility

Describe how dependency injection or service locator patterns help manage implementations

Discuss how multiple implementations can coexist and be swapped without affecting clients

Highlight how this design supports maintainability and scalability

Mention potential challenges and how to mitigate them