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
Watch Online System Design Course
0:00
/ #1: What do we offer?
All Course Lessons (288)
# | Lesson Title | Duration | Access |
---|---|---|---|
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 subscriptionComments
0 commentsSimilar courses

Master System Design and Design Pattern
Sources: udemy
This course explains all the deep concepts of scalable system design problems and design patterns. These problems are frequently asked during interviews.
11 hours 33 minutes 6 seconds

Team Dynamics and Soft Skills for Developers | Don’t Imitate
Sources: Anthony Alicea
Whether you've learned software development at a school, bootcamp, online, or are entirely self-taught, there is one key aspect to being a developer that you we
5 hours 8 minutes 46 seconds

Ultimate SwiftUI Mock Interview AppStore
Sources: letsbuildthatapp
Ready to become a professional developer? After this course, you'll be ready for any type of interview. Prerequisites: Basic SwiftUI skills, Understanding of networking.
5 hours 11 minutes 38 seconds
Want to join the conversation?
Sign in to comment