Course Content

Module 1 : System Design

Introduction to System Design

●​ What is System Design? Understanding its importance and challenges

●​ Types of Systems: Distributed, Scalable, Fault-Tolerant Systems
●​ Key Design Principles: Scalability, Reliability, and Maintainability

td
●​ High-Level vs Low-Level Design
●​ Requirements Gathering: Functional vs Non-Functional Requirements

tL
Designing Scalable Systems

Pv
●​ Vertical vs Horizontal Scaling
●​ Load Balancing Techniques: Round Robin, Least Connections, IP Hashing

s
●​ Sharding: Data Sharding and Application Sharding

ic
●​ Caching Strategies for Scalability: Memcached, Redis
at
●​ Database Scaling: Replication, Partitioning, and Horizontal Scaling
rm
High Availability and Fault Tolerance

●​ Redundancy Configurations: Active-Active, Active-Passive

fo

●​ Failover Mechanisms: Automatic and Manual Failover

●​ Designing for Disaster Recovery
In

●​ Ensuring Fault Tolerance through Replication and Data Redundancy

●​ Eventual Consistency vs Strong Consistency in Distributed Systems
ld

●​ Circuit Breaker Pattern and Retry Logic

or

Microservices and Distributed Systems

W

●​ Introduction to Microservices Architecture

●​ Communication between Microservices: REST APIs, gRPC, Message
x

Queues
nu

●​ Service Discovery and Load Balancing in Microservices

●​ Distributed Databases: CAP Theorem and its Applications
Li

●​ Distributed Systems Concepts: Eventual Consistency, Partition Tolerance

●​ RPC (Remote Procedure Calls) and RMI (Remote Method Invocation) in
Distributed Systems

Database Design

●​ Relational vs Non-Relational Databases

●​ Choosing the Right Database for your System
●​ Designing Scalable and Performant Database Schema
●​ Indexing and Query Optimization
●​ Transactions and ACID Properties

1
 ●​ Sharding and Partitioning Strategies
●​ Caching and Data Consistency Models

System Design Patterns

●​ Common Design Patterns: Client-Server, Layered (MVC), Master-Slave,

Peer-to-Peer
●​ Proxy, Broker, and Singleton Patterns
●​ Use of Design Patterns for System Reusability and Maintainability
●​ Combining Multiple Design Patterns for Complex Systems

td
Performance Optimization

tL
●​ Profiling and Identifying Performance Bottlenecks
●​ Optimizing CPU, Memory, Disk Utilization
●​ Reducing Latency: Asynchronous Processing, Parallelism, and Concurrency

Pv
●​ Caching Strategies for Performance: Redis, Memcached
●​ Distributed Caching for Large Systems

s
ic
Security in System Design

●​
at
Securing APIs: Authentication (OAuth, JWT, API Keys)
●​ Authorization: Role-Based Access Control (RBAC)
rm
●​ Data Encryption: At-Rest and In-Transit
●​ Rate Limiting and Throttling for API Security
fo

●​ Best Practices: Input Validation, CSRF, XSS

●​ Logging and Monitoring for Security Auditing
In
ld

System Design Best Practices

or

●​ Designing for Maintainability: Code Structure, Versioning, and Deprecation

W

●​ Real-World Design Constraints: Cost, Time, and Complexity

●​ Documenting and Communicating System Designs
x

●​ Preparing for System Design Interviews: Best Practices and Tips

nu
Li

2
Module 2: Data Structures and Time Complexity

●​ Programming Basics (C++ & Python):

○​ Data types, variables, loops, functions, and conditionals.
○​ Input/output handling.
●​ Introduction to DSA:
○​ Importance and real-world applications of DSA.
○​ Overview of problem-solving with algorithms.
●​ Complexity Analysis:

td
○​ Understanding time complexity: Big O, Big Omega, Big Theta notations.

tL
○​ Space complexity basics.
○​ Common complexities: O(1), O(log n), O(n), O(n log n), O(n²).
○​ Analyzing examples for complexity.

Pv
Module 3: Arrays and Strings

s
ic
●​ Arrays:
○​ Introduction, declaration, and initialization in C++ and Python.
at
○​ Traversal, insertion, deletion, and searching in arrays.
○​ Two-dimensional arrays and matrix manipulation.
rm

