Python Full Stack Engineering Course

1. What is the internet.
2. How does the web work.
3. The role of HTML and CSS.
4. Setting up a development environment (code editor, browser)
5. HTML Basics.
6. Structure of an HTML document.

1. Text formatting. (headings, paragraphs, emphasis)
2.Lists. (ordered and unordered)
3.Links. (anchors)
4. Image.

1. Creating input fields. (text, number, email, etc.)
2. Buttons. (submit, reset)
3. Labels.
4. Form validation.

1. Introduction to CSS.
2. Selectors. (element, class, ID)
3. Properties and values.
4. Styling text. (font, color, size)
5. Styling elements. (background, border, margin, padding)

1. Block, inline, and inline-block elements.
2. Float and clear properties.
3. CSS Grid.
4. Advanced CSS Topics.

1. Positioning. (relative, absolute, fixed)
2. Units of measurement. (pixels, percentages, ems, rems)
3. Color theory and color models.
4. Media queries for responsive design.

1. Plan and design a basic website. (e.g., a personal portfolio or a score
board)
2. Implement the HTML structure.
3.Apply CSS styles for layout and appearance.
4. Test and debug the website.

1. What is JavaScript.
2. Why is it called JavaScript.
3. What can in-browser JavaScript do.
4. JavaScript and VS Code.
5. Code structure.

1. Variables: (let, var, const).
2. Data Types:
Number.
String.
Boolean.
Null.
Undefined.
Objects.
3. Type of Operator.
Mathematical Operators & their precedence.
Comparison Operators.
Logical Operators.

1. If statement.
2. If...else statement. (including ternary operator)
3. Else if ladder.
4. Switch case.

1. While loop.
2. Do...while loop.
3. For loop.

1. Functions:
Function Declaration.
Local variables.
Outer variables.
Parameters.
Default values.
Returning a value.
Naming a function.  
2. Objects: the basics.

1. Objects: continued.
2. Strings: properties and methods.

1. Arrays: creation, access, manipulation.
2. Array functions: map, filter, reduce, etc.

1. Classes.
2. Constructors.
3. Getters and setters.
4. Inheritance.

1. Querying and selecting elements.
2. Traversing elements.
3. Creating elements.
4. Updating elements.
5. Removing elements.

1. Event listeners.
2. OnClick event.
3. Mouse events.
4. Keyboard events.

1. What is version control?
2. Why is it important?
3. What is Git?
4. What is GitHub?
5. Setting up Git and creating a GitHub account.
6. Version control terminology.

1. Staging and Committing Changes.
2. Repository Management Commands.
3. Branching and Merging.
4. Viewing and Comparing Changes.
5. Adding a Remote Repository.

1. Working on an Existing Repository.
2. Undoing Changes.

1. What is a Database.
2. Define a Database and its Components. (tables, records, fields)
3. Explain the role of a DBMS. (Database Management System)
4. Introduction to SQL.
SQL as a language for interacting with databases.
Basic SQL syntax and structure.
Common SQL commands. (SELECT, FROM, WHERE, ORDER BY)
5. Data types in SQL
Numeric. (INT, DECIMAL, FLOAT)
Character. (CHAR, VARCHAR)
Date and Time. (DATE, TIME, DATETIME)
Boolean. (BIT)
6. Creating tables
Using the CREATE TABLE statement.
Defining columns, data types, and constraints (PRIMARY KEY,
FOREIGN KEY, NOT NULL).

1. Inserting data.
Using the INSERT INTO statement.
Handling NULL values.
2. Updating data.
Using the UPDATE statement.
Updating multiple rows.
3. Deleting data.
Using the DELETE statement.
Deleting rows based on conditions.
4. Filtering data.
Using the WHERE clause with comparison operators. (=, <, >, <=,
>=, !=)
Using logical operators. (AND, OR, NOT)
Combining conditions.

1. Sorting data
Using the ORDER BY clause to sort results.
Ascending and descending order.
2. Grouping data
Using the GROUP BY clause to group rows.
Aggregate functions. (COUNT, SUM, AVG, MIN, MAX)

1. Indexes
Creating indexes to improve query performance.
Types of indexes. (clustered, non-clustered)
2. Performance tuning
Identifying performance bottlenecks.
Query optimization techniques. (explain plans, query rewriting)
3. Stored procedures
Creating and executing stored procedures.
Passing parameters.
Returning results.
4. Functions
Creating and using functions.
Scalar functions and table-valued functions.

1. Transactions.
Defining transactions.
Committing and rolling back transactions.
2. ACID properties.
Atomicity, consistency, isolation, durability.
3. Database design principles.
4. Entity-relationship (ER) diagrams.
5. Normalization. (1NF, 2NF, 3NF)
6. Normalization techniques.
7. Identifying functional dependencies.
8. Eliminating anomalies.

1. Database security.
User accounts and permissions.
Encryption.
Auditing.
2. Database backup.
Creating backups.
Restoring databases.

