Day Topic Sub-Topics

1 Python Basics Syntax, Variables, Data Types

2 Control Flow If, Else, Elif, Loops (for, while)
Functions and
3 Modules Defining, Calling, Scope, Recursion, Modules
4 Data Structures Lists, Tuples, Sets, Dictionaries
5 File Handling Reading, Writing, Appending Files
6 OOP Concepts Classes, Objects, Inheritance, Polymorphism
7 Advanced OOP Encapsulation, Abstraction, Interfaces
8 Python Libraries Numpy, Pandas, Matplotlib
9 Web Basics HTML, CSS, JavaScript

10 Front-End Framework React, Bootstrap

APIs and RESTful
11 Services API Basics, RESTful Architecture
12 Flask Basics Setting Up Flask, Routing, Templating
13 Flask with Databases SQLite, SQLAlchemy
14 User Authentication JWT, OAuth, Session Management
15 Django Basics Setting Up Django, MVC Pattern
16 Django Models Defining Models, Migrations
17 Django Templates Rendering Data, Template Inheritance
18 Django Forms Form Handling, Validations
Django REST
19 Framework Building APIs with Django
20 Front-End Integration Connecting Django with React/Bootstrap
Advanced Django
21 Features Middleware, Signals, Caching

Advanced Django
22 Features Middleware, Signals, Caching

Advanced Django
23 Features Middleware, Signals, Caching
Testing and
24 Debugging Unit Testing, Integration Testing
Front-End State
25 Management Redux, Context API

Front-End State
26 Management Redux, Context API

Front-End State
27 Management Redux, Context API
28 Real-World Project Planning and Structuring Full-Stack Project
29 Project Development Backend API Implementation
29 Project Front-End Integrating React with Backend APIs
30 Final Project Review Code Review, Documentation
DSA (Data Structures and Algorithms) 15 Days
Day Topic Area Subtopics to Cover

Basic Operations:
- Arithmetic Operations (addition, subtraction, multiplication,
division)
- Modulus, Exponentiation, Factorial
- Bitwise Operations (AND, OR, XOR, SHIFT)
1 Basic Operations + 2D
2D Arrays:
- Introduction to 2D Arrays
- Accessing and Modifying Elements
- Traversing 2D Arrays
- Common Problems (matrix rotations, boundary traversal, etc.)
Sliding Window:
- Introduction to Sliding Window Technique
- Fixed and Variable Window Size Problems
- Examples (Longest Substring Without Repeating Characters,
Maximum Sum Subarray)

Two Pointers:
2 Sliding Window + Two -PIntroduction to Two Pointers Technique
- Use in Sorted Arrays, Linked Lists, and Strings
- Examples (Pair Sum, Palindrome Check)

String Manipulation:
- Common String Operations (Reversal, Rotation, Anagram
Check, Palindrome)
- String Matching and Searching

Single Linked List:

- Definition and Structure
- Basic Operations: Insertion, Deletion, Traversal
- Finding Length, Reverse a Linked List
3 Single Linked List + Do- Detecting Loops in Linked List

Double Linked List:

- Difference between Singly and Doubly Linked List
- Operations (Insertion, Deletion, Traversal, Reverse)

Circular Linked List:

- Circular Linked List Structure (Singly Circular, Doubly
Circular)
- Operations (Insertion, Deletion, Traversal)
- Detecting Loops in Circular Linked List
4 Circular Linked List +
Fast-Slow Pointer Problems:
- Detecting Cycle in Linked List (Floyd’s Cycle-Finding
Algorithm)
- Finding the Middle of a Linked List
- Detecting the Start of the Cycle
- N-th Node from the End
Stack Implementation:
- Introduction to Stack Data Structure
- Stack Operations: Push, Pop, Peek
- Stack using Array vs Linked List
5 Stack Implementation +
Problems:
- Balanced Parentheses Problem
- Valid Parentheses (using Stack)
- Reverse a String Using Stack
- Stock Span Problem (Using Stack)

Queue Implementation:
- Introduction to Queue Data Structure
- Queue Operations: Enqueue, Dequeue, Front, Rear
- Queue using Array vs Linked List
6 Queue Implementation +
Problems:
- Next Greater Element Problem (Using Stack)
- Queue Using Two Stacks
- Circular Queue Implementation
- Sliding Window Maximum (Queue-based approach)

