DevOps with AI & 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

What You'll Learn:

Understanding DevOps culture and practices

The DevOps infinity loop and SDLC integration

Server fundamentals and types (Web, Database, Application)

Cloud computing introduction (AWS & Azure)

Networking basics (VPC, Security Groups, Ports, Protocols)

Hands-on: Launch and configure EC2 instances and Azure VMs

Key Topics :

Why Linux is essential for DevOps

Linux file system hierarchy and navigation

Essential CLI commands for file and directory management

User and group management

File permissions and ownership (chmod, chown)

Package management with APT

Shell scripting for automation

Hands-on: Automated web server deployment script **Key Technologies:** Ubuntu Linux, Bash, vi/vim, APT, Shell Scripting

Version control concepts and importance

Git architecture (Working Directory, Staging, Repository)

Basic Git operations (add, commit, push, pull)

Branching and merging strategies

Resolving merge conflicts

GitHub collaboration workflows

Pull requests and code reviews

GitHub webhooks for automation **Key Technologies:** Git, GitHub, Pull Requests, Webhooks, Forking Workflow

Software Development Life Cycle (SDLC)

Three-tier application architecture

Database setup and management (PostgreSQL)

Backend development with Node.js and Express

Frontend development with ReactJS

Web server configuration (NGINX)

Process management with PM2

Hands-on: Complete LMS application deployment **Key Technologies:** PostgreSQL, Node.js, ReactJS, NGINX, PM2, NPM

CI/CD concepts and benefits

Jenkins installation and configuration

Creating Jenkins jobs (Freestyle and Pipeline)

Jenkins Master-Worker architecture

Writing Jenkinsfiles (Pipeline as Code)

GitHub webhook integration

Static code analysis with SonarQube

Artifact management with Nexus Repository

Hands-on: Complete CI/CD pipeline for LMS

Containerization concepts and benefits

Containers vs Virtual Machines

Monolithic vs Microservices architecture

Docker architecture and components

Working with Docker images and containers

Docker networking (bridge, host, overlay)

Data persistence with Docker volumes

Writing Dockerfiles

Multi-stage builds for optimization

Docker Compose for multi-container applications

Pushing images to Docker Hub

Hands-on: Containerize complete LMS application **Key Technologies:** Docker, Docker Compose, Dockerfile, Docker Hub, Docker Volumes

Container orchestration challenges

Kubernetes architecture (Master and Worker nodes)

Kubernetes objects (Pods, Deployments, Services)

ConfigMaps and Secrets management

Persistent storage in Kubernetes

Service discovery and load balancing

Ingress controllers for routing

Kubernetes namespaces

Scaling applications (manual and auto-scaling)

Rolling updates and rollbacks

Hands-on: Deploy LMS on local Kubernetes cluster

AWS EKS (Elastic Kubernetes Service) overview

EKS cluster architecture

Creating and managing EKS clusters

Node groups and scaling

AWS Load Balancer Controller

EKS networking and security

IAM roles for service accounts

Monitoring EKS clusters

Cost optimization strategies

Hands-on: Deploy LMS on production EKS cluster

Infrastructure as Code (IaC) concepts

Terraform architecture and workflow

HCL (HashiCorp Configuration Language)

Terraform providers (AWS, Azure, GCP)

Resources, variables, and outputs

Terraform state management

Modules for reusability

Remote state storage (S3 + DynamoDB)

Terraform workspaces

Best practices and project structure

Observability pillars (Metrics, Logs, Traces)

Prometheus architecture and data model

PromQL query language

Service discovery and exporters

Alerting rules and AlertManager

Grafana installation and configuration

Building dashboards and visualizations

Monitoring Kubernetes with Prometheus

Application instrumentation

Hands-on: Complete monitoring stack for LMS

GitHub Actions overview and benefits

Workflow syntax and structure

Events, jobs, and steps

GitHub-hosted vs self-hosted runners

Secrets and environment variables

Matrix builds for parallel execution

Artifact sharing between jobs

Docker image building and pushing

Kubernetes deployment automation

Hands-on: Complete GitHub Actions pipeline for LMS

Introduction to AI-assisted development

Cursor AI features and capabilities

AI pair programming for DevOps

Generating shell scripts with AI

Writing Dockerfiles with AI assistance

Creating Kubernetes manifests using AI

Terraform code generation

Debugging and troubleshooting with AI

Best practices for AI-assisted DevOps

Hands-on: AI-powered DevOps automation workflows

Key Topics :

An overview of Azure DevOps services and its ecosystem. 2. **Azure Boards**

Introduction to project management using Azure Boards. 3. **Azure Repos**

Managing code repositories with Azure Repos. 4. **Azure Pipelines**

Automating builds, tests, and deployments with Azure Pipelines. 5. **Creating Pipelines in Azure DevOps**

Step-by-step guide to setting up your first pipeline.

Key Topics :

