TPC’s 13 Days System Design and DSA Interview

Preparation Plan
This preparation plan is designed to help you prepare for
interviews in System Design and DSA. It covers a broad range of
topics to ensure you are well-prepared for both conceptual and
practical aspects of interviews. (the plan is directional and the
number of days will vary based on your current preparation)

Day 1: Introduction to System Design

Topics to Cover:
System Design Basics: Understand the purpose of system design, the key
concepts such as scalability, availability, reliability, and maintainability.
Design Process: Learn the steps in the system design process—requirements
gathering, high-level design, detailed design, and trade-offs.
Functional vs Non-Functional Requirements: Clarify and emphasize non-
functional requirements during design. This includes scale, traffic handling, and
capacity planning.
Practice:
Analyze a simple system, identify key components, and discuss non-functional
requirements.
Resources:
Designing Data-Intensive Applications by Martin Kleppmann
System Design Primer GitHub Repository
High Scalability Blog

Day 2: High-Level Design (Architecture)

Topics to Cover:
Architectural Patterns:
Study common architectural patterns such as microservices, monolithic,
and serverless architectures.
 Scalability and Load Balancing:
Understand how to design systems that scale horizontally and vertically.
Learn about load balancing techniques and strategies for distributing traffic.
Practice:
Design a high-level architecture for a common application, such as an e-
commerce site or social media platform.
Draw diagrams of different architectural patterns and their components.
Resources:
Microservices Patterns by Chris Richardson
AWS Well-Architected Framework
System Design Interview – An insider's guide

Day 3: Low-Level Design (Component Design)

Topics to Cover:
Component Design Principles:
Learn about the SOLID principles (Single Responsibility, Open/Closed, Liskov
Substitution, Interface Segregation, Dependency Inversion).
Data Models and Storage:
Understand different types of databases (SQL vs NoSQL) and their use cases.
Study how to design data schemas and models.
Handling Long-Running Jobs: Focus on job queues, worker nodes, and task
tracking. Learn to design APIs for long-running tasks and asynchronous
responses.
Practice:
Design components for a system and API endpoints for long-running tasks (e.g.,
scraping services or job dispatch systems).
Resources:
Clean Architecture by Robert C. Martin
SQL vs NoSQL – Guide
Database System Concepts by Silberschatz, Korth, and Sudarshan

Day 4: High-Level System Design Case Study

Topics to Cover:
Case Studies:
Study detailed case studies of real-world systems like Google Search, Netflix,
or Twitter.
 Trade-Offs and Decisions: Learn how to evaluate trade-offs, especially between
consistency, availability, and partition tolerance.
Edge Cases: Consider pagination, infinite scrolling, domain redirection, and
robots.txt restrictions in system design.
Practice:
Review and analyze a case study. Identify design decisions and trade-offs made.
Create a similar high-level design for a system of your choice, justifying your
design choices.
Resources:
Designing Data-Intensive Applications by Martin Kleppmann
Netflix Technology Blog

Day 5: Low-Level System Design Case Study

Topics to Cover:
Detailed Component Design: Learn about class diagrams, sequence diagrams,
and component interactions.
Handling Concurrency: Study techniques for concurrency and parallelism in
system design.
Job Queues and Worker Systems: Focus on retry mechanisms, message queues,
and handling failures in worker nodes.
Practice:
Design detailed components, focusing on concurrency and worker-node systems.
Implement a component that demonstrates task distribution using job queues.
Resources:
Design Patterns: Elements of Reusable Object-Oriented Software by Gamma,
Helm, Johnson, and Vlissides
Java Concurrency in Practice by Brian Goetz

Day 6: Performance and Optimization

Topics to Cover:
Performance Metrics:
Understand how to measure performance, including latency, throughput, and
resource utilization.
Optimization Techniques:
Learn techniques for optimizing performance, including caching, indexing,
and database optimization.
 Cache Management and Expiry: Understand cache invalidation policies, eventual
