// What's Next · Now · Course 1: Foundations of AI and Machine Learning
Module 1: Introduction to AI/ML Environments
The environment end to end: ingestion, the lakehouse layers, the model frameworks, deployment, and the monitoring that closes the loop.

Raw data sources
- IoT: Sensor and device telemetry: the streaming source that arrives continuously rather than in batches.
- DB: Existing operational and analytical databases, the structured record of the business.
- External API: Third-party data and services pulled in over HTTP at ingest time.
- CRM, ERP: The customer and back-office systems (Salesforce, SAP and peers) whose records describe the business directly.
Ingestion & orchestration
- Event Hub: Azure's streaming ingestion service: takes in millions of events per second and hands them to consumers or to storage.
- Azure Data Factory: The orchestration layer: schedules and chains the pipelines that move and transform data across services.
Processing & transformation
- Azure Databricks: The Apache Spark-based analytics engine where raw data is cleaned, joined and engineered into features.
Storage
- Azure Data Lake Storage: The landing store, in medallion layers: bronze holds raw ingested data, silver holds cleaned and conformed data, gold holds the aggregates ready for consumption.
- Azure SQL Database: The relational store for structured, transactional and reporting workloads.
- Azure Cosmos DB: The distributed NoSQL store for globally replicated, low-latency reads and writes at scale.
Model development frameworks
- TensorFlow: Google's framework for building and training deep models, from research through to production serving.
- PyTorch: The research-first deep learning framework that dominates papers and experimentation.
- scikit-learn: The classical ML library: regression, classification, clustering, and the evaluation tooling around them.
- Azure Machine Learning SDK: The Azure-native API for tracking experiments, packaging models and managing their lifecycle.
Deployment platforms
- Azure Kubernetes Service (AKS): Managed Kubernetes, for containerised services that scale on demand.
- Azure Machine Learning Service: The managed serving and lifecycle layer for trained models: endpoints, retraining and rollout.
- Azure App Service: The managed web app host for APIs and front ends, without managing the underlying machines.
- Azure Functions: Event-driven serverless compute: run a small unit of logic in response to a trigger and pay per execution.
Continuous monitoring
- Azure Monitor: Platform-wide metrics and logs: the health of every Azure resource in one place.
- Application Insights: Application-level telemetry: requests, dependencies, exceptions and user flows inside the deployed app.
// Module notes
What the module is about
AI/ML infrastructure is the cloud-based tools, services and resources that carry a model through its entire lifecycle. The course frames it as three pillars, and the argument is that infrastructure comes before technique.
- Data pipelines: how data is ingested, processed, stored and served to models.
- Model development frameworks: the libraries that build, train and evaluate models.
- Deployment platforms: the services that put a trained model into production.
Before supervised learning or pre-trained LLMs, you need to know how data flows through systems, how models are built inside frameworks, and how they reach production.
The working environment
The course runs in Azure Machine Learning Studio. The lab is set up in four moves:
- Workspace: create one at ml.azure.com, then add a notebook.
- Kernel: select the Python - AzureML kernel, which carries the machine learning libraries the course uses.
- Resources: the lab runs on a resource group with virtual machines and SSH access.
- Reproducibility: save the setup as an Azure Resource Manager template so it can be recreated.
Data sources and pipelines
A pipeline is a series of automated processes that move data from source to destination, transforming it along the way. Sources come in four kinds:
- Relational databases: SQL Server, MySQL, PostgreSQL.
- NoSQL stores: Azure Cosmos DB, MongoDB.
- Cloud object storage: Azure Blob Storage, Amazon S3.
- Real-time streams: IoT sensors, APIs.
The pipeline then runs through four stages:
- Ingestion: collects the data, in real time or in batches; Azure Data Factory schedules and orchestrates it.
- Processing and transformation: cleans, normalises, aggregates and engineers features; Azure Databricks, built on Apache Spark, does the heavy work.
- Storage: Azure Data Lake Storage for raw unstructured data, Azure SQL Database for structured data that needs advanced queries, Azure Blob Storage for files and media.
- Access and utilisation: Azure Machine Learning trains the models, Power BI reports on them.
Model quality is bounded by data quality, which is why the pipeline comes first.
Choosing a framework
Model development is the cycle of selecting an algorithm, training on data while tuning hyperparameters, and evaluating until the model generalises to new data. Four frameworks dominate:
- TensorFlow: deep learning, with eager execution for prototyping and graph execution for optimised runs; TensorFlow Serving for production.
- PyTorch: the research favourite, with dynamic computation graphs that are easier to debug; TorchScript for deployment.
- scikit-learn: traditional machine learning, with regression, classification, clustering, preprocessing and evaluation behind one consistent API.
- Azure Machine Learning SDK: the Azure-native layer, integrating with Data Factory, Databricks and AKS; AutoML for baselines, experiment tracking and managed deployment.
The selection factors are the nature of the problem, data type and size, performance requirements, ease of use, deployment and maintenance, and total cost of ownership.
Choosing a deployment platform
Deployment takes a trained model and makes it available in a real environment: as a service, inside a web application, or on a device. Azure offers four routes:
- Azure Kubernetes Service: containerises the model and runs it across a cluster, with autoscaling, load balancing and high availability; suits large-scale, high-traffic systems.
- Azure Machine Learning Service: deploys a model as a RESTful endpoint in a few clicks; adds automated machine learning and model management.
- Azure App Service: hosts web applications and APIs with built-in scaling, security and monitoring.
- Azure Functions: serverless and event-driven, so you pay per execution and the model runs only when triggered.
Six factors decide the choice: deployment speed, cost efficiency, ease of use, scalability, updates and maintenance, and security and compliance. The module's tips follow from those factors:
- Azure Machine Learning Service for rapid prototyping and low-latency predictions.
- Azure Functions or Azure Container Instances for infrequent or temporary deployments.
- AKS for enterprise scale, and reserved instances for long-term runs.
Monitoring and maintenance
Deployment is not the end of the loop. Two services watch a deployed model:
- Azure Monitor: platform metrics and logs across every Azure resource.
- Application Insights: application telemetry, meaning requests, dependencies, exceptions and user flows.
Azure DevOps sits beside them for continuous integration and deployment, so updates, rollbacks and testing are automated rather than manual. The module points onward from here to model observability and drift detection as the next layer of the same problem.
How the course is assessed
The course is graded in six parts:
- Five quizzes, 15% each: AI/ML applications; data management in AI/ML; selecting a framework; platform deployment; AI/ML concepts in practice.
- One peer review, 25%: draft your pitch to the C-suite.
It is the first of five courses in the Microsoft AI & ML Engineering Professional Certificate:
- AI and Machine Learning Algorithms and Techniques.
- Building Intelligent Troubleshooting Agents.
- Microsoft Azure for AI and Machine Learning.
- Advanced AI and Machine Learning Techniques and Capstone.
// Where this fits
This is the breakdown of the diagram above: what each component is, and why it sits where it does in the pipeline. The course page carries the picture; the certificate page carries the plan it belongs to.