Build 12 end-to-end AI Use Cases (inc. Gen & Agentic AI)

In this lecture, we discussed the AI tech stack in traditional AI at a high level. We started off with an overview of the three main layers: the Application Layer (user-facing tools like chatbots and dashboards), the Model Layer (where models are built, trained, and evaluated), and the Infrastructure Layer (which provides computing power, storage, and deployment tools). Then we looked at key vertical components like programming languages, version control, MLOps, and Responsible AI that cut across all layers. Finally, we outlined how each layer will be explored in detail with practical tools and workflows, and wrapped up by highlighting why a clear understanding of this tech stack is essential for anyone aiming to build and deploy real-world AI systems.

In this lecture, we discussed the application layer of the AI tech stack in detail. First, we explored APIs and model interfaces, which act as bridges between trained models and user applications. Then we looked at how AI models are embedded into products using tools like Streamlit, Retool, and Gradio. Next, we covered BI and visualization tools like Power BI and Tableau that turn model outputs into business-friendly insights. After that, we discussed feedback and monitoring systems, which track user behavior to ensure models stay accurate and fair. Finally, we examined client interfaces and UX design, highlighting how tools like React or Flutter enable smooth human-AI interaction across devices, including edge environments. Each of these components was explained with practical examples and block diagrams to show how they fit into end-to-end AI solution architectures.

In this lecture, we explored the model layer of the AI tech stack, which forms the core of any traditional AI system. We started with Exploratory Data Analysis (EDA) to understand data patterns and quality, followed by data preparation and feature engineering, which ensures the data is clean and usable for modeling. Then we covered model training and tuning, where we select the right algorithms, train the model, and optimize it through techniques like grid search. Next, we discussed model review and governance, emphasizing fairness, interpretability, security, and compliance using tools like SHAP, Fairlearn, and AIF360. We then looked at model deployment and serving, where models are packaged and exposed via APIs using tools like Docker, FastAPI, and Flask. This was followed by model monitoring, which ensures performance and ethical integrity through drift detection and live dashboards. Finally, we covered automated retraining, triggered by new data or performance drops, to keep models up-to-date and reliable. Altogether, this lecture outlined a complete end-to-end ML lifecycle playbook—essential for building robust, scalable, and responsible AI systems.

In this lecture, we explored the infrastructure layer of the AI tech stack, which forms the backbone of any scalable AI system. We began with an overview of the four main components: compute and training infrastructure, data storage and management, model serving infrastructure, and system monitoring. First, we discussed different compute processors like CPUs, GPUs, TPUs, and NPUs, and the environments—local, cloud, on-prem, and hybrid—where AI models are trained. Then we looked at data storage types such as cloud storage, data warehouses, databases, and data lakes that support AI workflows. Next, we examined how trained models are deployed and served, including tools like Docker, SageMaker, and orchestration platforms. Finally, we covered system monitoring, including health checks, logging, and infrastructure automation using tools like Grafana, Prometheus, and Terraform. This lecture emphasized that without robust infrastructure, even the best AI models can't perform effectively—making this knowledge essential for anyone aiming to architect or deploy production-grade AI systems.

In this lecture, we explored the cross-cutting components of the AI tech stack that operate across all three core layers—application, model, and infrastructure. We started by clarifying the difference between languages, libraries, and frameworks, and examined how tools like Python, TensorFlow, Scikit-learn, and LangChain fit into modern AI development. Next, we looked at version control systems—including code, data, model, and infrastructure versioning—which ensure collaboration, reproducibility, and auditability. We then revisited MLOps best practices, showing how tasks like EDA, feature engineering, training, monitoring, and retraining align with the broader AI development lifecycle. Finally, we revisited NIST’s characteristics of trustworthy AI, mapping traits like safety, security, explainability, fairness, and accountability to different layers of the tech stack. This session tied together the foundational building blocks required to build scalable, responsible, and production-ready AI systems, reinforcing that good AI isn’t just about models—it’s about thoughtful engineering across the entire stack.

In this lecture, we looked at our first end-to-end implementation of a supervised learning classification project. We started off by revisiting the four types of machine learning—supervised, unsupervised, semi-supervised, and reinforcement learning—and focused specifically on classification, where the goal is to assign input data to discrete categories. Then, we discussed key concepts such as labeling requirements, popular models like logistic regression, and how supervised learning differs from regression tasks. After covering these fundamentals, we built a credit card default prediction app using logistic regression. We followed the entire ML lifecycle—starting with exploratory data analysis (EDA), creating new business-relevant features like payment ratio and number of delayed months, training the model, reviewing accuracy through metrics and confusion matrix, and finally, deploying it using Flask to serve predictions via a simple HTML-based web interface. We also explored the backend architecture and demonstrated how to turn a Jupyter notebook model into a fully deployable web app.

