System Design Course

92h 26m 21s
English
Paid

Course description

In this course, you’ll get a deep understanding of system design concepts. Full guide. Architectural schemes, capacity planning, API list, tests, Faq.

Read more about the course

On the course

  • Design a gmail-like mail system
    • routing client to server
    • We’re looking at services
    • authorized queries
    • Caching
    • decapling
  • Design an algorithm for an audio search engine like Shazam
    • mapping audio in key-values
    • pruning, transformation and chanking
    • Combinator’s hashes
    • Saving and Finding Heshovs
  • Rate-limiting algorithms
    • short-term fixes
    • distributed rate limiting
    • algorithms – sliding window, timer wheel
    • separating queues
    • Real optimization
  • Designing a call system. as whatsapp
    • PSTN and VOIP
    • Sip
    • charging users for a call
    • recommendation engine

Watch Online

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 288 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: What do we offer?

All Course Lessons (288)

#Lesson TitleDurationAccess
1
What do we offer? Demo
03:15
2
What are Databases?
04:40
3
Storage and Retrieval
04:25
4
What is a NoSQL database?
02:25
5
Types of Databases: Graph, TimeSeries and Object
02:16
6
What database should you choose?
02:13
7
What is Data Consistency?
01:31
8
Linearizable Consistency
03:14
9
Eventual Consistency
01:51
10
Causal Consistency
04:36
11
Quorum
06:30
12
Data Consistency Levels Tradeoffs
02:01
13
Transaction Isolation Levels - Read Uncommitted Data
03:13
14
Read Committed
03:44
15
Repeatable Reads
05:20
16
Serializable Isolation Level
02:01
17
Transaction Level Implementations
03:39
18
Conclusion - Transaction Isolation
00:52
19
Caching: Basics
06:29
20
Caching: Global vs. Local Cache
03:03
21
Global Cache Internals
06:32
22
Write Policies: Write Back Policy
04:36
23
Write Through Policy
02:34
24
Write Around Policy
03:24
25
Replacement Policies: LRU, LFU and Segmented LRU
11:15
26
Breakdown: The physical layer
02:59
27
Breakdown: The Routing Layer
03:20
28
Breakdown: The behavioral layer
04:40
29
Connecting to the internet: ISPs, DNS and everything in between
07:29
30
Internal routing: MAC addresses and NAT
06:53
31
HTTP, WebSockets, TCP and UDP
08:51
32
Communication Standards: REST, GraphQL and GRPC
07:18
33
Head of line blocking
05:16
34
Video transmission: WebRTC and HTTP-DASH
10:09
35
Primary Replica Architectures
03:07
36
WAL and Change Data Capture
04:02
37
Write Amplification and Split Brain
04:04
38
Database Migrations
10:12
39
Migrating the Database
07:50
40
Migration Across Regions
11:24
41
The Oracle and the Timer Wheel
15:54
42
Partitioning and Real-life Optimisations
11:43
43
Security aspects in distributed systems
03:46
44
Token Based Auth
09:11
45
SSO and OAuth
05:02
46
Access Control Lists and Rule Engines
06:21
47
Attack Vectors - Hackers, Developers and Code
04:53
48
How videos are protected inside CDNs
06:32
49
Design an algorithm for an Audio Search Engine
10:36
50
Introduction to design tradeoffs
03:59
51
Pull vs. Push Architectures
12:21
52
Memory vs. Latency
01:44
53
Throughput vs. Latency
08:42
54
Consistency vs. Availability
05:50
55
Latency vs. Accuracy
06:35
56
SQL vs. NoSQL databases
05:49
57
Relations Between Tradeoffs
06:02
58
The Problem of Distributed Consensus
05:29
59
Basic Algorithm
07:47
60
Improving the algorithm
02:58
61
Termination Conditions
07:17
62
Practical Considerations
03:37
63
Introduction to Observability
01:01
64
Logging - Best Practices
02:10
65
Monitoring Metrics
01:27
66
Anomaly Detection: Holt-Winters Algorithm
07:13
67
Root Cause Analysis
04:09
68
Conclusion to Observability
00:37
69
Scope and Requirement setting
00:22
70
Chapter #1: Service Registration and Proxies
14:32
71
Chapter #2: Authentication & Global Caching
09:27
72
Chapter #3: API contracts & Versioning
09:24
73
Chapter #4: Sending, Tagging & Searching Emails
06:05
74
Chapter #5: Contacts & Groups
07:18
75
Requirements of a chess website
11:37
76
Handling connections at scale
13:54
77
Consistent Hashing vs. Sharding
10:14
78
Connection related thundering herds
04:31
79
Request Batching and Conclusion
05:14
80
Live Streaming Requirement Breakdown
05:18
81
Video Ingestion and Transformation
05:09
82
Transferring processed videos to end users
07:55
83
Virtual Advertising for live sports events
07:20
84
Google Docs Requirements
05:53
85
Document Schema
05:42
86
Storing Documents
03:11
87
Version History
05:35
88
Avoiding Thundering Herds in Crons
03:12
89
Compression and Caching
02:48
90
Concurrent Writes with Locks
08:21
91
Operational Transform Overview
07:48
92
Permission Management
06:15
93
Requirements of a cab aggregator
06:43
94
Static Pricing of Rides
08:43
95
Ride Matching
09:05
96
Calculating Estimated Time of Arrival
12:26
97
Matching Drivers with Live Rides
09:53
98
Requirements of a Map application
08:11
99
Routing Challenges in Maps
06:47
100
Partitioning Algorithm: Splitting the graph into regions
05:12
101
Finding the shortest path - A* search
07:39
102
GeoHash and other proximity filters
06:26
103
Detecting traffic jams and broadcasting updates
09:46
104
Calculating an accurate and efficient estimated time of arrival
09:56
105
Calling App Design
14:13
106
Concept #1: Breaking calls into dialogs
06:58
107
Concept #2: The state machine
03:23
108
Concept #3: Charging Users
04:03
109
Concept #4: Consistent Hashing for caching call state
06:19
110
Converting data sources to a lake
06:04
111
The Map Reduce Architecture
03:33
112
Fault tolerance and engineering optimizations
03:04
113
Real time analytics
05:44
114
Ranking restaurants in real time and batch
02:53
115
Introduction to Low Level Design Series
02:22
116
The need for good coding practices
04:08
117
Setting Requirements and Objects
13:05
118
API and Package Structuring
09:51
119
Parent vs. Base class functions
04:09
120
Setting the main method
03:23
121
Debugging the code
09:34
122
Defining responsibilities of AI and Game classes
09:45
123
Unit Tests
05:53
124
Benefits of Single Responsibility Principle
05:01
125
Looking for a Smart AI
05:41
126
The need for stateless move exploration
07:29
127
Prototype Design Pattern
13:30
128
DRY: Dont Repeat Yourself
15:12
129
Iterator Design Pattern
07:23
130
DRY: Extracting Common Pieces
06:56
131
New feature request: Find Forks!
12:10
132
Building a Rule Engine
08:55
133
Builder Design Pattern
06:56
134
Summary: Open-Closed Principle
00:50
135
New feature request: Timers!
08:01
136
Encapsulating responsibilities in objects
10:08
137
Extracting Nested Objects
12:32
138
Having Multiple AI personalities
11:31
139
Singleton and Null Object Design Pattern
09:05
140
Chain of Responsibility Pattern
11:41
141
Interface Segregation Principle
04:20
142
Dependency Inversion Principle
02:58
143
New feature request: Undo Moves with Momento!
10:40
144
Proxy and Flyweight Design Pattern
10:22
145
The Labyrinth: Five Level Deep For-Loops!
10:24
146
State and Strategy Design Pattern
06:43
147
Writing Tests for Timed Games
05:06
148
Factory Design Pattern
09:15
149
Unit Tests and Object Pools
08:34
150
Setting Timed Test Cases
05:23
151
Fixing bugs in Game Logic and Factories
15:46
152
Strategy Design Pattern: Implementation and Benefits
12:44
153
New Feature: Email Notifications
13:03
154
Inheritance vs. Composition
06:36
155
The Publisher Subscriber Model
16:21
156
Problem Statement
03:39
157
Defining objects states and behaviors
10:58
158
Simplified Balances algorithm
05:35
159
APIs and coding requirements
05:32
160
Low Level Design
03:25
161
Coding: Building the service skeleton and defining objects
10:23
162
Coding: Algorithm
04:10
163
Coding: Test cases
06:06
164
Conclusion and Tips
03:03
165
#1: Caching: Engineering requirements
05:24
166
#2: Read your own writes
04:14
167
#3: Defining the core requirements
02:12
168
#4: Asynchronous processing: Keeping threads available
05:16
169
#5: View Consistency through thread assignment
06:14
170
Code #1: Code skeleton for 'Get' and 'Set'
16:59
171
Code #2: Setting up fast evictions
13:27
172
Code #3: Thread Assignment and updating GET + SET
12:59
173
Code #4: Hot loading and Request Collapsing
09:28
174
What is an event bus?
01:23
175
Breaking down engineering requirements
09:56
176
The mechanics of the bus
04:43
177
Why use threads?
04:14
178
Code Skeleton and using an extensible Retry Algorithm
12:20
179
The Keyed Executor
06:14
180
Pull and Push Subscribers
06:56
181
Defining the data structures in the bus
04:00
182
Wrapper Classes
08:26
183
Coding the tests
19:46
184
Conclusion
12:36
185
What will you learn
06:09
186
Rate Limiter Overview
06:51
187
Implementation Details
10:20
188
API Breakdown
09:34
189
Models, Controllers, Packages and ThreadPools
12:01
190
Reading and Writing Data
15:47
191
RateLimiter Client Setup
11:24
192
Sliding Window Algorithm Setup
07:19
193
Dependency Inversion
08:29
194
Sliding Window with Backpressure
10:06
195
Clearing Stale Entries in Sliding Window
05:15
196
January 2022: Datastores and their Tradeoffs
01:15:47
197
March 2022: Threads and Request Collapsing
01:39:28
198
April 2022: Chess Low Level Design
02:00:09
199
May 2022: Message Queues
01:35:28
200
June - Design a Payment System
01:43:41
201
July - Caching, Paxos and Zookeeper
01:23:36
202
Data Corruption and Alerts Monitoring
01:46:47
203
Caching: Doubts and Clarifications
01:40:08
204
August - Database Doubts
01:51:11
205
Design a subscription manager
01:37:45
206
Rule Engines
01:42:15
207
October - Kafka Internals
02:09:44
208
October 2022 - Implementing a File System
01:50:58
209
Pessimistic and Optimistic Locking
01:52:31
210
Producers and Consumers: November Meet
01:00:10
211
IRCTC Algorithm: December
01:07:32
212
Google Docs and Chess Design Queries
01:40:39
213
Jan 2023: DNS, CDNs, and everything in between
01:57:57
214
Jan 2023: API design and other discussions
01:07:09
215
Feb 2023: Permission Management System
01:26:21
216
March 2023: Eventual Consistency Levels
01:27:17
217
March 2023: Fetch top K hits in a distributed system
01:04:07
218
April 2023: Distributed Consensus and Load Balancing
02:01:05
219
April 2023: Graph Databases with Facebook TAO
01:33:43
220
May 2023: The SideCar Pattern
02:10:47
221
May 2023: Permission Management
01:33:49
222
June 2023: Clients, Comments and APIs
01:56:24
223
July 2023: Design an Event Handler
01:37:40
224
July 2023: Highly Scalable Concurrent Booking Systems
02:06:59
225
August 2023 - Google Calendar Low-Level Design
01:44:01
226
August 2023 - Designing IRCTC
01:22:05
227
September - Design Judge Launch
01:47:38
228
September - Tech in a startup
02:15:24
229
October - Live Watch Party Design
02:08:19
230
November - Memcached Reading
01:57:21
231
November - Memcached Revision
02:05:42
232
December: Memcached Paper Reading - 2
02:19:30
233
Monoliths vs Microservices
07:42
234
Horizontal vs Vertical Scaling
07:53
235
Load Balancing
10:14
236
An introduction to distributed systems
08:42
237
Single Point of Failure
06:00
238
Sharding
08:56
239
Service discovery and Heartbeats
05:30
240
Capacity Planning and Estimation: How much data does YouTube store daily?
13:12
241
Content Delivery Networks
11:09
242
API Design Goals
06:22
243
API Design in Practice
08:57
244
The Message Queue: Problem Statement
04:09
245
Asynchronous processing: benefits
05:35
246
Publisher Subscriber Models
11:21
247
Event Driven Architectures
03:36
248
Event Driven Architectures - Advantages
04:57
249
Event Driven Architectures - Disadvantages
05:44
250
Distributed data consistency
05:58
251
Data Consistency across Continents
05:14
252
Leader-follower architectures
04:58
253
Tradeoffs - 2 phase commit protocol
09:31
254
Difference between SQL and NoSQL
09:47
255
Cassandra Internals
07:35
256
Quorom
03:14
257
Write Heavy DB Design
05:29
258
Write Heavy DB Design - Merging Sorted String Tables
05:05
259
Write Heavy DB Design - Query optimisations
06:45
260
Location Representation
08:17
261
Data Structure - Quad Tree
01:51
262
Range Queries and Hilbert Curve
12:00
263
Motivation
06:25
264
Infrastructure Requirements
06:38
265
Practical considerations
05:17
266
Containers: A friendly Introduction
01:49
267
Containers: Usecases
05:36
268
System Requirements
02:49
269
One to one messaging
08:13
270
Last Seen Timestamps
03:39
271
Group Messaging
10:13
272
Requirements
03:57
273
Image Storage: Files vs. Database BLOB
06:49
274
Profile Creation and Authentication
05:48
275
One to One chat messaging
05:08
276
Matching right-swiped users
03:19
277
Serving recommendations to users
08:41
278
Requirements
02:52
279
Designing the Data Schema
06:04
280
Following Users
02:17
281
User Feed Service
05:25
282
Scaling the Instagram news feed
06:15
283
Anomaly Detection
07:26
284
Video Processing
06:11
285
ISP Synergy
04:19
286
System Design Tips
07:37
287
Dos and Don'ts
06:35
288
Online Judge
07:46