Recursion Basics:
- Understanding Recursion (Base Case, Recursive Case)
- Recursion Tree and Call Stack
- Solving Problems Using Recursion (Factorial, Fibonacci, Sum
of Array)
7 Recursion Basics + Sub
Subsets:
- Subset Problem (Finding all subsets of a set)
- Subset Sum Problem
- Recursion vs Iteration for Subsets
- Backtracking for Subset Generation

Permutations:
- Generating Permutations (Recursive Approach)
- Handling Duplicates in Permutations
- Permutation with Constraints
8 Permutations + Backtra
Backtracking Problems:
- N-Queens Problem
- Sudoku Solver
- Word Search Problem
- Combination Sum Problem
Binary Trees:
- Definition and Structure of Binary Tree
- Types of Binary Trees (Full, Complete, Perfect, Balanced)
- Tree Operations (Insertion, Deletion, Traversal)
9 Binary Trees + Binary
Binary Search Trees (BST):
- Properties of BST
- Insertion, Deletion, and Search in BST
- Balanced vs Unbalanced BST
- Searching for Minimum and Maximum in BST

Tree Traversals:
- Pre-order, In-order, Post-order Traversal (Recursive and
Iterative)
- Level-order Traversal (BFS)
- Depth-first Search (DFS)
10 Tree Traversals + Prob
Problems:
- Lowest Common Ancestor (LCA) Problem
- Find Distance Between Two Nodes
- Diameter of Binary Tree
- Balanced Tree Check

Graph Representations:
- Adjacency Matrix vs Adjacency List
- Graph Types: Directed, Undirected, Weighted, Unweighted
- Edge List and Incidence Matrix
- Graph Construction in Code
11 Graph Representations
DFS (Depth-First Search):
- Recursive DFS Implementation
- DFS using Stack
- Applications of DFS (Topological Sorting, Cycle Detection)
- Time and Space Complexity of DFS

BFS (Breadth-First Search):

- BFS Implementation (Queue-based)
- Level-wise Traversal
- Applications of BFS (Shortest Path in Unweighted Graph,
Bipartite Graph Check)
12 BFS (Breadth-First Sear
Shortest Path Algorithms:
- Introduction to Shortest Path Algorithms
- Dijkstra’s Algorithm (Basic Idea and Explanation)
- Dijkstra’s Algorithm Implementation (Priority Queue)

13 Searching & Sorting Binary Search, Quick Sort, Merge Sort, Heap Sort Basics
Dynamic DP Basics, Memoization, Tabulation, Fibonacci, 0/1 Knapsack
14
Programming Intro
Mock Interviews &
15 Solve a Set of 15-20 Problems Covering All Topics
Final Revision
Theory (2 Hours) Practical (3 Hours)
Overview, Basic Syntax Simple Programs, Data Type Usage
Conditional Logic Flow Control Programs

Function Concepts Creating Modular Programs

DS Concepts, Usage Implementing Basic Operations
File I/O Concepts File Processing Programs
OOP Basics Building Classes and Methods
OOP Principles Practical OOP Applications
Library Overview Data Handling and Visualization
Structure, Styling Building Static Pages

Component-Based Design Building Responsive UIs

API Design Principles Creating Simple REST APIs

Flask Introduction Building a Basic Web App
ORM Concepts Connecting Flask with a Database
Authentication Methods Implementing User Login
Django Framework Building Simple Apps
Data Models Building Data-Driven Apps
Template Design Creating Dynamic Web Pages
Form Concepts Implementing User Forms

API Integration Creating and Consuming APIs

Full Stack Concepts Integrating Back-End and Front-End

Performance Optimization Implementing Advanced Features

Middleware in Python (Django) -Types

of Middleware: Built-in and Custom.

Middleware Execution Flow.

Creating Custom Middleware in

Django.
Middleware and Signals

Caching in Django:Advanced Caching

Caching Techniques in Python Techniques
Testing Strategies Writing Test Cases

State Management Theory Building State-Driven UIs

State Management in Functions:
Global vs. Local State.
Using global variables and the global
State Management Theory keyword.
Object-Oriented State Management -
State Management in Larger
Advanced State Management Techniques Applications -- State Persistence
Project Roadmap Initial Setup and Database Design
API Design Building Core Backend Functionality
Front-End Integration Building Interactive UIs
Code Quality Standards Final Touches and Bug Fixing
thms) 15 Days
Hours Split

2.5h Basic Operations + 3.5h 2D Arrays Hands-on

