Course Objective & Scope
Many models perform well in a notebook yet never reach production. This introductory programme walks through the end-to-end flow: saving a scikit-learn or PyTorch model, turning it into an endpoint with FastAPI, packaging it with Docker and releasing it behind a simple health check.
Participants learn the difference between batch and online deployment, the model registry concept and the essential metrics to watch after release. The course runs on a sample model from the organisation itself, and ends with a reusable deployment template and a pre-release checklist.
Who Should Attend?
- Data scientists taking models to production for the first time
- Backend developers working alongside ML teams
- AI engineers starting their MLOps journey
- Prerequisite: basic Python and command-line skills
Key Takeaways
- Save and version a model in a reloadable format
- Write and test a simple REST endpoint for a model
- Package the model service as a Docker image
- Choose correctly between batch and online deployment
- Start monitoring core metrics such as latency, error rate and prediction distribution
Curriculum
From Notebook to Production: The Deployment Lifecycle
- Training, packaging, release and monitoring steps
- Batch and online deployment scenarios
Saving Models and the Model Registry
- joblib, pickle and framework-specific formats
- Version and stage management with MLflow Model Registry
Your First Prediction Endpoint with FastAPI
- Input validation with Pydantic
- Model loading and the prediction function
- Testing via the Swagger UI
Packaging with Docker
- Writing a Dockerfile and managing dependencies
- Reducing image size and adding a health check
Post-Release Monitoring and Rollback
- Latency, error rate and prediction distribution
- Simple rollback and a pre-release checklist
Other Courses in This Category
-
Fundamentals of REST and gRPC for model services: HTTP/JSON design, OpenAPI, Protocol Buffers, streaming RPCs and performance comparison. For developers who want to pick the right protocol and build their first service.
- Live Course
- 5 modules
-
Synchronous and asynchronous inference patterns: request-response, queue-based processing (Celery, Redis, Kafka), job polling, webhooks and async Python. For engineers designing long-running model calls that scale.
- Live Course
- 5 modules
-
A comparison of the three core inference modes: batch scoring with Spark and Airflow, REST-based real-time services and streaming inference with Kafka/Flink. For data and ML teams choosing the right mode for a business need.
- Live Course
- 5 modules
-
Saving models safely and portably: pickle/joblib risks, TorchScript, SavedModel, ONNX, safetensors and GGUF formats, packaging with MLflow and version compatibility. For ML engineers and data scientists.
- Live Course
- 5 modules
-
Model serving architecture patterns: embedded models, model-as-a-service, serverless, edge, multi-model and LLM gateway designs, and how platforms like KServe, Triton, Ray Serve and vLLM fit in. For architects and senior ML engineers.
- Live Course
- 5 modules
-
Balancing p95/p99 latency, throughput and unit cost in model serving: dynamic batching, quantization, caching, GPU/CPU selection and load-testing optimisation. For ML and platform engineers building scalable, cost-effective inference infrastructure.
- Live Course
- 5 modules
Get in touch