In this lecture, we looked at supervised learning for regression tasks at a high level. We started off by revisiting the idea of regression—how it predicts continuous values like house prices, rather than categories—and discussed its real-world business value in scenarios such as property valuation. Then, we explored a hands-on use case: building a complete ML app using linear regression to estimate housing prices based on features like number of rooms and distance from employment centers. We compared Streamlit and Flask for app development and learned why Streamlit is preferred for quick prototypes. Next, we discussed the importance of responsible feature selection, avoiding sensitive attributes that may act as proxies for race. We followed the full ML lifecycle: from exploratory data analysis to log-transforming skewed data, feature engineering, and training the model. Finally, we deployed the app using Docker for portability and consistency, demonstrating how containerization simplifies sharing and productionization of machine learning apps.

In this lecture, we discussed unsupervised learning at a high level. We started off by revisiting the core idea—how clustering helps group similar items from unlabeled data using techniques like K-Means. Then we explored a real-world business use case: segmenting retail customers using RFM (Recency, Frequency, Monetary) analysis. We walked through the full machine learning workflow—starting with data cleaning and feature engineering, then selecting the number of clusters using the elbow method, and finally profiling each cluster (e.g., Champions, At-Risk) based on customer behavior. Lastly, we looked at how to turn these insights into a visual dashboard using Streamlit, and even deployed the app to an AWS EC2 instance to make it publicly accessible.

In this lecture, we discussed Natural Language Processing (NLP) at a high level. We started off by understanding what NLP is and how it helps machines process human language through tasks like classification, translation, summarization, and information extraction. Then we explored how NLP is different from traditional machine learning, especially in the way it handles unstructured text data—right from cleaning and feature engineering to building rich feature vectors using methods like TFIDF, word embeddings, and sentence embeddings. Finally, we looked at an end-to-end hands-on demo of a real-world use case: a Resume-to-Job Description Matcher. We walked through each step of the AI pipeline, including data cleaning, vectorization, and cosine similarity-based matching, and built a Streamlit app that helps users find the top job matches for their resume. This session gave us both conceptual clarity and practical skills to work with text data using NLP techniques.

In this lecture, we looked at Computer Vision at a high level and built our first end-to-end app combining two key tasks: image classification and object detection. We started off by understanding what Computer Vision is, including tasks like segmentation, tracking, and 3D reconstruction. Then we compared how feature extraction in CV differs from traditional ML and NLP—highlighting how CNNs automatically extract features from image pixels. We dived deeper into CNN architecture, explored classification vs detection, and discussed how transfer learning with MobileNet and pre-trained YOLOv8 models can be used to build lightweight yet powerful vision solutions. Finally, we implemented a real-world use case for the auto insurance industry that detects vehicles in user-submitted images and classifies their type (car vs. jeep). We walked through the complete AI tech stack, trained and fine-tuned models, built an interactive Gradio app, and deployed it on Hugging Face Spaces for public access.

In this lecture, we looked at the Generative AI (GenAI) tech stack at a high level and how it compares with the traditional AI stack. We started off by understanding the structure of the GenAI stack—including the application, model, and infrastructure layers—and saw how GenAI introduces new concepts like off-the-shelf vs. custom apps and open-source vs. closed-source models. Then we discussed key factors to consider when selecting a GenAI model such as reasoning power, latency, multimodality, and governance. Finally, we looked at four major techniques to improve large language models (LLMs): prompt engineering, retrieval-augmented generation (RAG), fine-tuning, and pretraining, along with real-world examples and when to use each. This sets the foundation for our next session focused entirely on prompt engineering using ready-made GenAI tools.

In this lecture, we discussed prompt engineering at a high level, especially using GUI-based tools that are friendly for non-technical users. We started off by understanding what prompt engineering is, why it matters in GenAI workflows, and how it simplifies tasks compared to traditional AI development. Then we explored key best practices like setting persona, defining task intent, providing context, and specifying output format, followed by a deep dive into common prompting techniques such as zero-shot, one-shot, few-shot, and chain-of-thought prompting. Finally, we looked at real tools—starting with OpenAI Playground for experimentation, and then walked through five real-world Gen ai apps to build a complete AI startup in just 15 minutes. We used ChatGPT for ideation, Gamma for design, Lovable for deployment, HubSpot for marketing, and Gemini Workspace for feedback analysis, showing how prompt engineering enables end-to-end app creation without any coding.

In this lecture, we looked at prompt engineering from a developer’s perspective at a high level. We started off by recapping how prompt engineering works for everyday users using no-code tools like Lovable. Then, we explored why using APIs and code is important—for automation, integration, structured outputs, and building agentic systems. We discussed the difference between OpenAI’s Chat Completions API and the newer, smarter Responses API, especially in terms of memory, tool use, and workflow. After that, we walked through how to set up the OpenAI API in Python, build simple chains using LangChain, and integrate tools like Gradio for UI. We also learned about the complete toolkit available for prompt engineers—including APIs, frameworks, prompt libraries, IDEs, testing tools, and evaluation platforms. Finally, we looked at how to build a resume optimization app from scratch using OpenAI’s API, LangChain, and Gradio, applying prompt engineering best practices. This marked our shift from traditional ML lifecycle to LLMOps, and sets the stage for the next two sessions on RAG and fine-tuning.

