Software Testing & 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 :

What is Software & Types of Software (System, Programming, Application)

Software Applications (Desktop, Web, Mobile)

What is Software Testing & Why Testing is Important

Real-world Testing Failures (Therac-25, Mars Climate Orbiter, Boeing 737 MAX)

Software Development Life Cycle (SDLC) - Overview

Quality, QA vs QC

Errors, Bugs, Defects & Failures

Software Testing Life Cycle (STLC) - Introduction

Key Topics :

SDLC Models Overview

Waterfall Model (Phases, Advantages, Disadvantages, When to Use)

V-Model (Verification & Validation Model)

BRS & SRS Documents

HLD & LLD Documents

Static Testing (Review, Walkthrough, Inspection)

Comparison of SDLC Models

White Box, Black Box & Grey Box Testing

When to use each testing approach

Key Topics :

Unit Testing

Concept & Responsibility

Unit Testing Techniques (Basis Path, Conditional Coverage, Loop Coverage)

Unit Testing Frameworks (JUnit, NUnit, pytest)

Integration Testing

Purpose & Importance

Integration Testing Types:

Incremental (Top-Down, Bottom-Up, Sandwich/Hybrid)

Non-Incremental (Big Bang)

Stubs & Drivers

Developer's Role in Testing

Key Topics :

System Testing Overview

Functional vs Non-Functional Testing

GUI Testing

Visual Design Verification

Functional Elements Testing

Content & Interaction Verification

Usability Testing

User-friendliness Assessment

User Satisfaction Metrics

User Acceptance Testing (UAT)

Alpha Testing

Beta Testing

Key Topics :

Object Properties Testing

Database Testing (SQL Basics for Testers)

CRUD Operations Validation

Data Integrity Testing

Error Handling Testing

Calculations/Computations Testing

Links Testing (Internal, External, Anchor, Email)

Cookie Testing

Session Testing

Practical Examples & Scenarios

Key Topics :

Performance Testing

Load Testing

Stress Testing

Spike Testing

Endurance/Soak Testing

Volume Testing

Scalability Testing

Security Testing (Authentication, Authorization, Encryption)

Recovery Testing

Compatibility Testing (Hardware, OS, Browser)

Installation Testing (Fresh, Upgrade, Uninstall, Reinstall)

Garbage Testing

Key Topics :

Regression Testing (Unit, Regional, Full)

Retesting vs Regression Testing

Smoke Testing (Build Verification Testing)

Sanity Testing

Exploratory Testing

Ad-Hoc Testing

Monkey Testing

Positive Testing vs Negative Testing

Globalization Testing

Localization Testing

Severity vs Priority

Key Topics :

Equivalence Class Partitioning (ECP)

Valid & Invalid Equivalence Classes

Practical Examples

Boundary Value Analysis (BVA)

Boundary Values & Conditions

Test Case Creation

Decision Table Testing

Conditions, Actions & Rules

Complex Business Logic Testing

State Transition Testing

States, Events, Transitions

State Transition Diagrams & Tables

Error Guessing (Experience-based Testing)

Key Topics :

Software Testing Life Cycle (STLC) Phases

Requirement Analysis

Test Planning

Test Case Development

Test Environment Setup

Test Execution

Test Closure

Test Plan (Contents, Creation, Sample)

Use Case, Test Scenario & Test Case

Understanding the Differences

Use Case Components (Actor, Action, Goal)

Test Case Design & Documentation

Test Case Components & Format

Test Data Management

Writing Effective Test Cases

Requirement Traceability Matrix (RTM)

Defect/Bug Life Cycle & Reporting

Key Topics :

Agile Methodology

Agile Principles & Values

Advantages & Disadvantages

Agile Frameworks Overview

Scrum Framework

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

Scrum Artifacts (Product Backlog, Sprint Backlog, Increment)

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

Burndown/Burnup Charts

Testing in Agile Environment

JIRA for Test Management

Creating Test Cases in JIRA

Bug Tracking & Reporting

Sprint Management

Version Control System (GitHub Basics)

Real Project Execution

Interview Preparation & Resume Building

Key Topics :

What is Automation Testing?

Benefits of Automation Testing (Speed, Reusability, Cost-Effectiveness)

When to Automate vs Manual Testing

Automation Testing Pyramid (Unit, Integration, E2E)

Introduction to Selenium WebDriver

Selenium Architecture & Components

Selenium vs Other Tools (Playwright, Cypress, Appium)

Setting Up Selenium Environment

Installing Java/Python & IDE (Eclipse, IntelliJ, VS Code)

Selenium WebDriver Installation & Configuration

Browser Drivers (ChromeDriver, GeckoDriver, EdgeDriver)