Practice
3h Sliding Window + 2h Two Pointers + 1h String
Manipulation Practice

3h Single Linked List + 3h Double Linked List

Hands-on Practice

3h Circular Linked List + 3h Fast-Slow Pointer

Problems (Hands-on)
2.5h Stack Implementation + 3.5h Problems
(Balanced Parentheses, Reverse String, Stock Span)

3h Queue Implementation + 3h Problems (Next

Greater Element, Queue Using Two Stacks, Sliding
Window)

3h Recursion Basics + 3h Subset Problems

(Recursive Solutions, Backtracking)

3h Permutations (Generating All Permutations) +

3h Backtracking Problems (Solving N-Queens,
Sudoku)
3h Binary Trees Basics + 3h Binary Search Trees
Hands-on Practice

3h Tree Traversals + 3h Problems (LCA, Distance

Between Nodes, Diameter of Tree)

2.5h Graph Representations + 3.5h DFS Hands-on

Practice (Recursive, Stack-based)

3h BFS + 3h Dijkstra’s Algorithm (Basic Intro and

Implementation)

3h Concepts + 3h Coding Practice

3h Concepts + 3h Problem Solving

Full Hands-on Practice

Revision (1 Hour)
Recap of Concepts
Practice Problems

Function Problems
Problem Solving
Data File Handling
OOP Programs
Code Review
Practice with Datasets
Front-End Practice

UI Enhancement

API Testing
Code Review
CRUD Operations
Secure Access Testing
App Structuring
Database Operations
UI Improvements
Validation Testing

API Performance Testing

UX Enhancement

Code Tuning

Create a simple middleware that logs incoming

requests.

Implement middleware to check authentication

status.

Set up Redis caching for a Django project.

Implement caching for a specific view to

improve performance.

Create a cache invalidation strategy.

Bug Fixing

Performance Tuning
Implementing a simple counter function using
global variables.

Passing state between functions.

Building a class-based counter.

Saving and loading the counter state from a file.

Feature Breakdown
API Testing
User Acceptance Testing
Presentation Preparation
DSA (Data Structures and Algorithms) 15
Day Topic Area

1 Basic Operations + 2D Arrays

2 Sliding Window + Two Pointers + String Man

3 Single Linked List + Double Linked List

4 Circular Linked List + Fast-Slow Pointer Pr

