Full Stack Development & AI Agents

Key Topics:

What is an Application

Types of Applications

Web Application Fundamentals

Web Technologies: Frontend (HTML, CSS, JavaScript, React)

Web Technologies: Backend (Python, Java, Node.js)

Web Technologies: Databases (SQL: MySQL, PostgreSQL; NoSQL: MongoDB)

Software Development Life Cycle (SDLC)

SDLC Phases: Planning, Analysis, Design, Implementation, Testing, Deployment, Maintenance

Key Topics :

Waterfall vs. Agile Methodologies

The Agile Mindset

Popular Agile Frameworks

Scrum Overview & Pillars

Scrum Roles (Product Owner, Scrum Master, Dev Team)

Scrum Events (Sprint, Planning, Daily Scrum, Review, Retrospective)

Scrum Artifacts (Product Backlog, Sprint Backlog, Increment)

Writing User Stories

Epics and Themes

Acceptance Criteria

Estimating User Stories

Managing Backlogs

Tools: Google Sheets, Azure Boards

Key Topics :

The Importance of Computing Power

Key Computing Technologies: CPU (Central Processing Unit)

Key Computing Technologies: GPU (Graphics Processing Unit)

Introduction to Cloud Computing

Cloud Service Models: IaaS (Infrastructure as a Service)

Cloud Service Models: PaaS (Platform as a Service)

Cloud Service Models: SaaS (Software as a Service)

Key Topics :

What is Artificial Intelligence (AI)?

How AI Works?

Machine Learning (ML) Fundamentals

Deep Learning (DL) Fundamentals

What is Generative AI?

Large Language Models (LLMs)

Image Generation Models

AI in Everyday Learning

Key Topics :

Customer Relationship Management (CRM)

Human Resource Management Systems (HRMS)

Retail & E-Commerce Applications

Healthcare Applications

Key Topics :

Introduction to Web Development & Client-Server Architecture

HTML Document Structure & Semantic HTML5

Text, Links & Media Elements

Lists & Tables

Forms & Input Elements with Validation

Accessibility Best Practices

Key Topics :

CSS Fundamentals & Selectors (Specificity)

Box Model, Typography & Colors

Layouts & Positioning

Flexbox for One-Dimensional Layouts

CSS Grid for Two-Dimensional Layouts

Responsive Design & Media Queries

Transitions & Animations

CSS Variables & Modern Features

Key Topics :

Bootstrap Setup & Grid System (12-Column Layout)

Utility Classes (Spacing, Colors, Display)

Components: Buttons, Cards, Alerts, Badges

Navigation & Forms

JavaScript Components: Modals, Carousels, Tooltips

Responsive Design with Bootstrap

Customization & Theming

Key Topics :

JavaScript Basics & Integration with HTML

Variables (let, const) & Data Types

Operators (Arithmetic, Comparison, Logical)

Control Flow (if/else, switch)

Loops (for, while, do-while, for...in, for...of)

Functions (Declaration, Expression, Arrow Functions)

Scope & Hoisting

Key Topics :

Advanced Functions (Arrow Functions, IIFE)

Callbacks & Higher-Order Functions

Closures & Function Scope

Recursion

Arrays: Creating, Accessing, Modifying

Mutating Methods (push, pop, splice, sort)

Non-Mutating Methods (slice, concat, join)

Array Iteration (forEach, map, filter, reduce, find, some, every)

Destructuring & Spread Operator

Key Topics :

Objects: Creating, Accessing, Methods

Object Destructuring & Spread Operator

Object Methods (keys, values, entries, assign)

Template Literals & Multi-line Strings

Enhanced Object Literals

Computed Property Names

ES6+ String Methods

Symbols & Iterators

let, const & Block Scope

Key Topics :

DOM Fundamentals & Tree Structure

Selecting Elements (getElementById, querySelector)

Manipulating Content, Attributes & Styles

Creating & Removing Elements

DOM Traversal (Parent, Children, Siblings)

Event Handling (addEventListener)

Mouse & Keyboard Events

Form Events & Validation

Event Object & Propagation (Bubbling, Capturing)

Event Delegation Pattern

Key Topics :