●​ Strings:
○​ String handling and methods in Python (len, join, split) and C++ (std::string).
fo

○​ Common operations: reverse, palindrome check, anagrams, and substring

search.
In

Module 4: Recursion and Error Handling

ld

●​ Recursion Basics:
or

○​ Understanding recursion with examples (factorial, Fibonacci).

W

○​ Stack memory visualization for recursion calls.

○​ Recursive problems and their applications.
●​ Error Handling
x

○​ Try-catch blocks and exceptions.

nu

○​ Debugging techniques and tools.

Li

Module 5: Searching Algorithms

●​ Searching Algorithms:
○​ Linear Search, Binary Search.
○​ Recursive and iterative implementations.
○​ Analysis of time complexity of searching algorithms.

Module 6: Sorting Algorithms

●​ Sorting Algorithms:
○​ Bubble Sort, Selection Sort, Insertion Sort.

3
 ○​ Quick Sort, Merge Sort (Divide & Conquer).
○​ Time and Space Complexity Analysis.
○​ Practical Use Cases: When to use which sorting algorithm.

Module 7: Linked Lists (Singly, Doubly, Circular)

●​ Singly Linked List:

○​ Definition, creation, traversal, insertion, deletion.
○​ Applications of singly linked lists.
●​ Doubly Linked List:
○​ Understanding pointers for next and prev.

td
○​ Common operations and use cases.
●​ Circular Linked List:

tL
○​ Circular traversal and operations.
○​ Complexity Analysis for common operations in linked lists.

Pv
Module 8: Stacks and Queues

s
●​ Stacks:

ic
○​ Definition and real-life examples (undo operation, expression evaluation).
at
○​ Stack implementation using arrays and linked lists.
○​ Common stack operations: Push, Pop, Peek, IsEmpty.
rm
○​ Applications of stacks (Balanced Parentheses Problem, Reverse a string
using a stack, Evaluate Postfix and Prefix Expressions).
fo

●​ Queues:
○​ Definition and applications in scheduling and buffering.
In

○​ Queue implementation using arrays and linked lists.

○​ Circular Queue implementation.
ld

○​ Priority Queue and Deque (Double-Ended Queue).

or

Module 9: Trees and Binary Search Trees (BST)

W

●​ Trees Basics:
○​ Binary Tree representation and traversal: Inorder, Preorder, Postorder.
x

●​ Binary Search Trees:

nu

○​ Insertion, Deletion, and Search.

●​ Advanced Concepts:
Li

○​ Balanced Trees: AVL, Red-Black Trees (overview).

○​ Applications of trees in real-world problems.

Module 10: Graphs and Their Algorithms

●​ Graph Basics:
○​ Representation: Adjacency List and Matrix.
○​ Traversal Algorithms: BFS and DFS.
●​ Shortest Path Algorithms:
○​ Dijkstra’s Algorithm, Bellman-Ford Algorithm.
○​ Applications of Graph algorithms.

4
 ●​ Minimum Spanning Tree:
○​ Kruskal’s Algorithm.

Module 11: Backtracking, and Divide & Conquer

●​ Backtracking:
○​ Introduction to backtracking.
○​ Applications: Maze Problem, N-Queens problem.
●​ Divide and Conquer Approach:
○​ Introduction to Divide & Conquer.
○​ Common problems: Merge Sort, Quick Sort, Binary Search.

td
●​ Analyzing time complexity for Divide & Conquer algorithms.

tL
Module 12: Dynamic Programming

Pv
●​ Dynamic Programming Basics:
○​ Overlapping subproblems and optimal substructure.
○​ Common problems: Knapsack, Longest Common Subsequence, and

s
Fibonacci.

ic
●​ Advanced Techniques: at
○​ Memoization and Tabulation.
○​ State-space representation.
rm
fo

Module 13: Object-Oriented Programming (OOP)

In

●​ OOP Principles
ld

○​ Encapsulation, inheritance, polymorphism, abstraction.

○​ Real-world examples of OOP concepts.
or

●​ Advanced OOP Concepts

○​ Interfaces and abstract classes.
W