5 Stack Implementation + Problems (Balanced P

6 Queue Implementation + Problems (Next Gre

7 Recursion Basics + Subsets

8 Permutations + Backtracking Problems

9 Binary Trees + Binary Search Trees (BST)

10 Tree Traversals + Problems (Lowest Common

11 Graph Representations + DFS (Depth-First S

12 BFS (Breadth-First Search) + Shortest Path A

13 Searching & Sorting

14 Dynamic Programming
15 Mock Interviews & Final Revision
DSA (Data Structures and Algorithms) 15 Days
Subtopics to Cover

Basic Operations:
- Arithmetic Operations (addition, subtraction,
multiplication, division)
- Modulus, Exponentiation, Factorial
- Bitwise Operations (AND, OR, XOR, SHIFT)

2D Arrays:
- Introduction to 2D Arrays
- Accessing and Modifying Elements
- Traversing 2D Arrays
- Common Problems (matrix rotations, boundary traversal,
etc.)

Sliding Window:
- Introduction to Sliding Window Technique
- Fixed and Variable Window Size Problems
- Examples (Longest Substring Without Repeating
Characters, Maximum Sum Subarray)

Two Pointers:
- Introduction to Two Pointers Technique
- Use in Sorted Arrays, Linked Lists, and Strings
- Examples (Pair Sum, Palindrome Check)

String Manipulation:
- Common String Operations (Reversal, Rotation, Anagram
Check, Palindrome)
- String Matching and Searching

Single Linked List:

- Definition and Structure
- Basic Operations: Insertion, Deletion, Traversal
- Finding Length, Reverse a Linked List
- Detecting Loops in Linked List

Double Linked List:

- Difference between Singly and Doubly Linked List
- Operations (Insertion, Deletion, Traversal, Reverse)
Circular Linked List:
- Circular Linked List Structure (Singly Circular, Doubly
Circular)
- Operations (Insertion, Deletion, Traversal)
- Detecting Loops in Circular Linked List

Fast-Slow Pointer Problems:

- Detecting Cycle in Linked List (Floyd’s Cycle-Finding
Algorithm)
- Finding the Middle of a Linked List
- Detecting the Start of the Cycle
- N-th Node from the End

Stack Implementation:
- Introduction to Stack Data Structure
- Stack Operations: Push, Pop, Peek
- Stack using Array vs Linked List

Problems:
- Balanced Parentheses Problem
- Valid Parentheses (using Stack)
- Reverse a String Using Stack
- Stock Span Problem (Using Stack)

Queue Implementation:
- Introduction to Queue Data Structure
- Queue Operations: Enqueue, Dequeue, Front, Rear
- Queue using Array vs Linked List

Problems:
- Next Greater Element Problem (Using Stack)
- Queue Using Two Stacks
- Circular Queue Implementation
- Sliding Window Maximum (Queue-based approach)

Recursion Basics:
- Understanding Recursion (Base Case, Recursive Case)
- Recursion Tree and Call Stack
- Solving Problems Using Recursion (Factorial, Fibonacci,
Sum of Array)

Subsets:
- Subset Problem (Finding all subsets of a set)
- Subset Sum Problem
- Recursion vs Iteration for Subsets
- Backtracking for Subset Generation
Permutations:
- Generating Permutations (Recursive Approach)
- Handling Duplicates in Permutations
- Permutation with Constraints

Backtracking Problems:
- N-Queens Problem
- Sudoku Solver
- Word Search Problem
- Combination Sum Problem

Binary Trees:
- Definition and Structure of Binary Tree
- Types of Binary Trees (Full, Complete, Perfect, Balanced)
- Tree Operations (Insertion, Deletion, Traversal)

Binary Search Trees (BST):

- Properties of BST
- Insertion, Deletion, and Search in BST
- Balanced vs Unbalanced BST
- Searching for Minimum and Maximum in BST

Tree Traversals:
- Pre-order, In-order, Post-order Traversal (Recursive and
Iterative)
- Level-order Traversal (BFS)
- Depth-first Search (DFS)

Problems:
- Lowest Common Ancestor (LCA) Problem
- Find Distance Between Two Nodes
- Diameter of Binary Tree
- Balanced Tree Check
Graph Representations:
- Adjacency Matrix vs Adjacency List
- Graph Types: Directed, Undirected, Weighted,
Unweighted
- Edge List and Incidence Matrix
- Graph Construction in Code

DFS (Depth-First Search):

- Recursive DFS Implementation
- DFS using Stack
- Applications of DFS (Topological Sorting, Cycle
Detection)
- Time and Space Complexity of DFS

BFS (Breadth-First Search):

- BFS Implementation (Queue-based)
- Level-wise Traversal
- Applications of BFS (Shortest Path in Unweighted Graph,
Bipartite Graph Check)

Shortest Path Algorithms:

- Introduction to Shortest Path Algorithms
- Dijkstra’s Algorithm (Basic Idea and Explanation)
- Dijkstra’s Algorithm Implementation (Priority Queue)

Binary Search, Quick Sort, Merge Sort, Heap Sort Basics

DP Basics, Memoization, Tabulation, Fibonacci, 0/1
Knapsack Intro
Solve a Set of 15-20 Problems Covering All Topics
thms) 15 Days
Hours Split

2.5h Basic Operations + 3.5h 2D Arrays Hands-on Practice

3h Sliding Window + 2h Two Pointers + 1h String Manipulation

Practice

3h Single Linked List + 3h Double Linked List Hands-on Practice

3h Circular Linked List + 3h Fast-Slow Pointer Problems (Hands-on)

2.5h Stack Implementation + 3.5h Problems (Balanced Parentheses,

Reverse String, Stock Span)

3h Queue Implementation + 3h Problems (Next Greater Element,

Queue Using Two Stacks, Sliding Window)

3h Recursion Basics + 3h Subset Problems (Recursive Solutions,

Backtracking)
3h Permutations (Generating All Permutations) + 3h Backtracking
Problems (Solving N-Queens, Sudoku)

3h Binary Trees Basics + 3h Binary Search Trees Hands-on Practice

3h Tree Traversals + 3h Problems (LCA, Distance Between Nodes,

Diameter of Tree)
2.5h Graph Representations + 3.5h DFS Hands-on Practice
(Recursive, Stack-based)

3h BFS + 3h Dijkstra’s Algorithm (Basic Intro and Implementation)

3h Concepts + 3h Coding Practice

3h Concepts + 3h Problem Solving
Full Hands-on Practice