Synchronous vs Asynchronous JavaScript

Call Stack, Web APIs & Event Loop

Callbacks & Callback Hell

Promises (Creating, Chaining, Handling Errors)

Promise Methods (all, race, allSettled, any)

Async/Await Syntax

Error Handling with try/catch

Fetch API for HTTP Requests

Working with REST APIs

Local Storage & Session Storage

Key Topics :

Introduction to TypeScript & Setup

Type Annotations & Type Inference

Primitive Types (string, number, boolean)

Arrays & Tuples

Objects & Interfaces

Function Types & Overloading

Union & Intersection Types

Type Narrowing & Type Guards

Literal Types

Type Aliases & Enums

Key Topics :

Classes (Properties, Methods, Constructor)

Access Modifiers (public, private, protected)

Static Members & Abstract Classes

Generics (Functions, Classes, Interfaces)

Generic Constraints

Utility Types (Partial, Required, Readonly, Pick, Omit)

Mapped Types

Conditional Types

Declaration Files

TypeScript with Modern Frameworks

Key Topics :

What is React? Why React?

Setting up Development Environment (Node.js, npm)

Creating React App with create-react-app / Vite

Project Structure Overview

Functional Components vs Class Components

JSX Syntax and Its Advantages

Embedding Expressions in JSX

JSX Attributes (className, htmlFor, camelCase)

Rendering Elements

Key Topics :

Understanding Props (Properties)

Passing Data to Components via Props

PropTypes for Type Checking

Default Props

Introduction to React Hooks

useState Hook for State Management

Updating State and Re-rendering

Event Handling in React (onClick, onChange, onSubmit)

Controlled vs Uncontrolled Components

Form Handling with State

Key Topics :

useEffect Hook (Side Effects, Data Fetching)

Dependency Array in useEffect

Cleanup Functions

useRef Hook (DOM Access, Persisting Values)

useMemo Hook (Performance Optimization)

useCallback Hook (Memoizing Functions)

useReducer Hook (Complex State Logic)

useLayoutEffect vs useEffect

Custom Hooks (Creating Reusable Logic)

Rules of Hooks

Key Topics :

Styling in React:

Inline Styles with JSX

CSS Modules for Local Styles

Styled-Components (CSS-in-JS)

Context API:

Creating Context (createContext)

Provider and Consumer Pattern

useContext Hook

Global State Management

React Router v6:

Setting up React Router

BrowserRouter, Routes, Route

Link and NavLink Components

useNavigate Hook (Programmatic Navigation)

Dynamic Routes with useParams

Nested Routes with Outlet

Protected Routes

Key Topics :

React Children and Composition

Higher-Order Components (HOCs)

Render Props Pattern

Redux Toolkit:

Store Configuration

Slices and Reducers

useDispatch and useSelector Hooks

Async Thunks for API Calls

Axios Integration for API Calls

Error Boundaries

React Performance Optimization

Code Splitting with React.lazy and Suspense

Deployment (Vercel)

Key Topics :

What is Node.js? Why Node.js?

Node.js Architecture (V8 Engine, Event Loop)

Blocking vs Non-Blocking I/O

Installing Node.js and npm

Node Version Manager (nvm)

Creating Your First Node.js Application

Understanding package.json

npm vs yarn vs pnpm

Node.js Modules System (CommonJS vs ES Modules)

Built-in Modules: fs, path, os, http

Creating Custom Modules

Debugging Node.js Applications

Environment Variables with dotenv

Key Topics :

Introduction to Express.js

Setting up Express Application

Routing Basics (GET, POST, PUT, DELETE)

Route Parameters and Query Strings

Middleware Concept and Usage

Built-in Middleware (express.json, express.static)

Custom Middleware Functions

Error Handling Middleware

Building RESTful API Endpoints

HTTP Status Codes and Best Practices

Request and Response Objects

CORS Configuration

Express Router for Modular Routes

Postman/Thunder Client for API Testing

Key Topics :

Introduction to NoSQL Databases

MongoDB Architecture and Features

Installing MongoDB (Local & Atlas Cloud)

MongoDB Compass GUI

CRUD Operations with MongoDB Shell

MongoDB Data Types and Documents

