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

Join premium to watch
Go to premium
# Title Duration
1 What do we offer? 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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Computer Networks

Computer Networks

Sources: takeUforward
This course is a step-by-step immersion into the world of computer networks: from basic concepts and clear examples to complex technologies used in real...
8 hours 28 minutes 4 seconds
Classic Season 5

Classic Season 5

Sources: destroyallsoftware
In the "What Goes in Active Records" series (part 1 and part 2), we looked at some design constraints for what goes in ActiveRecord models. Sometimes, these con
3 hours 32 minutes 54 seconds
AI For Developers With GitHub Copilot, Cursor AI & ChatGPT

AI For Developers With GitHub Copilot, Cursor AI & ChatGPT

Sources: Academind Pro
This course is designed for developers who want to use AI effectively! AI is not a threat, but a powerful tool capable of making you even more...
4 hours 55 minutes 24 seconds
Advanced Algorithms

Advanced Algorithms

Sources: neetcode.io
The "Advanced Algorithms" course is a comprehensive guide to fundamental data structures and algorithms required to excel in technical interviews. This course is suitable for bo...
7 hours 36 minutes 10 seconds
The Junior to Senior Guidebook

The Junior to Senior Guidebook

Sources: Randall Kanna
This book is all you need to confidently build a developer career. Things that aren't taught in courses or at university. I wanted to write a book that...