1. Practice exercises.
2. Applying SQL concepts to real-world scenarios.
3. Troubleshooting common SQL errors.
4. Question and answer Class.
5. Addressing learners' questions and concerns.

1. What is Python?
2. Why Python? (features and benefits)
3. Installing Python and setting up the environment.
4. Writing your first Python program.
5. Variables.

1. Data types.
2. Input /Output operations.
3. Comments and basic syntax.
4. Practice with basic variable assignments.
5. Take user input and display output.

1. Basic arithmetic Operators.
2. Logic Operators.
3. Practice with basic Operators.
4. Control Flow.
5. Conditional statements. (if, elif, else)

1. Loops (for, while)
2. Loop control (break, continue, pass)
3. Write a program to calculate the area of a rectangle.

1. Defining and calling functions.
2. Function arguments and return values.
3. Write a function to calculate the factorial of a number.
4. Create a function that takes two numbers and returns their sum.

1. Creating and modifying lists.
2. Basic list operations (append, remove, sort).

1. Creating dictionaries.
2. Accessing, adding, and updating dictionary items.
3. Tuples and sets.

1. Create a program to manage a to-do list using lists.
2. Build a dictionary-based student record system.

1. String methods.(upper(), lower(), etc.)
2. String formatting.
3. String slicing and indexing.
4. Extract the domain name from an email address.
5. Format a string to display “Hello, [Name]!”

1. Classes and objects.
2. Methods and attributes.
3. Constructors and inheritance.

1. Importing modules.
2. Using standard libraries. (math, datetime, random)
3. Creating custom modules.

1. Reading and writing text files.
2. Understanding exceptions.
3. Try, except, and finally blocks.
4. Raising exceptions.

1. What is the .NET Framework?
2. Why use ?
3. Installing Visual Studio.
4. Creating a new Console App project
output & comments.

1. Variables.
2. Constants.
3. Data types.
4. Type casting.
5. Operators.
Arithmetic operators.

1. Operators continued.
Assignment Operators.
Comparison Operators.
Logical Operators.
Control structures.
2. if statement.
3. if...else statement.
4. if...else ladder.
5. Switch case.

1. Loops.
2. While loop.
3. Do...while loop.
4. For loop.
5. Break and continue statements.

1. Arrays.
2. 2D arrays.
3. For each loop.

1. Methods/functions.
2. Creating a method.
3. Calling a method.
4. Parameters and arguments.
5. Default parameter values.
6. Return values.
7. Named arguments.
8. Method overloading.

1. What is OOP?
2. Classes and members.
3. Constructors.
4. Constructor parameters.

1. Access modifiers.
2. Encapsulation.
3. Properties.
4. Inheritance.

1. Polymorphism.
2. Abstraction.
3. Interfaces.

1. Exceptions: try...catch, throw.
2. Generics: introduction, generic classes.
3. Generic collections.
4. List.
5. Dictionary.
6. Sorted List.
7. Queue.
8. Stack.

1. Files and directories.
2. Streams.
3. Creating, opening, writing to, and reading from files.
4. Serialization.
5. Object to binary file stream.
6. Object to XML file stream.
7. Object to JSON string.

1. Basic operations (access, insertion, deletion).
2. Time and space complexity analysis.
3. Array-based implementations of stacks and queues.

1. Singly, doubly, and circular linked lists.
2. Traversal, insertion, deletion operations.
3. Time and space complexity analysis.

1. LIFO and FIFO principles.
2. Array and linked list implementations.
3. Applications (e.g., expression evaluation, backtracking).

1. Binary trees, binary search trees, heaps.
2. Tree traversals. (preorder, in order, post order)
3. Insertion, deletion, and search operations.
4. Heap operations. (insertion, deletion, heapify)

1. Linear search, binary search.
2. Bubble sort, insertion sort, selection sort, merge sort, quick sort.
3. Time and space complexity analysis.

1. Hash functions, collision handling techniques (separate chaining,
open addressing).
2. Applications (e.g., dictionaries, sets).

1. Graph representations (adjacency matrix, adjacency list).
2. Graph traversal algorithms.
3. Minimum spanning trees.
4. Shortest path algorithms.

1. Introduction to dynamic programming.
2. Solving problems using memorization and tabulation.
3. Classic DP problems (e.g., Fibonacci, knapsack, longest common
subsequence).

1. What is Django?
2. MVC architecture.
3. Setting up a Django project.
4. The manage.py script.
5. Practice: Creating a basic Django project.

1. What are Django apps?
2. Creating and registering apps.
3. The models.py, views.py, urls.py, and admin.py files.
4. Practice: Creating a simple app.

1. Defining models, fields, and relationships.
2. Migrations.
3. Interacting with the database using the Django ORM.
4. Practice: Creating models for a simple application (e.g., a blog, a to-
do list).