Collections and Databases

Introduction to Mongoose ODM

Defining Mongoose Schemas

Schema Types and Validation

Mongoose Models and Queries

Creating, Reading, Updating, Deleting Documents

Query Methods: find(), findOne(), findById()

Update Methods: updateOne(), findByIdAndUpdate()

Delete Methods: deleteOne(), findByIdAndDelete()

Mongoose Middleware (Pre/Post Hooks)

Key Topics :

Schema Design Patterns

Data Modeling: Embedding vs Referencing

One-to-One Relationships

One-to-Many Relationships

Many-to-Many Relationships

Population (Joining Documents)

Virtual Properties

Indexes and Performance Optimization

Aggregation Pipeline Basics

$match, $group, $project, $sort stages

$lookup for Joins

Text Search in MongoDB

Data Validation with Mongoose

Custom Validators

Schema Methods and Statics

Query Helpers

Key Topics :

User Authentication Fundamentals

Password Hashing with bcrypt

JSON Web Tokens (JWT)

Creating and Verifying JWT Tokens

User Registration and Login API

Protected Routes with Middleware

Authorization and Role-Based Access Control

Express Session Management

Cookie Handling

API Security Best Practices

Input Validation with express-validator

Rate Limiting and DDoS Protection

Helmet.js for Security Headers

File Upload with Multer

Image Storage (Local & Cloud)

Error Handling Strategies

Logging with Morgan/Winston

Environment Configuration (dev, staging, prod)

Deployment to Render/Railway/Vercel

MongoDB Atlas Production Setup

Key Topics :

Introduction to Python & Environment Setup

Python Interpreter Installation (Windows/Mac)

IDE Setup (Visual Studio Code)

Python Syntax & Keywords (35 keywords)

Identifiers & Naming Conventions

Variables & Memory Management

Data Types (Simple & Complex)

Type Conversion & Type Casting

Operators (Arithmetic, Comparison, Logical, etc.)

Conditional Statements (if, elif, else, match-case)

Loops (while, for) & range() function

Control Flow (break, continue, pass)

User Input with input() function

Key Topics :

String Definition & Rules

String Indexing (Positive & Negative)

String Slicing (start:end:step)

String Operations (Concatenation, Repetition)

String Formatting (f-strings, format())

String Immutability Concept

Case Conversion Methods

Search Methods (find, index, count)

Checking Methods (isalpha, isdigit, etc.)

Trimming Methods (strip, lstrip, rstrip)

Replacement & Split/Join Methods

String Alignment Methods

Key Topics :

Simple vs Complex Data Types

Lists: Creation, Indexing, Slicing

List Operations & Methods

Adding Elements (append, insert, extend)

Removing Elements (remove, pop, clear)

Searching & Counting (index, count)

Sorting & Reversing (sort, reverse)

List Comprehensions

Tuples: Creation & Operations

Tuple Immutability

Tuple Packing & Unpacking

Lists vs Tuples Comparison

Key Topics :

Dictionaries: Creation & Access

Dictionary Operations & Methods

Keys, Values, Items Methods

Dictionary Comprehensions

Nested Dictionaries

Sets: Creation & Properties (UUU)

Set Operations (Union, Intersection, Difference)

Mathematical Set Operations

Subset & Superset Checks

Frozen Sets & Immutability

Practical Applications

Key Topics :

Collections Module (namedtuple, Counter, defaultdict, deque)

Iterators & Iteration Protocol

Custom Iterators

Generators & yield Statement

Generator Expressions

Memory Efficiency Concepts

Lambda Functions

Higher-Order Functions (map, filter, reduce)

Functional Programming Concepts

Generator Pipelines

Key Topics :

Function Definition & Calling

Function Parameters & Arguments

Positional Arguments

Keyword Arguments

Default Arguments

Arbitrary Positional Arguments (*args)

Arbitrary Keyword Arguments (kwargs)

Return Statements

Multiple Return Values

Local & Global Scope

Global Keyword Usage

Built-in Functions

User-Defined Functions

Lambda Functions (IIFE)

Function Documentation (Docstrings)

Recursive Functions

Key Topics :

Introduction to Modules

