---
type: "article"
title: "Introduction to System Design"
summary: "System Design often feels intimidating at first - big diagrams, fancy terms, and interviews that expect you to “just know” how large systems are built.\nThis blog series is my attempt to make Low-Level System Design (LLD) simple, practical, and approa..."
newsletter: "Engineering With Ashmit"
newsletter_handle: "engineeringwithashmit"
newsletter_url: "https://usecommune.com/n/engineeringwithashmit"
author: "Ashmit JaiSarita Gupta (@ashmitjsg)"
published: "2026-01-27T16:50:33.611Z"
canonical_url: "https://usecommune.com/n/engineeringwithashmit/a/introduction-to-system-design"
markdown_url: "https://usecommune.com/n/engineeringwithashmit/a/introduction-to-system-design.md"
chat_url: "https://usecommune.com/n/engineeringwithashmit/a/introduction-to-system-design/chat"
source_url: "https://engineeringwithashmit.hashnode.dev/introduction-to-system-design"
body_source: "imported"
likes: 0
replies: 0
body_words: 647
---

# Introduction to System Design

System Design often feels intimidating at first - big diagrams, fancy terms, and interviews that expect you to “just know” how large systems are built.

This [blog series](https://engineeringwithashmit.hashnode.dev/series/low-level-system-design) is my attempt to **make Low-Level System Design (LLD) simple, practical, and approachable**, especially for **freshers and undergrad students**.

Most of the concepts shared here are based on my learning from [Rohit Negi and Aditya Tandon’s “Low-Level Design (LLD) Masterclass” on YouTube](https://youtube.com/playlist?list=PLQEaRBV9gAFvzp6XhcNFpk1WdOcyVo9qT&si=67cXAzKxfb0zQf5j), combined with my own notes and understanding.

This series is for you if:

- You want a **quick and structured revision** of LLD concepts
- Long video courses feel hard to follow (language, pace, or time issues)
- You’re starting **system design from scratch** and want clarity
- You’re preparing for **SDE interviews** and want strong fundamentals

I’ll be publishing a new article **every 1–2 weeks**, keeping things crisp and focused.

> If you find this useful, consider **liking the blog and subscribing to the newsletter** so you don’t miss upcoming posts.

## Low‑Level Design (LLD)

Low-Level Design focuses on the **internal structure of an application**.

It answers questions like:

- What classes should exist?
- How do objects interact with each other?
- How does data flow inside the system?
- Where do algorithms and data structures fit into the code?

In simple terms:

> **LLD is about how your code is organised internally.**

It covers:

- class design
- object relationships
- interfaces and abstractions
- clean separation of responsibilities

### Core Principles of Low-Level Design

LLD mainly focuses on three things:

**1. Scalability**

- The system should handle **large numbers of users** easily
- Code structure should allow **easy expansion** (new features, more servers, new requirements)

**2. Maintainability**

- Adding new features should **not break existing functionality**
- Code should be easy to **debug, read, and modify**

**3. Reusability**

- Write **loosely coupled, plug-and-play modules**
- Example:

  - a notification system
  - a matching or recommendation algorithm

These can be reused across apps like **Zomato, Swiggy, Amazon Delivery**, etc.

## **High-Level Design (HLD)**

While LLD focuses on code structure, **High-Level Design (HLD)** focuses on the **big picture -** the **overall system architecture**.

HLD deals with:

- overall system architecture
- interaction between major components
- tech stack choices
- database selection (SQL / NoSQL / Hybrid)
- scaling strategies (load balancers, auto-scaling)
- deployment and cloud cost optimisation (AWS / GCP)

In short:

> **HLD explains how the entire system works at scale.**

## DSA vs LLD vs HLD (Quick Summary)

|   |   |   |
| --- | --- | --- |
| **DSA** | **LLD** | **HLD** |
| Brain of an application | Skeleton of the application | Architecture of the application |
| Algorithms that solve specific problems efficiently | Classes, object models, code structure, and where algorithms fit | Servers, databases, infrastructure, tech stack, and scaling |

All three are important—and they work best **together**.

## **What’s Ahead**

Before diving into **LLD design patterns**, we need a **standard and structured way** to represent our designs. In the industry, designs are often explained using **simple, well-defined diagrams** that everyone understands. This is where **Unified Modelling Language (UML)** comes in.

UML is a **general-purpose modelling language** used to visually represent system designs.
Its goal is to provide a **standard way to visualise how a system is built**, similar to blueprints in civil or mechanical engineering.

In the **next article**, I will deep-dive into **UML diagrams**, explain their different types and components, and show how they help us represent system design concepts clearly—so that we can discuss and apply **design patterns efficiently**.

## Final Note

If you’re learning system design or preparing for interviews, you’re not alone—it *does* take time.
The goal of this series is to **build strong fundamentals step by step**, without overcomplicating things.

Feel free to drop questions or feedback in the comments—I’ll try to address them in future posts.

***

## Discussion

No replies yet.