Preparing for the System Design Interviews

This lesson gives an introduction to the concept of load balancing.

This lesson shows the various layers where a load balancer can be used in a scalable system

This lesson would cover the various types of load balancers that can be used in production ready systems.

This lesson covers the type of loads a load balancer can handle and the different kind of load balancing techniques that can be used to scale your system.

This lesson gives an introduction to caching, what it is and why we use it.

This lesson covers the concept of caching and give an example of its usage.

This lesson covers the different types of caches that we can use for our applications.

This lesson gives an intro on the different ways data can be updated in the caches.

This lesson gives the different ways data can be evicted from the caches.

This gives an introduction to the concept of CDNs

This lecture covers the concept of cdn.

This video gives an introduction about this simple case study. This case study is about building an LRU cache.

If you already know about this topic, feel free to skip this lesson

This lesson gives a description of what an LRU cache is. It also gives an example of a case where this cache might not be useful at all.

This lesson covers the concept behind building a simple LRU cache.It walks through a simple diagram whereby an example is used to depict the formulation and concepts behind a LRU cache.

This lesson covers the actual code behind a simple LRU cache. The code demoed in the case study is entirely written in java but can easily be ported to any other language like python, C# etc.

This lesson covers the actual code behind a simple LRU cache. The code demoed in the case study is entirely written in java but can easily be ported to any other language like python, C# etc.

For the current approach we have used a Hashmap and Arraylist combination. Even though the current solution explains the concepts behind an LRU cache well and might be good enough for an interview but there are few flaws in this approach.

This lesson covers the entire topics that we covered in the basic's section and using those topics we have tried to design an ecommerce website end to end.

In this lesson we will cover what is the question that is asked , or what exactly is the problem asked for.

In this lesson we will dig deeper into the problem by asking the right set of questions. We will try to understand what is expected from the system. What all are the complex points about this system.

This lesson gives the functional requirements of the system.

This chapter covers the non functional requirements of the system

This lesson covers the simplest possible case where the application is running on just one box and the entire system is built out of that box.

This lesson covers the simpler approaches in detail and explains how these simple approaches can be used to generate unique numbers.

This lesson gives the problems that are found while using the simple approach.

This lesson would give a small introduction on the 3 approaches that are suggested for handling this problem

This lesson gives a small description on this simple approach of generating a unique id by a global server.

Approach 1 continued...

This approach discusses the ticketing server approach that is very popular and is used in production systems as well.

Approach 2 continued...

In this lesson the twitter snowflake approach is covered along with the sample code for the same. If you are giving an example of this approach in your system design interview you would be expected to write the code for the same in your favorite language on the whiteboard.

This lesson gives the introduction to the problem we are working on as part of this case study.

This lesson would depict the details about understanding this problem of recommending items to users.

This lesson explains why relational db's are not suited for using to solve these kind of problems

This lesson will cover the requirements for the system we are designing as part of this case study.

This lesson briefly covers the high level design of this system.

This lesson covers the design of the data ingestion layer.

This lesson starts with the approach on analytics engine and gives a walk through of the first approach of using the Apriori Algorithm

Explanation of Apriori Algorithm or the market basket analysis approach

This lesson covers the code on the Apriori Algorithm using Apache Spark

This lesson covers the disadvantages of this approach.

An important point for this case study.

This lesson covers the approach for content based recommendation.

This lesson covers the code of implementing a content based recommendation system.

This lesson gives an introduction to collaborative filtering.

This lesson covers the collaborative filtering approach in short.

This lesson gives the problem we are trying to solve in this case study and also covers understanding of the problem

In this lesson we go over the functional and non function requirements from this system. We will also go over any assumptions we have made.

This lesson covers some simple back of the envelope calculations

This lesson covers the high level design for our system

This lesson shows example of sample JSON that can be pushed from the UI downstream to store in the big data layer.

This lesson describes the restful API we can build for this type of service.

This lesson covers a brief description of building the rest services of the API.

This lesson covers the code for the underlying TRIE datastructure we are proposing to use in this case study,

This chapter explains further on the low level design using a diagram

This lesson will cover why it's a good idea to store this TRIE in cache.

This lesson talks about how data can be stored and partitioned in HDFS for scalability and how map reduce jobs can be run on top of them using Hive.

This lesson will cover how we can build the TRIE.

This lesson will talk about the disadvantage of this approach.