Types of Modules (Built-in, User-Defined, External)

Importing Techniques

Creating User-Defined Modules

Common Built-in Modules (math, random, datetime, os, sys)

Package Structure & Creation

**init**.py File Purpose

Nested Packages

pip Package Manager

Installing External Packages

requirements.txt Management

Popular External Packages (requests, pandas, numpy)

Module Best Practices

Key Topics :

File Operations Basics (CRUD)

open() Function & File Modes

Reading Files (read, readline, readlines)

Writing Files (write, writelines)

Append Mode Operations

File Path Operations

Directory/Folder Management (os, shutil)

Working with CSV Files

csv.reader & csv.writer

csv.DictReader & csv.DictWriter

Working with JSON Files

JSON Operations (dump, dumps, load, loads)

Data Serialization & Deserialization

File Handling Best Practices

Key Topics :

Exception Handling Fundamentals

try-except-else-finally Blocks

Catching Specific Exceptions

Raising Exceptions

Re-raising Exceptions

Custom Exception Classes

Built-in Exception Types

Decorators Introduction

Function Decorators

Decorator with Arguments

Multiple Decorators

Class Decorators

Practical Decorator Applications

Generators Deep Dive

Generator Expressions

Infinite Generators

Context Managers

Custom Context Managers

Key Topics :

OOP Fundamentals & Philosophy

Classes & Objects

Attributes (Instance & Class Variables)

**init** Constructor Method

Understanding self

Instance Methods

Class Methods (@classmethod)

Static Methods (@staticmethod)

**Four Pillars of OOP:**

**Encapsulation**: Access modifiers (public, protected, private)

**Inheritance**: Single, Multi-level, Multiple inheritance

**Abstraction**: Abstract classes, Abstract methods

**Polymorphism**: Method overriding, Duck typing

Method Overriding

super() Function

Special/Magic Methods (**str**, **repr**, **len**, etc.)

Abstract Base Classes (ABC module)

Real-World OOP Applications

Introduction to Databases & DBMS

Relational Database Management Systems (RDBMS)

ACID Properties (Atomicity, Consistency, Isolation, Durability)

Introduction to PostgreSQL

PostgreSQL Installation & Setup (Windows, Mac, Linux)

PostgreSQL Tools: psql, pgAdmin 4

Database Objects (Databases, Schemas, Tables)

Data Types: Numeric, Character, Date/Time, Boolean, Special types

Constraints: PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK, DEFAULT

Creating Databases and Tables

INSERT Operations and Data Population

Referential Integrity

SELECT Statement Basics

Column Aliases and Expressions

WHERE Clause and Filtering

Comparison Operators (=, !=, >, <,>=, <=) - Logical Operators (AND, OR, NOT) - BETWEEN, IN, LIKE operators - NULL handling (IS NULL, IS NOT NULL) - ORDER BY (Sorting data) - DISTINCT (Removing duplicates) - LIMIT and OFFSET (Pagination) - String Functions (UPPER, LOWER, CONCAT, SUBSTRING, etc.) - Numeric Functions (ROUND, CEIL, FLOOR, ABS, etc.) - Date and Time Functions (CURRENT_DATE, EXTRACT, DATE_TRUNC, etc.) - Aggregate Functions (COUNT, SUM, AVG, MIN, MAX) - GROUP BY and HAVING

Window Functions (ROW_NUMBER, RANK, LAG, LEAD, etc.) - JOIN Operations: - INNER JOIN - LEFT JOIN / RIGHT JOIN - FULL OUTER JOIN - CROSS JOIN - SELF JOIN - Multi-table Joins - Join Optimization

Subqueries in WHERE, SELECT, FROM clauses

Correlated Subqueries

EXISTS and NOT EXISTS

IN and NOT IN with subqueries

Common Table Expressions (CTEs)

Recursive CTEs for hierarchical data

Multiple CTEs

Set Operators:

UNION and UNION ALL

INTERSECT

EXCEPT

UPDATE Statements

UPDATE with expressions

UPDATE with JOIN

DELETE Statements

DELETE with subqueries

TRUNCATE vs DELETE

Transaction Management

BEGIN, COMMIT, ROLLBACK

Savepoints

