KISS (Keep It Simple) in LLD - System Design Exercise

Design: Simple Task Management System

Design focuses on core task management features with simple architecture. Authentication and notifications are out of scope.

Functional Requirements

FR1: Users can create, update, and delete tasks

FR2: Tasks have a title, description, and status (todo, in-progress, done)

FR3: Users can view a list of their tasks

FR4: The system should be easy to understand and maintain

Non-Functional Requirements

NFR1: Handle up to 1000 users concurrently

NFR2: API response time p99 under 300ms

NFR3: Availability target 99.5% uptime

NFR4: Keep the design minimal and avoid unnecessary complexity

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

API server for task operations

Simple database for storing tasks

Basic client interface or API consumer

Design Patterns

CRUD (Create, Read, Update, Delete) pattern

Single responsibility principle

Minimal layered architecture

Reference Architecture

Client
  |
  v
API Server
  |
  v
Simple Database

Components

Client

Any frontend or API consumer

Send requests to create, update, delete, and list tasks

API Server

Lightweight REST API (e.g., Flask, Express)

Handle task operations with simple endpoints

Simple Database

Relational DB like SQLite or PostgreSQL

Store tasks with minimal schema

Request Flow

1. Client sends HTTP request to API server to create or update a task

2. API server validates request and performs operation on database

3. Database stores or updates task record

4. API server sends response back to client confirming success or failure

5. Client requests list of tasks; API server queries database and returns results

Database Schema

Task(id PK, user_id FK, title VARCHAR, description TEXT, status ENUM('todo','in-progress','done'), created_at TIMESTAMP, updated_at TIMESTAMP)

Scaling Discussion

Bottlenecks

Single API server may become overloaded with many users

Database can slow down with large number of tasks

Simple design may lack advanced features needed later

Solutions

Add load balancer and multiple API servers for horizontal scaling

Use database indexing and optimize queries; consider read replicas

Keep design modular to add features without complexity

Interview Tips

Time: 10 min for requirements and clarifications, 20 min for design and data flow, 15 min for scaling and trade-offs

Emphasize simplicity and maintainability

Explain how minimal components meet requirements

Discuss trade-offs of simple design versus future needs

Show understanding of scaling basics without overcomplicating