Backend Engineering Foundations

A structured visual guide to Backend Engineering, System Design, Distributed Systems, Low Level Design, Databases, and Backend Security.

https://github.com/user-attachments/assets/9f99dac6-4dfe-4012-ab8f-3a70f4baa2d8

---

Learn backend engineering through structured visual diagrams designed for learning, revision, and interview preparation.

Related Repositories

Networks Foundation
https://github.com/100NikhilBro/networks-foundation

OS & DBMS Foundation
https://github.com/100NikhilBro/os_dbms

Node.js Scaling Lab
https://github.com/100NikhilBro/nodejs-scaling-lab

DevContainer Lab
https://github.com/100NikhilBro/devcontainer-lab

---

Purpose

This repository serves as a visual reference for:

• Backend Engineering Fundamentals
• Low Level Design (LLD)
• Object-Oriented Design (OOD)
• SOLID Principles
• Design Patterns
• System Design
• Distributed Systems
• Networking
• Database Internals
• Security Fundamentals
• Scalability & Reliability Patterns
• Technical Interview Preparation

---

Table of Contents

• Low Level Design (LLD)
• System Design & Backend
• Security
• SQL
• Ongoing Work
• Author

---

Low Level Design (LLD)

Contents

No.	Diagram
1	Approach to Solving a Design Problem
2	Coupling & Cohesion
3	Object vs Class
4	Four Pillars of OOP
5	Relationships in Object-Oriented Design
6	SOLID Principles Overview
7	Single Responsibility Principle (SRP)
8	Open Closed Principle (OCP)
9	Liskov Substitution Principle (LSP)
10	Interface Segregation Principle (ISP)
11	Dependency Inversion Principle (DIP)
12	Singleton Pattern
13	Factory Pattern
14	Builder Pattern
15	Adapter Pattern
16	Strategy Pattern
17	Observer Pattern
18	Decorator Pattern
19	Facade Pattern

---

Approach to Solving a Design Problem

Coupling & Cohesion

Object vs Class

Four Pillars of OOP

Relationships in Object-Oriented Design

SOLID Principles Overview

Single Responsibility Principle (SRP)

Open Closed Principle (OCP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Dependency Inversion Principle (DIP)

---

Singleton Pattern

Factory Pattern

Builder Pattern

Adapter Pattern

Strategy Pattern

Observer Pattern

Decorator Pattern

Facade Pattern

---

System Design & Backend

Contents

No.	Diagram
1	AWS Frequently Used Services Overview
2	AWS Single Instance Deployment (Basic Overview)
3	Proxy
4	API Gateway & Load Balancer
5	Load Balancer Overview
6	Load Balancer Types (L4, L7, Active-Active, Active-Passive)
7	Load Balancing Algorithms
8	Content Delivery Network (CDN)
9	Caching
10	Rate Limiting
11	Rate Limiting Algorithms
12	Backpressure
13	Queue
14	Retry Mechanism
15	Circuit Breaker Pattern
16	Bulkheads Pattern
17	Failover
18	Failure Handling
19	Graceful Degradation
20	Concurrency vs Parallelism
21	Processes & Threads
22	Consistency Models
23	Consistency in NoSQL
24	PACELC Theorem
25	Consistent Hashing
26	Bloom Filter
27	Merkle Tree
28	Gossip Protocol & Database Failures
29	Leader Election
30	Quorum Algorithm
31	Raft Consensus Algorithm - Part 1
32	Raft Consensus Algorithm - Part 2
33	Raft Consensus Algorithm - Part 3
34	Raft Consensus Algorithm - Part 4
35	Distributed Lock
36	Federation
37	HTTP Fundamentals - Part 1
38	HTTP Fundamentals - Part 2
39	Remote Procedure Call (RPC)
40	Server-Sent Events (SSE) & Webhooks
41	API Versioning
42	Event Driven Architecture
43	Payment Gateway Overview
44	SQL Architecture
45	Write-Ahead Logging & Database Recovery
46	Isolation Levels & Locking
47	Why Backend Shouldn't Serve Static Files

---

AWS Frequently Used Services Overview

AWS Single Instance Deployment (Basic Overview)

Proxy

API Gateway & Load Balancer

Load Balancer Overview

Load Balancer Types (L4, L7, Active-Active, Active-Passive)

Load Balancing Algorithms

Content Delivery Network (CDN)

Caching

Rate Limiting

Rate Limiting Algorithms

Backpressure

Queue

Retry Mechanism

Circuit Breaker Pattern

Bulkheads Pattern

Failover

Failure Handling

Graceful Degradation

Concurrency vs Parallelism

Processes & Threads

Consistency Models

Consistency in NoSQL

PACELC Theorem

Consistent Hashing

Bloom Filter

Merkle Tree

Gossip Protocol & Database Failures

Leader Election

Quorum Algorithm

Raft Consensus Algorithm - Part 1

Raft Consensus Algorithm - Part 2

Raft Consensus Algorithm - Part 3

Raft Consensus Algorithm - Part 4

Distributed Lock

Federation

HTTP Fundamentals - Part 1

HTTP Fundamentals - Part 2

Remote Procedure Call (RPC)

Server-Sent Events (SSE) & Webhooks

API Versioning

Event Driven Architecture

Payment Gateway Overview

SQL Architecture

Write-Ahead Logging & Database Recovery

Isolation Levels & Locking

Why Backend Shouldn't Serve Static Files

---

Security

Contents

No.	Diagram
1	Authentication vs Authorization
2	Cookies, Sessions & Replay Attacks
3	Browser Security
4	Privilege Escalation, CSRF, XSS & Injection Attacks

---

Authentication vs Authorization

Cookies, Sessions & Replay Attacks

Browser Security

Privilege Escalation, CSRF, XSS & Injection Attacks

---

SQL

Contents

No.	Diagram
1	Subqueries
2	CTEs & Views
3	SQL Comparison - Subquery vs CTE vs Temp Table vs CTAS vs Views
4	Window Functions
5	Regular Expressions
6	Database Indexing
7	Clustered vs Non-Clustered Indexes

---

Subqueries

CTEs & Views

SQL Comparison - Subquery vs CTE vs Temp Table vs CTAS vs Views

Window Functions

Regular Expressions

Database Indexing

Clustered vs Non-Clustered Indexes

---

Ongoing Work

New concepts, diagrams, and improvements are added regularly as the repository evolves. If this repository adds value to your learning journey, a ⭐ is always appreciated.

Author

Built and maintained by Nikhil Gupta.