Relationships (association, aggregation, composition) in LLD - System Design Exercise

Design: Object Relationship Modeling System

In scope: Modeling and managing object relationships with association, aggregation, and composition. Out of scope: Complex inheritance hierarchies, UI design beyond basic visualization.

Functional Requirements

FR1: Model different types of relationships between objects: association, aggregation, and composition

FR2: Allow creation, update, and deletion of objects and their relationships

FR3: Visualize relationships clearly to distinguish their types

FR4: Support querying objects based on their relationships

Non-Functional Requirements

NFR1: Handle up to 10,000 objects and 50,000 relationships

NFR2: Response time for queries should be under 200ms

NFR3: System availability should be 99.9%

NFR4: Data consistency must be maintained for relationship updates

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Object storage (database or in-memory)

Relationship manager module

API layer for CRUD operations

Visualization component

Query engine

Design Patterns

Composite pattern for composition relationships

Graph data modeling for relationships

Observer pattern if lifecycle events need tracking

Repository pattern for data access abstraction

Reference Architecture

  +-------------------+       +---------------------+
  |   API Layer       |<----->|  Relationship Manager|
  +-------------------+       +---------------------+
           |                            |
           v                            v
  +-------------------+       +---------------------+
  | Object Storage DB  |<----->|  Query Engine       |
  +-------------------+       +---------------------+
                                   |
                                   v
                          +---------------------+
                          | Visualization Layer  |
                          +---------------------+

Components

API Layer

RESTful API or GraphQL

Handles client requests to create, update, delete, and query objects and relationships

Relationship Manager

Backend service in chosen language

Manages logic for association, aggregation, and composition relationships including lifecycle rules

Object Storage DB

Relational DB (e.g., PostgreSQL) or Graph DB (e.g., Neo4j)

Stores objects and their relationships with appropriate schema

Query Engine

Custom query processor or DB query interface

Processes queries on objects and relationships efficiently

Visualization Layer

Frontend library (e.g., D3.js)

Displays objects and their relationships visually, distinguishing relationship types

Request Flow

1. Client sends request to API Layer to create or update an object or relationship

2. API Layer forwards request to Relationship Manager

3. Relationship Manager applies rules based on relationship type (e.g., composition enforces lifecycle dependency)

4. Relationship Manager updates Object Storage DB accordingly

5. For queries, API Layer sends query to Query Engine

6. Query Engine retrieves data from Object Storage DB and returns results

7. Visualization Layer fetches data via API and renders relationship graphs

Database Schema

Entities: - Object: id (PK), name, type, attributes - Relationship: id (PK), source_object_id (FK), target_object_id (FK), type (association, aggregation, composition) Relationships: - Object to Relationship is 1:N (one object can have many relationships) - Relationship links two Objects Composition enforces cascade delete from source to target objects

Scaling Discussion

Bottlenecks

Database performance with large number of objects and relationships

Query latency for complex relationship traversals

Visualization rendering performance for large graphs

Solutions

Use graph databases optimized for relationship queries to improve traversal speed

Implement caching for frequent queries to reduce DB load

Paginate and limit visualization data; use progressive rendering techniques

Partition data or use sharding for very large datasets

Interview Tips

Time: Spend 10 minutes understanding and clarifying requirements, 20 minutes designing components and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing

Explain differences between association, aggregation, and composition clearly

Describe how lifecycle dependencies are enforced in composition

Justify choice of database technology based on relationship queries

Discuss how to keep data consistent and performant at scale

Mention visualization challenges and solutions