Writing Your First Selenium Script

Locating Elements:

ID, Name, Class Name

CSS Selectors (Basic & Advanced)

XPath (Absolute & Relative)

Link Text, Partial Link Text

Tag Name

WebDriver Commands:

Navigation (get, navigate, refresh, back, forward)

Browser Commands (maximize, minimize, fullscreen)

Getting Page Information (title, currentUrl, pageSource)

WebElement Commands:

Click, SendKeys, Clear

getText, getAttribute, getCssValue

isDisplayed, isEnabled, isSelected

Handling Different Web Elements:

Text Boxes, Buttons, Links

Radio Buttons & Checkboxes

Dropdowns (Select Class)

Multi-Select Dropdowns

Key Topics :

Waits in Selenium:

Implicit Wait

Explicit Wait (WebDriverWait)

Fluent Wait

Custom Expected Conditions

Handling Complex UI Elements:

Alerts & Pop-ups (accept, dismiss, getText, sendKeys)

Multiple Windows & Tabs (getWindowHandles, switchTo)

iFrames (switchTo.frame, switchTo.defaultContent)

Shadow DOM Elements

Dynamic Elements & AJAX Calls

Mouse & Keyboard Actions:

Actions Class (moveToElement, clickAndHold, dragAndDrop)

Right Click (contextClick)

Double Click (doubleClick)

Keyboard Actions (keyDown, keyUp, sendKeys)

Taking Screenshots:

Full Page Screenshots

Element Screenshots

Screenshots on Test Failure

Handling JavaScript:

JavaScriptExecutor Interface

Executing JavaScript Commands

Scrolling (scrollIntoView, scroll by pixels)

Handling Hidden Elements

File Upload & Download:

File Upload (sendKeys, Robot Class, AutoIT)

File Download Verification

Cookies Management:

addCookie, getCookies, deleteCookie, deleteAllCookies

Browser Logs & Network Monitoring

Test Automation Framework:

Framework Types (Data-Driven, Keyword-Driven, Hybrid, BDD)

Page Object Model (POM) Design Pattern

Page Factory Pattern

Creating Base Classes

Utility Classes (Excel, Properties, Screenshots)

TestNG Framework:

Annotations (@Test, @BeforeMethod, @AfterMethod, etc.)

Test Configuration (testng.xml)

Assertions (Hard vs Soft Assertions)

Parameterization & Data Providers

Grouping Tests

Parallel Execution

Test Listeners & Reporting

Data-Driven Testing:

Reading from Excel (Apache POI)

Reading from CSV, JSON, XML

Database Connectivity (JDBC)

Key Topics :

Introduction to Playwright

Why Playwright in 2026? (Speed, Reliability, Multi-Browser)

Playwright vs Selenium: Key Differences

Playwright Architecture & Features:

Auto-Waiting Mechanism

Network Interception

Multi-Tab & Multi-Context Support

Built-in Test Runner

AI-Powered Self-Healing Locators

Setting Up Playwright:

Installation (Node.js, Python, Java, .NET)

Playwright Configuration (playwright.config.js/ts)

Browser Installation

VS Code Extension

Writing Playwright Tests:

Test Structure (@playwright/test)

Page Object Model in Playwright

Fixtures & Hooks (beforeEach, afterEach)

Locators in Playwright:

Role-Based Locators (getByRole)

Text-Based Locators (getByText, getByLabel)

Test ID Locators (getByTestId)

CSS & XPath Selectors

Chaining Locators

Smart Locators (Auto-Retry)

Actions & Assertions:

Click, Fill, Type, Check, Select

expect() Assertions (toBeVisible, toHaveText, toContainText)

Auto-Waiting Assertions

Soft Assertions

Advanced Playwright Features:

Handling Multiple Pages & Contexts

Network Mocking & API Interception

Route Handling (route.fulfill, route.abort)

File Upload & Download

Geolocation & Permissions

Browser Context Isolation

Playwright Inspector & Debugging:

Codegen (Test Generator)

Playwright Inspector

Trace Viewer (Detailed Execution Trace)

Screenshots & Videos on Failure

Debug Mode (PWDEBUG=1)

Cross-Browser Testing:

Chromium, Firefox, WebKit

Mobile Emulation (iPhone, Android)

Device Descriptors

Responsive Testing

Playwright Test Runner:

Configuration & Projects

Parallel Execution & Sharding

Test Retry Strategy

Reporters (HTML, JSON, JUnit)

Test Annotations & Tags

Key Topics :

AI in Test Automation (2026 Trends):

Self-Healing Tests

AI-Powered Test Generation

Visual AI Testing

Intelligent Test Maintenance

Selenium with AI:

Healenium (Self-Healing Locators)