consistency, and high availability strategies.
Practice:
Analyze performance bottlenecks in the system designed on Day 2.
Implement optimization techniques to improve performance.
Resources:
High Performance Browser Networking by Ilya Grigorik
System Design Interview – An insider's guide

Day 7: Start with DSA - Arrays and Strings

Topics to Cover:
Arrays:
Basic operations (traversal, insertion, deletion).
Common algorithms (sorting, searching).
Techniques: two-pointer approach, sliding window.
Strings:
String manipulation and common operations.
Algorithms: substring search, pattern matching.
Practice:
Implement common array algorithms (e.g., rotating arrays).
Solve string problems like reversing a string, finding the longest substring without
repeating characters.
Resources:
LeetCode - Arrays Problems
GeeksforGeeks - Arrays
GeeksforGeeks - Strings

Day 8: Linked Lists

Topics to Cover:
Singly Linked List:
Basic operations (insertion, deletion, traversal).
Techniques: reversing a linked list, detecting cycles.
Doubly Linked List:
Operations and differences from singly linked lists.
Circular Linked List:
Understanding circular linked lists and their applications.
Practice:
Implement a singly linked list with basic operations.
Solve problems like merging two sorted linked lists and detecting cycles in a
linked list.
Resources:
LeetCode - Linked Lists Problems
GeeksforGeeks - Linked Lists
YouTube - Linked List Tutorial

Day 9: Stacks and Queues

Topics to Cover:
Stacks:
Operations (push, pop, peek).
Applications: expression evaluation, backtracking.
Queues:
Operations (enqueue, dequeue).
Variants: circular queue, priority queue.
Practice:
Implement stack and queue data structures.
Solve problems like evaluating postfix expressions and implementing a queue
using stacks.
Resources:
LeetCode - Stack Problems
LeetCode - Queue Problems
GeeksforGeeks - Stack and Queue Data Structure

Day 10: Trees and Graphs

Topics to Cover:
Binary Trees:
Basic operations (traversal: in-order, pre-order, post-order).
Special types: binary search trees, AVL trees.
Graphs:
Representations (adjacency matrix, adjacency list).
Algorithms: BFS, DFS, shortest path (Dijkstra’s, Bellman-Ford).
Practice:
Implement binary trees and graph algorithms.
Solve problems like finding the height of a binary tree, and shortest path in a
graph.
Resources:
LeetCode - Tree Problems
LeetCode - Graph Problems
GeeksforGeeks - Tree Data Structure and Graph Data Structure

Day 11: Hashing and Heaps

Topics to Cover:
Hashing:
Hash tables, collision resolution techniques.
Applications: hash maps, hash sets.
Heaps:
Min-heap and max-heap.
Operations (insertion, deletion, heapify).
Applications: priority queues, heap sort.
Practice:
Implement hash maps and heaps.
Solve problems like finding duplicates using hash maps and implementing heap
operations.
Resources:
LeetCode - Hashing Problems
LeetCode - Heap Problems
GeeksforGeeks - Hashing and Heap Data Structure

Day 12: Dynamic Programming

Topics to Cover:
Dynamic Programming Basics:
Understand the principles of dynamic programming (overlapping
subproblems, optimal substructure).
Common problems: Fibonacci series, knapsack problem.
Advanced Topics:
Longest common subsequence, matrix chain multiplication.
Practice:
Solve classic dynamic programming problems.
Implement solutions for problems like the 0/1 knapsack problem and longest
common subsequence.
Resources:
LeetCode - Dynamic Programming Problems
GeeksforGeeks - Dynamic Programming
YouTube - Dynamic Programming Tutorial

Day 13: Challenge Day

Take The Proven Club challenge to get your Skill Assessment index!

To maximize your performance, we recommend reviewing the listed

topics. If you have any questions or need further clarification on the
challenge details, please feel free to reach out.

Best regards,
The Proven Club.