Implementing agile methodologies using Azure Boards. 2. **Basic Concepts of Azure Boards**

Understanding work items, sprints, and scrum features. 3. **Connecting Boards to GitHub**

Integrating Azure Boards with GitHub repositories. 4. **Work Items and Sprints**

Managing tasks and sprints in Azure Boards for agile development. 5. **Azure Boards Integrations**

Enhancing Azure Boards with integrations for extended functionalities.

Key Topics :

Overview and key concepts of using Azure Repos for source control. 2. **Branches and Cloning in Azure Repos**

Managing branches and cloning repositories for development workflows. 3. **Import Code from GitHub**

Steps to import existing codebases from GitHub into Azure Repos. 4. **Search Your Code in Repos**

Utilising search functionalities within Azure Repos for code management. 5. **Azure Repos Integrations**

Extending Azure Repos capabilities with external integrations.

Key Topics :

Strategies for deploying applications using Azure Pipelines. 2. **CI Triggers and YAML Basics**

Configuring continuous integration triggers and understanding YAML for pipeline configuration. 3. **Setting Up CI Build**

Creating a continuous integration build process with Azure Pipelines. 4. **Adding Tests to the Pipeline**

Incorporating testing into the CI/CD pipeline for quality assurance. 5. **Agents and Tasks**

Understanding agents and tasks within Azure Pipelines for build and deployment processes.

Key Topics :

Managing dependencies and packages with Azure Artifacts. 2. **Connection Feeds and Views in Artifacts**

Configuring feeds for package sharing and views for package management. 3. **Connecting Azure Artifacts to Azure Pipelines**

Automating package deployment with Azure Pipelines integration. 4. **What are Azure Test Plans?**

Introduction to planning, executing, and tracking tests with Azure Test Plans. 5. **Testing Web Apps**

Strategies and best practices for testing web applications using Azure Test Plans.

Key Topics :

Understanding the benefits and considerations of using cloud services.

Exploring Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS), Software-as-a-Service (SaaS).

Differentiating between Public Cloud, Private Cloud, and Hybrid Cloud models.

Key Topics :

Introduction to the types of compute services offered by Azure and their use cases. 2. **Azure Storage**

Overview of Azure's storage options and recommendations for different data types and usage scenarios. 3. **Azure Networking**

Basic concepts of Azure networking solutions including virtual networks, subnets, and connectivity options. 4. **Azure Database Services**

Introduction to Azure's database services for relational and non-relational data.

Key Topics :

Understanding Azure pricing, cost management tools, and Azure support plans and services. 2. **Azure Governance**

Azure governance methodologies, including Role-Based Access Control (RBAC), resource locks, and Azure Policy.

Key Topics :

Utilizing the Azure Portal and Azure Command-Line Interface (CLI) for managing Azure services. 2. **Azure Management Tools**

Introduction to Azure management tools like Azure Monitor, Azure Resource Manager, and Azure Policy for efficient resource management.

Key Topics :

Overview of Azure App Service plans, networking for an App Service, and container images.

Understanding how to deploy and manage web apps and APIs using Azure App Services.

Key Topics :

Overview of Cloud Computing, AWS Global Infrastructure, AWS Pricing Models 2. **AWS Account Setup & Security**

Account Setup, Billing Management, AWS Networking Basics (VPC Overview) 3. **AWS Identity and Access Management (IAM) Basics**

Users, Roles, Policies, Security Best Practices 4. **AWS Command Line Interface (CLI)**

Installing & Configuring AWS CLI, Basic AWS CLI Commands 5. **AWS CloudWatch Overview**

Monitoring Resources, Setting up CloudWatch Alarms 6. **AWS CloudTrail Overview**

Event History and Monitoring, Logging and Tracking Changes

Key Topics :

Launching EC2 Instances , Instance Types, Pricing Models 2. **AWS EC2 Auto Scaling Basics**

Auto Scaling Groups , Scaling Policies 3. **Amazon Elastic Load Balancing (ELB)**

Configuring ELB , Load Balancing Traffic 4. **AWS Lambda Introduction**

Overview of Serverless Computing , Lambda Functions, Use Cases 5. **Amazon API Gateway Basics**

Setting up REST APIs with Lambda

Key Topics :

Subnets, Route Tables, Internet Gateways 2. **AWS Key Management Service (KMS)**

Encryption Keys and Policies 3. **Amazon Cognito**

Managing User Pools for Authentication 4. **AWS Security Best Practices**

Identity & Resource Security

Key Topics :

Buckets, Object Storage, and Permissions 2. **Amazon S3 Advanced Features**

Versioning, Lifecycle Policies 3. **Amazon Elastic Block Store (EBS) Overview**

Creating and Managing Volumes

Key Topics :

Analyzing Costs and Setting Budgets 2. **AWS Trusted Advisor & Savings Plans**

Cost Optimization with AWS Savings Plans

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

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

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

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

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

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

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

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

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

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

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