AI4Selenium Framework

OpenCV for Visual Testing

Integrating AI Libraries

Playwright AI Features:

Smart Locators with Auto-Retry

AI Test Generation Tools

Visual Comparison Testing

Headless & Headed Execution:

Headless Browser Testing (Benefits & Use Cases)

Headed Mode for Debugging

Docker Containers for Testing

Cross-Browser & Cross-Platform Testing:

Browser Compatibility Testing

Cloud-Based Testing (BrowserStack, Sauce Labs, LambdaTest)

Device Farms & Real Device Testing

Responsive Design Testing

Visual Testing & Screenshot Comparison:

Pixel-by-Pixel Comparison

Percy, Applitools Integration

Visual Regression Testing

Handling Dynamic Content

Performance Testing in Automation:

Page Load Time Measurement

Lighthouse Integration

Performance Metrics (FCP, LCP, TTI)

Network Throttling

Key Topics :

Version Control with Git:

Git Basics (clone, commit, push, pull)

Branching Strategies

.gitignore for Test Projects

GitHub

Continuous Integration/Continuous Deployment:

Introduction to CI/CD

GitHub Actions:

Workflow Configuration

Running Tests on Push/PR

Matrix Strategy (Multi-Browser)

Artifacts & Reports

Azure DevOps Pipelines

Docker for Test Automation:

Docker Basics

Selenium Grid with Docker

Playwright Docker Images

Docker Compose for Multi-Container Setup

Test Reporting & Dashboards:

Allure Reports (Installation & Configuration)

Extent Reports

Custom HTML Reports

Test Result Dashboards

Email Notifications

Test Management Integration:

JIRA/Zephyr Integration

TestRail Integration

Linking Test Cases to Requirements

Defect Tracking Automation

Best Practices for Automation Testing:

Test Design Principles

Naming Conventions

Code Reusability & Modularity

Avoiding Test Flakiness

Test Data Management

Parallel Execution Strategies

Test Maintenance & Refactoring

Logging & Debugging

Common Challenges & Solutions:

Handling Flaky Tests

StaleElementReferenceException

TimeoutException

NoSuchElementException

Dynamic Locators

Test Execution Speed Optimization

Key Topics :

Introduction to APIs (Application Programming Interfaces)

What is an API? Types of APIs (Web APIs, Library APIs, OS APIs)

Why API Testing is Important?

API Testing vs UI Testing

Benefits of API Testing (Speed, Reliability, Early Detection)

API Architecture Styles:

REST (Representational State Transfer)

SOAP (Simple Object Access Protocol)

GraphQL

RESTful API Concepts:

Resources & Endpoints

HTTP Methods:

GET (Retrieve Data)

POST (Create Data)

PUT (Update/Replace Data)

PATCH (Partial Update)

DELETE (Remove Data)

HEAD, OPTIONS

HTTP Status Codes:

1xx (Informational)

2xx (Success: 200, 201, 204)

3xx (Redirection: 301, 302)

4xx (Client Errors: 400, 401, 403, 404)

5xx (Server Errors: 500, 502, 503)

Request Components:

URL/URI Structure

Headers (Content-Type, Authorization, Accept)

Query Parameters

Path Parameters

Request Body (JSON, XML, Form Data)

Response Components:

Status Code

Headers

Response Body (JSON, XML, HTML)

Cookies

JSON (JavaScript Object Notation):

JSON Syntax & Structure

Objects, Arrays, Key-Value Pairs

Data Types (String, Number, Boolean, Null)

Nested JSON Objects

JSON Path Expressions

XML Basics:

XML Structure & Syntax

Elements, Attributes, Tags

XPath Expressions

API Documentation:

Reading API Documentation

Swagger/OpenAPI Specification

API Contracts

Key Topics :

Introduction to Postman

Installing Postman (Desktop & Web)

Postman Interface Overview:

Workspace, Collections, Environments

Request Builder

Response Viewer

Creating API Requests:

GET Requests

POST Requests with Body (JSON, XML, Form Data)

PUT & PATCH Requests

DELETE Requests

Setting Headers

Query & Path Parameters

Understanding Responses:

Response Status, Time, Size

Response Body (Pretty, Raw, Preview)

Response Headers

Cookies

Collections & Folders:

Creating Collections

Organizing Requests in Folders

Running Collections

Collection Runner

Sharing Collections

Variables in Postman:

Global Variables

Environment Variables

Collection Variables

Local Variables

Dynamic Variables ($guid, $timestamp, $randomInt)

Pre-request Scripts:

JavaScript in Postman

Setting Variables Dynamically

Generating Random Data

Date & Time Manipulation

Tests & Assertions:

Writing Tests in Postman

Chai Assertion Library