Transaction Isolation Levels

Concurrency Control

ALTER TABLE Operations

Adding, Modifying, Dropping Columns

Managing Constraints

Indexes and Performance

Index Types (B-tree, Hash, GIN, GiST)

Creating and Managing Indexes

When to use indexes

Views and Abstraction

Creating Views

Updatable Views

Materialized Views

Refreshing Materialized Views

Stored Functions

PL/pgSQL Programming Language

Function Parameters and Return Types

Control Structures (IF, CASE, LOOP)

Functions Returning Tables

Stored Procedures

Procedure vs Function differences

Exception Handling in PL/pgSQL

Triggers

BEFORE, AFTER, INSTEAD OF triggers

Trigger Functions

Audit Logging with Triggers

Data Validation with Triggers

Advisory Locks

Entity-Relationship (ER) Modeling

Entities, Attributes, Relationships

Relationship Types (1:1, 1:M, M:N)

ER Diagrams

Normalization Principles

First Normal Form (1NF)

Second Normal Form (2NF)

Third Normal Form (3NF)

Normalization Benefits and Trade-offs

When to Denormalize

Database Design Best Practices

Naming Conventions

Data Type Selection

Primary Key Strategies

Foreign Key Design

Query Optimization

EXPLAIN and EXPLAIN ANALYZE

Reading Execution Plans

Index Strategies

Query Rewriting Techniques

Performance Tuning

Database Statistics (ANALYZE)

VACUUM and Maintenance

Connection Pooling

Table Partitioning

Topics:

Introduction to Django (History, Features)

Django vs Other Frameworks

MVT Architecture (Model-View-Template)

Installing Django

Creating a Django Project (django-admin startproject)

Creating Django Apps (python manage.py startapp)

Project Structure Overview

Django Development Server

URL Routing Basics

First View and Template

Django Admin Panel Introduction

Settings Configuration

Topics:

Introduction to Django ORM

Defining Models (CharField, TextField, IntegerField, etc.)

Field Options: max_length, null, blank, default

Migrations: makemigrations and migrate

Django Shell for Database Operations

CRUD Operations with ORM:

Model.objects.create()

Model.objects.all(), .filter(), .get()

Model.objects.update(), .delete()

QuerySet Methods: values(), first(), last()

Model Relationships:

ForeignKey (One-to-Many)

ManyToManyField

OneToOneField

Registering Models in Admin

Topics:

Function-Based Views (FBVs):

Handling GET and POST requests

Rendering Templates

Context Data

Django Template Engine:

Template Inheritance ({% extends %}, {% block %})

Template Tags: {% if %}, {% for %}, {% url %}

Template Filters

Static Files Configuration

Django Forms:

Creating Forms (forms.Form)

ModelForm for Model-Backed Forms

Form Validation

Displaying Forms in Templates

Crispy Forms Integration

CSRF Protection

File Uploads (ImageField)

Topics:

Class-Based Views (CBVs):

CreateView, ListView, DetailView

UpdateView, DeleteView

Template Naming Conventions

success_url and reverse_lazy

User Authentication:

Django’s Built-in Auth System

User Model

Creating Custom User Profiles

User Registration View

Login/Logout Views

@login_required Decorator

Authentication in CBVs (LoginRequiredMixin)

Session Management

Password Reset Flow

Topics:

Introduction to Django REST Framework

Installing and Configuring DRF

Serializers:

Serializer vs ModelSerializer

Serialization & Deserialization

Nested Serializers

API Views:

@api_view Decorator

APIView Class

Generic Views (ListCreateAPIView, RetrieveUpdateDestroyAPIView)

ViewSets and Routers

Browsable API

Authentication in DRF:

Token Authentication

Session Authentication

JWT Authentication

Permissions (IsAuthenticated, IsAdminUser)

Pagination

Filtering and Searching

API Documentation with Swagger

Topics:

Python Prerequisites (Data Types, Control Flow, File Handling)

Comparison: Flask vs Django vs FastAPI

Why FastAPI? (Async, Validation, Auto-Documentation)

Setting up Virtual Environment

Installing FastAPI and Uvicorn

Creating Your First API Endpoint