○​ Composition over inheritance.

○​ Design patterns (Singleton, Factory, Observer, Decorator).
x
nu

Module 14: Operating System

Li

●​ Introduction to Operating Systems

○​ What is an Operating System? Overview of types and functions.
○​ Key components of an OS: Kernel, System Calls, and Privileged Instructions.
○​ Introduction to UNIX Systems and Microkernel concept.
●​ Process Scheduling
○​ Introduction to Process Scheduling.
○​ Process Creation, Deletion, and Process States.
○​ Process Table and Process Control Block (PCB).
○​ CPU Scheduling Algorithms: Preemptive vs Non-Preemptive.
○​ Time Spent in Context Switching.
○​ Starvation and Aging in OS.

5
●​ Process Synchronization
○​ Introduction to Process Synchronization and Inter-Process Communication
(IPC).
○​ Critical Section Problem and Peterson’s Algorithm.
○​ Semaphores, Mutex vs Semaphore, and Monitors.
○​ Classical IPC Problems: Dekker’s and Bakery Algorithms.
○​ Linux Thread Synchronization with Mutex Locks.
○​ Priority Inversion Problem and solutions.
●​ Deadlock
○​ Introduction to Deadlock and its concepts: Starvation and Livelock.
○​ Deadlock Prevention, Detection, and Recovery.

td
○​ Banker’s Algorithm and Resource Allocation Graph (RAG).
○​ Methods of Resource Allocation by OS.

tL
○​ Deadlock Detection in Distributed Systems.
●​ Processes & Threads

Pv
○​ Introduction to Threads in Operating Systems.
○​ User-Level vs Kernel-Level Threads.
○​ Process-Based vs Thread-Based Multitasking.

s
○​ Benefits of Multithreading.

ic
○​ Zombie Processes: Causes and Prevention.
at
○​ Remote Procedure Call (RPC) in OS.
●​ Memory Management
rm
○​ Introduction to Memory Management and its types.
○​ Paging, Segmentation, and Virtual Memory.
fo

○​ Memory Interleaving and OS-based Virtualization.

○​ Swap Space and Page Fault Handling.
In

○​ Memory Segmentation in 8086 Microprocessor.

○​ Algorithms: Next Fit, Buddy System, and Slab System.
ld

●​ Disk Management
○​ Overview of File Systems and Unix File System.
or

○​ File Allocation and Access Methods.

○​ Disk Scheduling Algorithms: SSTF.
W

○​ Free Space Management and Spooling Concepts.

○​ Implementing Directory Management with Shell Script.
x

●​ File Systems:
nu

○​ Advanced File System Topics: NTFS, ext4, FAT32, etc.

○​ File System Mounting and Virtual File System (VFS)
Li

○​ Journaling File Systems

●​ Security in OS:
○​ Security Mechanisms: Access Control, Authentication, Encryption
○​ File Permissions and User Management
○​ Role-based Access Control (RBAC)
○​ OS-level Security in Multi-user Environments
●​ Networking in OS:
○​ Network Protocols and Networking Stack in OS
○​ Socket Programming Basics
○​ Network File System (NFS) and Distributed File Systems
○​ Communication Between Systems in Distributed Environments

6
Module 15: MongoDB

●​ Introduction to MongoDB
○​ What is MongoDB? Overview of collections, documents, BSON.
○​ Installing MongoDB locally and using MongoDB Atlas.
●​ CRUD Operations
○​ Create: Using insertOne() and insertMany().
○​ Read: Using find(), findOne(), filters, projections.
○​ Update: Using updateOne(), updateMany().
○​ Delete: Using deleteOne(), deleteMany().
●​ Indexes in MongoDB

td
○​ Creating and using indexes to optimize queries.
●​ Data Modeling

tL
○​ Schema design.
○​ Embedding vs. referencing documents.

Pv
●​ Aggregation Framework
○​ Basic aggregation: $match, $group, $sort.
○​ Advanced aggregation: $lookup, $unwind, $project.

s
●​ MongoDB Security

ic
○​ Authentication, RBAC (Role-Based Access Control).
at
○​ Backup and restore techniques.
rm
fo
In
ld
or
W
x
nu
Li