Status Code Assertions

Response Time Assertions

Response Body Validation:

Checking JSON Properties

Array Length Validation

Schema Validation

Header Validation

pm.expect() Assertions

Data-Driven Testing:

Using CSV Files

Using JSON Files

Iterating Through Test Data

Authentication in Postman:

No Auth

API Key

Bearer Token

Basic Auth

OAuth 1.0 & 2.0

Digest Auth

JWT (JSON Web Token)

Postman Mock Servers:

Creating Mock Servers

Using Mock Responses

Testing Without Backend

Postman Monitors:

Scheduled API Testing

Monitoring API Health

Email Notifications

Key Topics :

Introduction to API Test Automation

Requests Library (Python):

Installing Requests Library

Making HTTP Requests (get, post, put, patch, delete)

Passing Parameters & Headers

Request Body (JSON, Form Data)

Response Object:

status_code, text, json(), headers, cookies

Response Time (elapsed)

Session Objects

Authentication (auth parameter)

File Upload & Download

SSL Certificate Verification

Pytest for API Testing:

Pytest Installation & Setup

Writing Test Functions

Assertions (assert)

Fixtures (setup, teardown)

Parameterization (@pytest.mark.parametrize)

Test Organization

HTML Reports (pytest-html)

Framework Design:

Project Structure

Config Files

Utility Functions

Test Data Management

Logging

Reporting

Key Topics :

API Chaining:

Dependent API Calls

Extracting Data from Response

Using Response Data in Next Request

Database Testing with APIs:

Database Connectivity (JDBC, PyMySQL)

Validating API Response with Database

Data Integrity Testing

API Performance Testing:

Introduction to Performance Testing

Key Metrics (Response Time, Throughput, Latency)

Load Testing with JMeter

Stress Testing

Spike Testing

Endurance Testing

API Security Testing:

Authentication & Authorization Testing

SQL Injection Testing

XSS (Cross-Site Scripting) Testing

HTTPS & SSL/TLS Validation

API Key Security

Rate Limiting Testing

OWASP API Security Top 10:

Broken Object Level Authorization

Broken User Authentication

Excessive Data Exposure

Lack of Resources & Rate Limiting

Security Misconfiguration

Contract Testing:

What is Contract Testing?

Consumer-Driven Contracts

Pact Framework

Provider & Consumer Testing

GraphQL API Testing:

Introduction to GraphQL

GraphQL vs REST

GraphQL Concepts:

Queries (Fetching Data)

Mutations (Modifying Data)

Subscriptions (Real-time Updates)

Schema & Types

Resolvers

GraphQL Queries:

Fields & Arguments

Aliases & Fragments

Variables & Directives

Nested Queries

Testing GraphQL APIs:

Using Postman for GraphQL

Automating GraphQL Tests

Schema Validation

Error Handling

SOAP API Testing:

Introduction to SOAP

WSDL (Web Services Description Language)

SOAP Request Structure (Envelope, Header, Body)

Testing SOAP APIs with SoapUI

SOAP API Automation

Microservices Testing:

Introduction to Microservices

Testing Strategies for Microservices

Service Virtualization

Testing with Docker Containers

Key Topics :

API Test Automation Framework:

Hybrid Framework Design

Folder Structure

Configuration Management

Environment Management (Dev, QA, Staging, Prod)

Test Data Management

Utility Classes

Logging & Reporting

CI/CD Integration:

GitHub Actions:

Workflow for API Tests

Running Tests on Push/PR

Environment Secrets

Azure DevOps Pipelines

API Mocking & Virtualization:

Why Mock APIs?

Creating Mock Servers

WireMock (Java)

Mock Server (Node.js)

Using Postman Mock Servers

Service Virtualization Tools

Test Reporting:

Allure Reports

Extent Reports

Custom HTML Reports

Test Result Dashboards

API Testing Best Practices:

Test Case Design

Positive & Negative Testing

Boundary Value Testing

Error Handling Testing

Test Data Independence

Reusability & Maintainability

Clear Test Naming

Assertions Best Practices

Avoiding Hard-Coded Values

Environment Configuration

API Documentation Testing:

Validating Swagger/OpenAPI Spec

Documentation Accuracy

Example Validation

Monitoring & Observability:

API Monitoring Tools

Health Check Endpoints

Logging & Error Tracking

APM (Application Performance Monitoring)

Common API Testing Challenges:

Authentication Issues

Data Dependencies

Environment Differences

API Versioning

Response Time Variations

Rate Limiting

Interview Preparation:

API Testing Interview Questions

REST Assured Interview Questions

Postman Interview Questions

GraphQL Interview Questions

Coding Challenges

Resume Building for API Testers

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:

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