Data Engineering & AI Agents

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

Key Topics :

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

Key Topics :

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

Key Topics :

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

Key Topics :

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

Key Topics :

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

Key Topics :

Business Intelligence fundamentals and modern analytics

Power BI components and architecture

Interface navigation and first report creation

Understanding Desktop vs. Service capabilities

Key Topics :

File, database, cloud, and web source connectivity

Import vs. DirectQuery vs. Live Connection

Data source settings and credential management

Performance considerations for connection modes

Key Topics :

Power Query interface and applied steps

Data profiling and quality assessment

Essential transformations: filtering, splitting, merging

Reshaping: pivot, unpivot, grouping

Combining queries: append and merge operations

Key Topics :

Star schema vs. snowflake schema design

Creating and managing table relationships

Primary and foreign keys

Hierarchies and date dimension tables

Data model optimization strategies

Key Topics :

Data visualization principles and chart selection

Core visualizations: charts, tables, maps, KPIs

Interactive elements: slicers, filters, bookmarks, drill-through

Dashboard layout and mobile optimization

Storytelling with data

Key Topics :

DAX syntax and structure

Calculated columns vs. measures

Essential functions: aggregation, logical, text, date/time

CALCULATE and FILTER functions

Creating KPIs and business metrics

Key Topics :

Time intelligence functions: YTD, MTD, QTD

Prior period comparisons and growth rates

Filter context vs. row context

Variables and iterator functions

DAX performance optimization

Key Topics :

Custom visuals from AppSource

Advanced chart types: waterfall, funnel, decomposition tree

R and Python integration

AI visuals: Key Influencers, Q&A, Smart Narratives

Dynamic visuals with parameters

Key Topics :

Publishing and workspace management

Dashboards vs. reports

Data refresh and gateway configuration

Sharing strategies and Power BI apps

Integration with Teams, SharePoint, Excel, PowerPoint

Key Topics :

Power BI admin portal and tenant settings

Row-Level Security (RLS) and Object-Level Security (OLS)

Incremental refresh and aggregations

Dataflows and deployment pipelines

Performance optimization and capacity management

Enterprise licensing models

APIs and embedded analytics

Key Topics :

Microsoft Fabric fundamentals and architecture

Fabric workloads (Data Factory, Data Engineering, Warehouse, Science, Real-Time Intelligence, Power BI)

Licensing and capacity units (F2-F2048)

Workspaces and tenant structure

Platform comparisons (Databricks, Snowflake)

Migration paths from Azure Synapse

Key Topics :

OneLake architecture and concepts

Delta Lake and Parquet file formats

ACID transactions and versioning

OneLake shortcuts to external data sources

OneLake Catalog and data discovery

Security and access control

Key Topics :

Lakehouse fundamentals and components

Creating and managing Lakehouses

Medallion architecture (Bronze, Silver, Gold layers)

SQL Analytics Endpoint

Delta table operations and optimization

Time travel queries

Key Topics :

Data Factory capabilities and connectors

Data pipelines creation and configuration

Dataflows Gen2 and Power Query

M language fundamentals

Database mirroring (Azure SQL, Cosmos DB, PostgreSQL)

Pipeline orchestration and error handling

CI/CD for pipelines

Key Topics :

Apache Spark in Fabric

Fabric Notebooks and Copilot

PySpark DataFrames and transformations

Spark SQL queries and optimization

Spark job definitions and scheduling

AI functions (Summarization, Classification, PII obfuscation)

Key Topics :

Fabric Data Warehouse overview

T-SQL support and user-defined functions

Schema design and table management

Star schema and dimensional modeling

Slowly Changing Dimensions (SCD)

SQL Database in Fabric

Performance optimization

Key Topics :

Real-Time Intelligence overview

Eventstreams and streaming sources

Kusto Query Language (KQL)

Eventhouse and KQL databases

Graph in Fabric for relationship modeling

Maps for geospatial analytics

Real-time dashboards and alerting

Key Topics :

Power BI integration with Fabric

Direct Lake mode and storage modes

Semantic models and relationships

DAX fundamentals and syntax

Row-level security (RLS) and object-level security (OLS)

Incremental refresh and aggregations

Report development and Copilot

Key Topics :

Data Science experience in Fabric

Exploratory data analysis

ML model training and versioning

MLflow and experiment tracking

Semantic Link (SemPy) integration

Batch scoring and predictions

Key Topics :

Copilot across workloads (Notebooks, SQL, KQL, Pipelines, Reports)

Data Agents for conversational AI

Operations Agents for monitoring

Fabric IQ and ontology models

AI Functions integration

Azure AI Foundry integration

Key Topics :

User Data Functions overview

Python-based serverless functions

VS Code extension for development

Integration with Notebooks, Pipelines, and SQL

Testing and deployment

Key Topics :

Fabric security model

Authentication and authorization

Row-level and column-level security

Dynamic data masking

Microsoft Purview integration

Data lineage and catalog

Compliance and auditing

Key Topics :

Fabric admin portal and tenant settings

Capacity management and SKUs

Monitoring Hub and performance dashboards

Query and pipeline monitoring

Git integration and deployment pipelines

CI/CD patterns for Fabric

Key Topics :

Query and performance optimization

Partition strategies and caching

Enterprise architecture patterns

Data mesh implementation

Migration strategies

Developer tools and extensibility (Fabric CLI, APIs)

Integration with Azure and third-party services

Key Topics :

DP-600 exam structure and skills measured

DP-700 Fabric Data Engineer certification

Practice test strategies

Hands-on labs alignment

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