Path Operations: GET, POST, PUT, DELETE

Understanding Decorators (@app.get, @app.post)

Auto-generated Documentation (Swagger UI & ReDoc)

Running the Development Server

Topics:

Path Parameters:

Defining Path Parameters

Type Hints and Validation

Path Parameter with Enums

Query Parameters:

Required vs Optional Parameters

Default Values

Multiple Parameters

Request Body:

Introduction to Pydantic Models

Defining BaseModel Classes

Automatic Data Validation

Nested Models

Optional Fields with Optional type

Response Models

Topics:

Introduction to ORMs (Object-Relational Mapping)

SQLAlchemy Setup and Configuration

Creating Database Models

Database Session Management (Dependency Injection)

Schemas vs Models (Pydantic vs SQLAlchemy)

CRUD Operations:

Create Records

Read Records (Single & Multiple)

Update Records

Delete Records

Database Migrations with Alembic

Relationships (One-to-Many, Many-to-Many)

Topics:

Organizing Code with APIRouter

Creating Modular Routers (blogs, users, auth)

Router Prefixes and Tags

Including Routers in Main App

Response Status Codes

HTTPException for Error Handling

Custom Exception Handlers

Repository Pattern for Database Operations

Dependency Injection Deep Dive

Environment Variables with python-dotenv

CORS Configuration

Topics:

Password Hashing with Bcrypt

User Registration Endpoint

OAuth2 Password Flow

JWT (JSON Web Tokens) Implementation:

Creating Access Tokens

Token Expiration

Verifying Tokens

OAuth2PasswordBearer Dependency

Protecting Routes with Authentication

Getting Current User from Token

Login/Logout Functionality

Role-Based Access Control (RBAC) Basics

API Testing with Postman/Thunder Client

Topics:

Large Language Models fundamentals

Transformer architecture

Comparing major LLMs (GPT, Claude, Gemini, DeepSeek)

Evolution of LLMs from GPT-1 to 2026 frontier models

LLM architecture and tokenization

Model selection for different use cases

Cost optimization strategies

Topics:

Advanced prompt engineering techniques

Context engineering and design

Reasoning mode optimization

Reducing hallucinations

Zero-shot, few-shot, and chain-of-thought prompting

Multimodal prompting (text, image, audio)

Domain-specific prompt design

Topics:

OpenAI, Anthropic, Google, and DeepSeek APIs

LangChain 1.0 fundamentals

Create_agent abstraction

Middleware systems for customization

Multi-provider integration

Streaming and batching

Function calling and structured outputs

Cost-optimized pipelines

Topics:

Vector databases (ChromaDB, Pinecone, Qdrant)

Building production RAG pipelines

Agentic RAG and self-improving retrieval

MCP-Enhanced RAG

Embedding strategies

Hybrid search (semantic and keyword)

Document processing at scale

Hallucination reduction techniques

Topics:

Streamlit and Gradio interfaces

LangGraph Platform deployment

Cost optimization strategies

AI governance and EU AI Act compliance

API security and rate limiting

Monitoring and observability

Scaling strategies

Integration with enterprise tools

Topics:

Agentic AI fundamentals (plan, reason, act)

LangChain 1.0 Agents with middleware

Model Context Protocol (MCP)

Tool integration patterns

Enterprise adoption and use cases

Agent architectures and design patterns

Topics:

LangGraph 1.0 architecture

State management and graph-based logic

Node caching for development

Pre/Post hooks for guardrails

Building AI workflows

Production use cases

Topics:

Parallel execution with deferred nodes

Conditional routing and decision trees

Iterative refinement loops

Type-safe streaming

Essay evaluation systems

Customer feedback routing

Multi-stage approval workflows

Quality-gated content generation

Topics:

Durable state management

Built-in persistence (PostgreSQL, Redis)

Human-in-the-loop (HITL) implementations

Multi-day workflow support

Enterprise compliance and audit trails

Restart and failure recovery

Topics:

LangGraph Platform deployment

Multi-agent system design

Google A2A Protocol for agent-to-agent communication

LangSmith observability and monitoring

MCP security model

Prompt injection prevention

Compliance and audit trails

Agent guardrails and safety