In this lecture, we discussed Retrieval-Augmented Generation (RAG) at a high level. We started off by revisiting previous sessions on prompt engineering—both no-code and developer-focused—and then introduced RAG as a clever way to bring external knowledge into LLMs in real time. We explored why RAG is powerful, including its ability to make models domain-aware, reduce hallucinations, avoid costly fine-tuning, and ensure up-to-date responses while maintaining privacy. Then we walked through each component of a RAG pipeline step-by-step—from embedding user queries and chunked documents, to similarity search using cosine distance, to constructing augmented prompts and generating LLM outputs. Finally, we implemented a hands-on project: a resume-to-JD matcher that semantically compares resumes with hundreds of job descriptions using OpenAI’s embedding model and ChromaDB as a vector store. We tested the system, validated its performance using cosine scores, and deployed it with a Gradio interface for real-time matching—demonstrating how RAG can solve practical, high-impact problems in talent matching and recruitment.

In this lecture, we explored fine-tuning of large language models (LLMs) at a high level. We started off by revisiting why we adapt and align pre-trained models using techniques like prompt engineering, RAG, and now fine-tuning—especially when training from scratch is too resource-intensive. Then we discussed the limitations of prompting and RAG, such as lack of memory, context limits, and dependency on document quality, and introduced fine-tuning as a way to directly modify model behavior using labeled data. We then covered how fine-tuning works compared to pre-training, and explored six key types—especially instruction fine-tuning, RLHF, and LoRA. Through diagrams and examples, we learned how instruction tuning helps models follow tasks better, RLHF aligns models with human values using reward models, and LoRA enables low-cost, efficient fine-tuning by updating only small inserted matrices. Finally, we compared the three methods in terms of goals, data needs, efficiency, and when to use each—highlighting real-world examples like GPT-3.5 with RLHF and LLaMA-LoRA. This wraps up our Generative AI section, setting the stage for the next deep dive into Agentic AI—where LLMs don’t just respond, but act.

In this lecture, we looked at agentic AI at a high level. We started off by understanding how agentic AI differs from traditional and generative AI—especially through its iterative, goal-oriented workflows. Then we discussed the agentic AI tech stack, introducing four key components: tools, memory, planning, and action. Each of these was explored in detail, including real-world examples of how agents plan tasks, use memory for context, and call external tools like calendars or web search. Finally, we looked at how agentic systems break big goals into smaller steps using techniques like reflection, self-critique, and subgoal decomposition—making them more intelligent and adaptive than linear workflows. This sets the foundation for the next session on one of 2025’s hottest skills: Vibe Coding.

In this lecture, we explored the concept of Vibe Coding at a high level. We started off by understanding how Vibe Coding—using AI to generate code from plain language—is different from traditional prompt engineering. Then we discussed five core skills every Vibe Coder should master: thinking, giving context, debugging, creating checkpoints, and selecting the right frameworks. Each of these skills was explained through a real-world use case: building a custom CV optimizer app. We also looked at four powerful tools—Replit, Cursor, GitHub Copilot Workspace, and Lovable—that make Vibe Coding easier and more accessible. Finally, we examined three key principles for agentic code development: be precise, be organized, and be patient. This sets the stage for our next lecture on no-code agent builders—see you there!

In this lecture, we looked at how to build no-code AI agents at a high level. We started off by understanding the three categories of agentic AI tools—No Code Builders, Pro Code Frameworks, and Enterprise Workflow Agents—and then focused only on the no-code category. We discussed three types of no-code agent use cases: conversational assistants like ChatGPT, app builders like Replit, and workflow automation tools like n8n. Finally, we saw a hands-on demo of how to create a custom AI news aggregator using each of these tools—starting with ChatGPT’s standard interface and custom GPT builder, followed by building a Flask-based summarizer app on Replit, and wrapping up with an automated workflow that sends summarized AI news to Gmail using n8n.

In this lecture, we discussed code-based agentic AI at a high level. We started off by revisiting the agentic AI tool map and then focused on pro-code tools that give developers more control and flexibility. We looked at three main categories: IDE-centric copilots like Cursor and Replit that act as real-time coding assistants, agent libraries like LangGraph and Autogen that allow custom multi-agent workflows, and autonomous coding agents like Devin that can build apps and fix bugs independently. Finally, we demonstrated how to rebuild our credit card default prediction app using Cursor, where we saw how this agentic coding partner handled planning, scripting, debugging, and app creation—all in just a few minutes with minimal manual coding.

In this lecture, we looked at the Agentic AI toolmap from an enterprise perspective at a high level. We started off by recapping the earlier pro-code demo using Cursor, and then shifted focus to how workplace tools like Microsoft 365 and Google Workspace are embedding agentic AI for daily productivity. Then we explored three categories of enterprise agents: universal assistants like Microsoft Copilot and Google Gemini that work across apps; custom builders like Copilot Studio and Google Agent Space that let teams build their own agents; and ready-made vertical agents like Microsoft Copilot for Sales and Google NotebookLM that are tailored for specific business roles. Finally, we saw real-world capabilities like automatic slide creation in PowerPoint, email summarization in Gmail, and AI-powered research notebooks—highlighting how agentic AI is becoming a powerful teammate in modern office ecosystems.