Unlock unlimited learning

Get instant access to all 287 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

NativeScript + Angular: Build Native iOS, Android & Web Apps

NativeScript + Angular: Build Native iOS, Android & Web Apps

Sources: udemy
With Angular (2+), you can already build highly reactive and engaging web apps. Wouldn't it be amazing to use that same tech stack and knowledge to build real native mobile apps...
20 hours 11 minutes 23 seconds
Reprogram Your Subconscious

Reprogram Your Subconscious

Sources: Prodigies University
The forbidden secret formula, discovered in 1919, that will help reprogram your subconscious, attract wealth, and turn dreams into reality.
1 hour 18 minutes 21 seconds
Lightspeed Deployments

Lightspeed Deployments

Sources: newline (ex fullstack.io)
This workshop is a continuation of the courses "Overnight Fullstack Applications" and "How To Connect, Code & Debug Supabase With Bolt." In the recording of...
16 minutes 45 seconds
AI Engineering Bootcamp: RAG (Retrieval Augmented Generation) for LLMs

AI Engineering Bootcamp: RAG (Retrieval Augmented Generation) for LLMs

Sources: zerotomastery.io
This course will teach you how to create smarter AI applications using one of the most important techniques in modern artificial intelligence - Retrieval...
22 hours 1 minute 6 seconds
Design Microservices Architecture with Patterns & Principles

Design Microservices Architecture with Patterns & Principles

Sources: udemy
In this course, we’re going to learn how to Design Microservices Architecture with using Design Patterns, Principles and the Best Practices with Iterate Design
17 hours 26 minutes 52 seconds