1. Customizing the admin interface.
2. Registering models.
3. Practice: Working with the admin interface to create and manage
data.

1. What are REST APIs?
2. HTTP methods (GET, POST, PUT, DELETE).
3. Status codes. JSON.
4. Practice: Designing a simple API for the application created in Module
2

1. Installing DRF.
2. Serializes: converting model instances to JSON and vice-versa.
3. Practice: Creating serializes for the models.

1. Using DRF's API view, Generic Views, and View sets.
2. Handling requests and responses.
3. Practice: Creating API endpoints for basic CRUD (Create, Read,
Update, Delete) operations.

1. Using DRF's routers.
2. Versioning APIs.
3. Practice: Setting up URL patterns for the API.

1. Basic authentication, Token-based authentication (using DRF's Token
Authentication).
2. Practice: Implementing token-based authentication for the API.

1. Permissions and roles.
2. Using DRF's permission classes.
3. Practice: Implementing permissions to restrict access to certain API
endpoints.

1. What is React? Why use React?
2. React vs. other frameworks (Vue, Angular).
3. Setting up React using create-react-app.
4. Overview of the folder structure.
5. Running the first React app (npm start).
6. Introduction to JSX.

1. What are React components? Functional vs. Class components.
2. Creating a functional component.
3. Understanding JSX and embedding expressions.
4. Component properties (props).
5. Nesting and reusing components.

1. What is state? Difference between state and props.
2. Using the useState hook for functional components.
3. Handling state updates.
4. Conditional rendering based on state.
5. Introduction to lifecycle methods (for awareness).

1. Handling events in React (onClick, onChange, etc.).
2. Passing arguments to event handlers.
3. Handling form submission.
4. Understanding synthetic events.

1. Using conditional rendering (if-else, ternary operators).
2. Rendering lists using map.
3. Using keys in lists.
4. Dynamic list rendering and managing state.

1. Introduction to React Router.
2. Setting up routes.
3. Navigation using Link and NavLink.
4. Passing parameters to routes.
5. Handling 404 pages.

1. Inline styling.
2. CSS stylesheets.
3. CSS Modules.
4. Styled-components (optional).
5. Best practices for styling React apps.

1. Using fetch and axios for GET requests.
2. Using use Effect for data fetching.
3. Handling loading and error states.
4. Displaying fetched data in components.

1. Creating and submitting data using POST requests.
2. Updating data with PUT requests.
3. Deleting data with DELETE requests.
4. Handling API responses and errors.

1. What is Redux? Why use it?
2. Setting up Redux in a React app.
3. Creating actions, reducers, and the Redux store.
4. Connecting Redux to React components with useDispatch and
useSelector.

1. Introduction to Redux Thunk for async actions.
2. Dispatching actions in asynchronous code.
3. Handling API calls with Redux.
4. Best practices for managing async actions.

1. Authentication concepts (login, logout, user roles).
2. Handling user sessions using tokens (JWT).
3. Protecting routes using Private Route components.
4. Storing authentication state in Redux.

1. Implementing role-based access (admin vs. user).
2. Using local Storage to persist user sessions.
3. Logout functionality and session expiration.
4. Handling authentication errors.

1. Preparing the app for deployment (building the app).
2. Deploying to vercel.
3. Handling environment variables for deployment.

1. Design and implement a user-friendly interface using modern web
technologies.

1. Build efficient database schemas using SQL or NoSQL databases.

1. Develop RESTful APIs for seamless frontend-backend
communication.

1. Master version control and collaboration using Git.

1. Deploy your application to the Azure cloud for scalability and security.

1. What is Cloud Computing?
2. Types of Clouds.
3. Cloud Computing Models – SaaS / PaaS / IaaS.
4. Data Centres and Availability Zones.
5. Overview of a Cloud Platform (Microsoft Azure).
6. Exploring Various Cloud Resources.

1. What is DevOps?
2. Azure DevOps Walkthrough.

1. Continuous Integration.
2. Continuous Deployment.

1. AI and its Applications.
2. Machine Learning Concepts.
3. Difference Between Machine Learning and AI.

1. Generative AI, LLM, and Prompt Engineering.
2. Natural Language Processing.
3. AI-Based Hands-on Project.

1. Learn how to handle real-world interview scenarios thru practice
sessions with tech leads and hiring managers from top-tier
organizations.

2. Meet & Greet: Learn how to effectively greet the interviewers and
establish the first impression.

3. How to Present Yourself: Learn how to present yourself
professionally, including mastering body language, attire, and clear
communication to make a strong first impression.

1. We will train you to answer complex technical questions confidently,
emphasizing problem-solving and practical knowledge application.

2. Behavioral Questions: Learn how to respond to behavioral questions
using the STAR method, showcasing your interpersonal skills,
teamwork, and ability to handle workplace challenges.

1. Power Dressing.
2. Strong Communication.
3. Time Management.
4. Leadership Quality.