RPA & Intelligent Automation

You can write clean, object-oriented Python code and structure production-ready scripts inside virtual environments.

1. Python for data and AI4 hrs
   • Python 3.12 syntax and pattern matching
   • Virtual environment creation with python -m venv
   • Package management via pip and pip-tools
   • PEP 8 style guide enforcement with ruff
   • Dependency locking with requirements.txt
2. Data types, control flow and functions4 hrs
   • List, dict, and set comprehensions
   • Generator functions and yield expressions
   • Exception hierarchies and try-except-finally blocks
   • Function closures and custom decorators
   • Type hinting with the typing module (Union, Optional, Callable)
3. Object-oriented Python4 hrs
   • Class definitions and the __init__ constructor
   • Dunder methods including __repr__, __len__, and __getitem__
   • Inheritance, super(), and method overriding
   • Structured data records using @dataclass
   • Abstract base classes via abc.ABCMeta and @abstractmethod
4. Working with files, APIs and JSON4 hrs
   • Filesystem path operations using pathlib.Path
   • HTTP requests with requests.Session and status code handling
   • json.loads, json.dumps, and custom serializers
   • Environment variable configuration with python-dotenv
   • Pagination loops and rate-limit handling for external APIs
5. Your AI development environment (Jupyter, venv)4 hrs
   • JupyterLab server setup and configuration
   • ipykernel registration for isolated virtual environments
   • Repository tracking with git init, branch, and commit
   • .gitignore configuration for notebooks and virtual environments
   • IPython cell magic commands (%timeit, %prun, %matplotlib inline)
6. Debugging and testing Python scripts4 hrs
   • Interactive breakpoint debugging using pdb and breakpoint()
   • Test discovery and assertions with pytest
   • Parametrized testing with @pytest.mark.parametrize
   • Isolating network boundaries with unittest.mock.patch
   • Standard library logging levels and StreamHandler setup

Hands-on project: Build a CLI-based data ingestion utility that fetches paginated JSON records from a REST API, validates schema integrity with Pydantic, writes clean output records to disk, and isolates failures using Python logging.

You can calculate vector transformations, derivatives, and probability distributions required to understand model optimization.

1. Linear algebra: vectors and matrices2 hrs
   • Vector spaces, norms (L1, L2), and dot products
   • Matrix multiplication rules and rank calculation
   • Matrix transpose, determinant, and inverse operations
   • Eigenvalues and eigenvectors computation with numpy.linalg.eig
   • Singular Value Decomposition (SVD) mechanics and compression
2. Calculus and gradients intuitively2 hrs
   • Secant lines, limits, and derivative definitions
   • Partial derivatives of multivariable cost functions
   • The chain rule across composite multi-layer functions
   • Gradient vectors and directional derivative vectors
   • Visualising non-convex loss surfaces and saddle points
3. Probability and statistics essentials2 hrs
   • Probability mass functions (PMF) and density functions (PDF)
   • Expectation, sample variance, and covariance matrices
   • Gaussian distribution, Z-scores, and the Central Limit Theorem
   • Maximum Likelihood Estimation (MLE) formulations
   • Bayes' theorem, prior probabilities, and posterior distributions
4. Optimisation and gradient descent2 hrs
   • Objective functions and learning rate hyperparameters
   • Batch gradient descent vs Stochastic Gradient Descent (SGD)
   • Convergence criteria and patience-based stopping rules
   • Navigating local minima, ill-conditioned curvature, and plateaus
   • Momentum updates and exponentially weighted moving averages
5. How the maths shows up in models2 hrs
   • Affine transformations: Wx + b matrix formulation
   • Non-linear activation functions: Sigmoid, Softmax, and ReLU math
   • Loss formulations: Mean Squared Error and Cross-Entropy loss
   • Backpropagation equations via recursive chain rule applications
   • Tracking tensor shape transformations across matrix layers
6. Numerical stability in code2 hrs
   • IEEE 754 floating-point precision limits (fp32, fp16, fp64)
   • Preventing exponential overflow and underflow in Softmax
   • Log-sum-exp trick implementation in numerical code
   • Finite-difference numerical gradient checking
   • Vectorized performance profiling with cProfile

Hands-on project: Implement a multivariable linear regression optimizer from scratch using pure NumPy matrix math, tracking loss trajectories across iterations and proving numerical gradient convergence.

You can clean, reshape, and explore messy tabular datasets using NumPy and Pandas before feeding them to models.

1. NumPy for numerical computing2 hrs
   • numpy.ndarray memory layout and strided indexing
   • NumPy broadcasting rules across mismatched tensor dimensions
   • Vectorized mathematical reductions (sum, mean, std along axes)
   • Boolean indexing, filtering, and numpy.where conditional logic
   • Array concatenation, stacking (hstack, vstack), and splitting
2. Pandas for data manipulation2 hrs
   • pandas.DataFrame and Series indexing with .loc and .iloc
   • Split-apply-combine aggregations with df.groupby() and .agg()
   • Relational operations: merge, inner/outer join, and concat
   • Datetime parsing, pd.to_datetime, and time-series resampling
   • Reshaping tables with pivot_table, melt, and stack/unstack
3. Cleaning and preparing real datasets2 hrs
   • Missing data diagnostics with isna() and fillna() strategies
   • Vectorized string operations and regular expression extractions
   • Categorical encoding using pd.get_dummies and category dtypes
   • Standardizing continuous scales with min-max and Z-score transforms
   • Duplicate row identification and removal with drop_duplicates()
4. Exploratory data analysis2 hrs
   • Descriptive statistics calculation with describe() and quantile()
   • Multicollinearity detection via Pearson and Spearman correlation matrices
   • Checking skewness, kurtosis, and normality distributions
   • Logarithmic and Box-Cox power transforms for skewed features
   • Outlier identification using Interquartile Range (IQR) and Z-scores
5. Visualising data with Matplotlib/Seaborn2 hrs
   • Object-oriented Matplotlib figure and axis subplots
   • Univariate distribution plotting with seaborn.histplot and kdeplot
   • Bivariate relationship analysis with scatterplot and regplot
   • Category comparisons using boxplot and violinplot
   • Figure export configurations (dpi, bbox_inches, tight_layout)
6. Optimising Pandas performance2 hrs
   • DataFrame memory footprint profiling with memory_usage(deep=True)
   • Downcasting numeric types (float64 to float32, int64 to int16)
   • Replacing costly apply() and iterrows() loops with vectorized methods
   • Reading large datasets in chunks with pd.read_csv(chunksize=...)
   • Arrow-backed string data types in Pandas 2.2

Hands-on project: Build an exploratory data pipeline that ingests a raw multi-thousand row CSV, removes anomalies, imputes nulls with domain-appropriate statistics, and outputs a clean dataset with an automated EDA visualization report.

You can train, evaluate, and tune classical machine learning models using scikit-learn while preventing data leakage.

1. How learning from data works4 hrs
   • Supervised vs unsupervised learning paradigms
   • Train, validation, and test split protocols (train_test_split)
   • K-fold and Stratified K-fold cross-validation mechanics
   • Identifying and preventing target leakage in feature preprocessing
   • The fit vs transform distinction in scikit-learn estimators
2. Regression and classification4 hrs
   • Ordinary Least Squares regression and R-squared calculation
   • Logistic regression mechanics and log-odds decision boundaries
   • Confusion matrix analysis: TP, FP, TN, and FN components
   • Precision, Recall, F1-score, and precision-recall trade-offs
   • Receiver Operating Characteristic (ROC) and AUC score evaluation
3. Decision trees, random forests and boosting4 hrs
   • Decision tree splitting criteria: Gini Impurity and Shannon Entropy
   • Tree regularization parameters (max_depth, min_samples_split)
   • Bagging mechanics and RandomForestClassifier ensembles
   • Gradient boosting theory and XGBoost / LightGBM implementations
   • Feature importance extraction and permutation importance
4. Model evaluation, overfitting and validation4 hrs
   • The bias-variance trade-off in empirical prediction models
   • L1 (Lasso) and L2 (Ridge) weight penalty regularization
   • Exhaustive hyperparameter tuning with GridSearchCV
   • Efficient parameter exploration using RandomizedSearchCV
   • Diagnosing high bias vs high variance with learning_curve
5. Feature engineering that improves models4 hrs
   • StandardScaler, RobustScaler, and OneHotEncoder transformers
   • Generating interaction terms with PolynomialFeatures
   • Handling mixed data types using ColumnTransformer
   • Composing full workflows with sklearn.pipeline.Pipeline
   • Writing custom transformers by subclassing BaseEstimator and TransformerMixin
6. Unsupervised learning foundations4 hrs
   • K-Means clustering mechanics and inertia evaluation
   • Determining cluster counts via the elbow method and silhouette score
   • DBSCAN density clustering and epsilon neighborhood tuning
   • Principal Component Analysis (PCA) for dimensionality reduction
   • Explained variance ratio analysis and scree plot interpretation

Hands-on project: Build an end-to-end customer churn prediction classifier using scikit-learn and XGBoost, packaged inside a Pipeline with preprocessing, hyperparameter search, and audited against test data leakage.

You can design and train custom feedforward neural networks using PyTorch with proper weight initialization and loss tracking.

1. Neural networks from the ground up4 hrs
   • Perceptron computation and biological analogies
   • Hidden layer representations and the Universal Approximation Theorem
   • Forward pass matrix equations across multi-layer networks
   • PyTorch autograd mechanics and backward() computational graphs
   • PyTorch Tensor creation, indexing, and GPU transfer with .to(device)
2. Activation, loss and optimisation4 hrs
   • Activation functions: ReLU, LeakyReLU, GELU, Sigmoid, and Tanh
   • Loss function selection: MSELoss, CrossEntropyLoss, and BCEWithLogitsLoss
   • Stochastic optimizers: SGD with momentum, RMSprop, and AdamW
   • Weight initialization techniques: Xavier/Glorot and He/Kaiming initialization
   • Vanishing and exploding gradient mechanics during backpropagation
3. Training, batching and regularisation4 hrs
   • Subclassing torch.utils.data.Dataset for custom data inputs
   • Configuring DataLoader: batch_size, shuffle, num_workers, and pin_memory
   • Preventing co-adaptation using Dropout layers
   • Normalisation techniques: BatchNorm1d and LayerNorm placement
   • Weight decay formulation (L2 regularisation) inside AdamW
4. Building networks in PyTorch/TensorFlow4 hrs
   • Subclassing torch.nn.Module and defining __init__ and forward()
   • Linear layer stacking using torch.nn.Sequential containers
   • Tensor shape reshaping via .view(), .reshape(), and .squeeze()
   • Switching network states between model.train() and model.eval()
   • Persisting and loading model weights via torch.save(model.state_dict(), path)
5. Debugging and improving models4 hrs
   • Learning rate scheduling: StepLR and CosineAnnealingLR policies
   • Gradient clipping to prevent explosions using torch.nn.utils.clip_grad_norm_
   • Diagnosing underfitting vs overfitting from train/val loss curves
   • Implementing custom early stopping logic based on validation loss
   • Enforcing deterministic execution with torch.manual_seed
6. Experiment tracking and metrics4 hrs
   • Initializing torch.utils.tensorboard.SummaryWriter instances
   • Logging scalar training and validation losses per iteration
   • Visualizing network computation graphs via add_graph()
   • Tracking weight and gradient histograms across training steps
   • Hyperparameter configuration logging using add_hparams()

Hands-on project: Build and train a custom multi-layer perceptron in PyTorch on an tabular dataset, implementing mini-batching, Dropout, LayerNorm, early stopping, and real-time loss tracking in TensorBoard.

You can process image tensors, build Convolutional Neural Networks, and apply transfer learning for image classification.

1. Images as data2 hrs
   • Digital image representations: RGB channels, bit depth, and coordinate spaces
   • Image reading and color space conversion (BGR to RGB) using OpenCV
   • Channel-first (NCHW) vs channel-last (NHWC) tensor memory layouts
   • Normalizing pixel values using dataset-specific mean and standard deviation
   • Data augmentation pipelines with torchvision.transforms.v2
2. Convolutional neural networks (CNNs)2 hrs
   • 2D convolution mechanics: kernel filters, receptive fields, and feature maps
   • Spatial dimensionality calculations: padding, stride, and dilation math
   • Downsampling with MaxPool2d and AvgPool2d layers
   • Feature map extraction with nn.Conv2d and nn.BatchNorm2d blocks
   • Global average pooling to replace dense classification parameters
3. Transfer learning with pre-trained models2 hrs
   • The torchvision.models architecture zoo (ResNet, ConvNeXt, EfficientNet)
   • Freezing backbone weights via param.requires_grad = False
   • Replacing classification heads with custom nn.Linear projection layers
   • Differential learning rates for backbone vs head layers
   • Fine-tuning strategies for small target datasets
4. Image classification and detection2 hrs
   • Bounding box coordinate systems: [x1, y1, x2, y2] vs [x, y, w, h]
   • Intersection over Union (IoU) calculation logic
   • Object detection architecture paradigms: two-stage vs single-stage detectors
   • Non-Maximum Suppression (NMS) thresholding to eliminate duplicate proposals
   • Mean Average Precision (mAP) evaluation metrics across classes
5. A hands-on vision project2 hrs
   • Dataset structuring using torchvision.datasets.ImageFolder
   • Accelerated training using torch.cuda.amp.autocast for mixed precision
   • Multi-class confusion matrix plotting with scikit-learn and Seaborn
   • Best-epoch model checkpointing based on validation loss thresholds
   • Visualizing network attention and decisions using Grad-CAM
6. Deployment preparation for vision models2 hrs
   • TorchScript model tracing via torch.jit.trace with sample inputs
   • Exporting PyTorch models to portable ONNX format via torch.onnx.export
   • Running ONNX models in Python using onnxruntime.InferenceSession
   • Image pre-processing benchmarks for low-latency web APIs
   • Batch inference throughput profiling on CPU vs GPU

Hands-on project: Fine-tune a pre-trained ResNet-50 vision model on a custom multi-class image dataset, apply data augmentations, achieve >90% validation accuracy, and export the final model to ONNX format.

You can tokenize text sequences, implement embedding layers, and fine-tune Transformer models for sequence classification.

1. Text preprocessing and tokenisation4 hrs
   • Text normalization: lowercasing, regex cleaning, and unicode stripping
   • Subword tokenization algorithms: Byte-Pair Encoding (BPE) and WordPiece
   • Hugging Face AutoTokenizer loading and vocabulary inspection
   • Handling batch padding, sequence truncation, and max_length constraints
   • Attention masks and special token injection ([CLS], [SEP], [PAD])
2. Word embeddings4 hrs
   • Continuous vector representations of words: Word2Vec and GloVe mechanics
   • PyTorch nn.Embedding lookup table mechanics and weight initialization
   • Measuring semantic vector similarity via Cosine Similarity
   • Visualizing high-dimensional embeddings using t-SNE projections
   • Out-of-vocabulary (OOV) tokens and subword embedding mitigation
3. The Transformer architecture4 hrs
   • Self-attention formula: Query, Key, Value matrix projections and scaling
   • Multi-Head Attention mechanics and parallel subspace representations
   • Sinusoidal and learned Positional Encodings
   • Transformer Encoder vs Decoder block topologies and feedforward sub-layers
   • Residual connections and Layer Normalization placement (Pre-LN vs Post-LN)
4. Using pre-trained language models4 hrs
   • Hugging Face Model Hub navigation and model card inspection
   • Instantiating AutoModelForSequenceClassification models
   • Inference pipelines using the transformers.pipeline high-level interface
   • Inspecting model configuration parameters via PretrainedConfig
   • Downloading, caching, and offline local model loading
5. Fine-tuning for your own tasks4 hrs
   • Formatting datasets using the Hugging Face datasets library
   • Configuring hyperparameters via TrainingArguments (learning_rate, warmup_ratio)
   • Executing distributed training loops using the Trainer class
   • Defining evaluation metrics using evaluate.load('accuracy') and F1
   • Saving fine-tuned checkpoints and tokenizer artifacts to disk
6. Evaluation and error analysis in NLP4 hrs
   • Generation evaluation metrics: BLEU, ROUGE-L, and Perplexity
   • Inspecting false-positive and false-negative misclassified text examples
   • Analysing model robustness against input token length variations
   • Domain adaptation challenges and vocabulary drift
   • Adversarial spelling perturbations and model vulnerability testing

Hands-on project: Fine-tune a pre-trained BERT model for multi-class ticket classification using Hugging Face Transformers, tracking evaluation metrics on a validation set and logging misclassifications for error analysis.

You can construct prompt chains, configure generation parameters, and build Retrieval-Augmented Generation systems using LangChain.

1. How large language models work4 hrs
   • Autoregressive causal language modeling and next-token prediction
   • Context window constraints and token-to-word compression ratios
   • Sampling decoding strategies: Temperature, Top-p (nucleus), and Top-k
   • Token cost calculations using tiktoken and API billing management
   • Differentiating System, User, and Assistant prompt roles
2. Prompt engineering and controlling output4 hrs
   • Zero-shot vs Few-shot in-context learning patterns
   • System prompt personas and negative instruction constraints
   • Enforcing valid JSON mode and Pydantic structured output parsing
   • Chain-of-Thought (CoT) and Step-Back reasoning prompt structures
   • Automating prompt evaluation with ground-truth test assertions
3. The Hugging Face and OpenAI ecosystems4 hrs
   • OpenAI Python client initialization and chat.completions.create
   • Streaming tokens via server-sent events using stream=True
   • Local inference with open-weights models (Llama, Mistral) via Ollama
   • Handling API rate limits with exponential backoff and tenacity retries
   • Asynchronous API execution using AsyncOpenAI
4. Retrieval-augmented generation (RAG)4 hrs
   • Document ingestion and recursive character text splitting
   • Generating text embeddings via text-embedding-3-small and Hugging Face models
   • Vector database operations: ChromaDB collection creation, indexing, and querying
   • Cosine similarity and Euclidean distance nearest-neighbor lookups
   • Augmenting context prompts with retrieved document metadata and source tags
5. Building apps with LangChain4 hrs
   • PromptTemplate and ChatPromptTemplate abstractions
   • Composing processing pipelines with LangChain Expression Language (LCEL)
   • VectorStoreRetriever configuration and k-nearest neighbor limits
   • Managing conversational multi-turn context with RunnableWithMessageHistory
   • Output parsing with PydanticOutputParser
6. Advanced RAG techniques4 hrs
   • Query transformation: Multi-query generation and hypothetical document embeddings (HyDE)
   • Contextual compression and reranking with Cohere Rerank API
   • Parent Document Retrieval and small-to-big chunk mapping
   • RAG quality evaluation using Ragas metrics (Faithfulness, Answer Relevance)
   • Hybrid retrieval: combining BM25 keyword search with dense vector embeddings

Hands-on project: Build an enterprise document question-answering system using LangChain and ChromaDB, implementing semantic chunking, embedding generation, source citations, and hallucination evaluation.

You can expose AI models behind FastAPI backends and build interactive frontend user interfaces using Streamlit.

1. Serving models behind an API2 hrs
   • FastAPI application setup and asynchronous route handlers (async def)
   • Request and response data validation with Pydantic v2 BaseModel
   • Dependency injection in FastAPI with fastapi.Depends
   • OpenAPI and Swagger UI auto-generated documentation endpoints
   • Cross-Origin Resource Sharing (CORS) middleware configuration
2. Building an interactive app with Streamlit2 hrs
   • Streamlit UI primitives: st.chat_input, st.chat_message, and st.status
   • Preserving conversational context using st.session_state
   • Optimizing heavy model and client initialization with @st.cache_resource
   • Handling document and image uploads via st.file_uploader
   • Multi-column layouts, sidebars, and reactive page updates
3. Connecting models to real data2 hrs
   • Database connectivity with SQLAlchemy and asynchronous engine sessions
   • Persisting user conversation histories and feedback scores to PostgreSQL
   • Caching repetitive inference outputs with in-memory TTL caches
   • Connection pooling configurations (pool_size, max_overflow)
   • Graceful error handling during database outages and timeouts
4. Guardrails, evaluation and cost2 hrs
   • Input prompt sanitization and prompt injection heuristic filters
   • Token usage accounting and cost calculations per authenticated user
   • API endpoint rate limiting using slowapi and IP address hashing
   • Fallback responses and circuit breaker patterns for downstream AI timeouts
   • Middleware for logging request duration and latency percentiles
5. Responsible and safe AI use2 hrs
   • Hallucination mitigation via source citation grounding checks
   • PII detection and automated data masking before third-party API calls
   • Auditing model outputs against enterprise content moderation rules
   • Providing clear system confidence signals to frontend users
   • Structuring thumbs-up and thumbs-down user feedback collection loops
6. Testing web services and UIs2 hrs
   • Unit testing FastAPI endpoints using starlette.testclient.TestClient
   • Mocking external LLM network responses in automated pytest suites
   • Writing reusable test fixtures for database and client connections
   • Testing error handling paths: 422 Unprocessable Entity and 500 statuses
   • End-to-end integration test execution across backend and mocked client

Hands-on project: Build and run a complete AI web application featuring an asynchronous FastAPI inference service with OpenAPI documentation and an interactive Streamlit chat interface that supports streaming token responses.

You can containerise AI models with Docker, track experiments, and deploy production services to cloud environments.

1. Packaging and versioning models2 hrs
   • Model serialization formats: joblib, safetensors, and state_dict
   • MLflow Model Registry: tracking runs, parameters, and artifact versions
   • Semantic versioning rules for AI services and backward compatibility
   • Packaging model weights separate from application container code
   • Checksum validation (SHA-256) to ensure weight artifact integrity
2. Containerising with Docker2 hrs
   • Writing clean Dockerfile instructions: FROM, WORKDIR, COPY, and RUN
   • Multi-stage Docker builds to eliminate build-time compilers and bloat
   • Layer caching optimization for pip dependencies
   • Container security: running processes under an unprivileged non-root USER
   • Configuring container HEALTHCHECK endpoints for orchestrators
3. Deploying models to the cloud2 hrs
   • Cloud container deployment options: Google Cloud Run, AWS ECS, or App Runner
   • Injecting secrets and API tokens via cloud environment variables
   • Configuring CPU, memory limits, and request concurrency thresholds
   • Horizontal autoscaling rules based on request volume and queue depth
   • Configuring TLS certificates and custom domain routing
4. Monitoring and detecting drift2 hrs
   • Data drift vs concept drift: statistical definitions and causes
   • Population Stability Index (PSI) and Kolmogorov-Smirnov distribution tests
   • Exporting application metrics to Prometheus via prometheus-fastapi-instrumentator
   • Logging inference payloads asynchronously for offline auditing
   • Setting up alert triggers for elevated error rates and p99 latency spikes
5. From notebook to product2 hrs
   • Refactoring experimental Jupyter notebooks into clean Python modules
   • Automated code linting and formatting with ruff and black
   • Structured JSON logging in production services using structlog
   • Graceful SIGTERM and SIGINT shutdown handling in web servers
   • Managing configuration profiles (dev, staging, prod) via pydantic-settings
6. CI/CD pipelines for AI services2 hrs
   • Defining workflow YAML files in .github/workflows
   • Automating code quality checks and pytest execution on Pull Requests
   • Building and tagging multi-platform Docker container images in CI
   • Publishing images securely to container registries (GHCR / Docker Hub)
   • Automated staging deployment triggers and rollback strategies

Hands-on project: Containerize the FastAPI inference application with a multi-stage Dockerfile under 350 MB running as a non-root user, write a GitHub Actions pipeline that runs pytest on pull requests, and deploy the container to a cloud host.

You can frame business challenges into ML problem statements, evaluate ROI, and navigate ethical compliance.

1. Framing a business problem as an AI task2 hrs
   • Mapping business goals to ML paradigms (classification, ranking, generation)
   • Defining primary business KPIs and proxy offline machine learning metrics
   • Establishing baseline benchmarks with rule-based heuristics before modeling
   • Assessing technical feasibility and data availability constraints
   • Scoping the Minimum Viable Product (MVP) vs long-term iterations
2. Data ethics, bias and fairness2 hrs
   • Identifying demographic bias in historical training datasets
   • Fairness metrics: Disparate Impact, Demographic Parity, and Equalized Odds
   • Auditing model predictions across protected sub-groups
   • Regulatory frameworks: GDPR right to explanation, EU AI Act, and DPDP Act 2023
   • Designing human-in-the-loop fallback procedures for high-stakes decisions
3. Choosing the right approach2 hrs
   • Evaluating rules vs classical ML vs fine-tuned transformers vs commercial LLMs
   • Cost-benefit trade-offs of build vs buy vs open-source models
   • Hardware requirements: CPU vs GPU inference costs per million requests
   • Latency constraints: real-time streaming vs asynchronous batch pipelines
   • Long-term engineering maintenance overhead of complex architectures
4. Measuring impact2 hrs
   • Designing randomized controlled A/B testing splits for AI features
   • Measuring statistical significance (p-values, confidence intervals) in online tests
   • Navigating offline evaluation gains that fail to produce online KPI lift
   • Establishing user feedback mechanisms for continuous active learning
   • Calculating Return on Investment (ROI) and total cost of ownership (TCO)
5. Case studies across industries2 hrs
   • E-commerce personalization and recommendation ranking architectures
   • Fintech real-time transaction fraud detection pipelines
   • Document processing and automated entity extraction in legal/finance
   • Conversational customer support bots and escalation workflows
   • Post-mortem analysis of high-profile production machine learning outages
6. Stakeholder communication and documentation2 hrs
   • Translating precision/recall trade-offs to business executives
   • Creating clear high-level system architecture diagrams using C4 modeling
   • Documenting data provenance, pipeline lineage, and model assumptions
   • Writing incident post-mortems and service level objective (SLO) definitions
   • Presenting technical results and risks to cross-functional leadership

Hands-on project: Draft a formal Machine Learning System Architecture and ROI Proposal for an enterprise use-case, specifying the business problem, baseline heuristic, target online KPIs, hardware budget, and compliance risk mitigations.

You can test an AI feature for the ways it fails and publish its real limits.

1. Evaluation that is not a vibe check2 hrs
   • Curating representative held-out 'golden' evaluation datasets
   • Defining task-specific quantitative scoring assertions and rubrics
   • Automated evaluation workflows with Promptfoo and pytest suites
   • Setting regression quality gates inside continuous delivery pipelines
   • Tracking score distribution drift across model versions
2. Red-teaming an AI feature2 hrs
   • Direct prompt injection mechanisms and delimiter bypassing
   • Indirect prompt injection via untrusted third-party document inputs
   • System prompt leak extraction attacks and protection strategies
   • Automating adversarial fuzzing using garak (LLM vulnerability scanner)
   • Documenting attack vectors and documenting severity in a vulnerability registry
3. Bias and fairness2 hrs
   • Measuring demographic skew and disparate impact in model completions
   • Stress testing generative models against toxicity and stereotypes
   • Calibrating classifier decision thresholds across distinct demographic segments
   • Auditing model confidence calibration using Brier score and reliability curves
   • Mitigating toxic output generation via constrained decoding
4. Publishing honest limits2 hrs
   • Authoring industry-standard Model Cards following the Mitchell et al. framework
   • Explicitly documenting intended use cases and out-of-scope deployment hazards
   • Communicating known residual errors and edge-case failure modes
   • Structuring human-in-the-loop review criteria for high-uncertainty outputs
   • Transparency reporting and audit artifact generation for enterprise compliance
5. Security guardrails implementation2 hrs
   • Implementing programmatic input sanitization and regex pattern blockers
   • Integrating the OpenAI Moderation API for automated content filtering
   • Enforcing strict output structure validation via JSON schema gates
   • Rate limiting and anomalous traffic pattern detection per user identity
   • Deterministic fallback responses when safety filters trigger
6. Continuous monitoring and auditing2 hrs
   • Secure logging of LLM requests and outputs with PII anonymization
   • Automated alerts on safety filter violations and adversarial spike activity
   • Periodic scheduled evaluation runs against static reference benchmarks
   • Establishing incident response playbooks for toxic or breached generation
   • Audit trail export formats for third-party compliance verification

Hands-on project: Build an automated evaluation and adversarial testing harness for an AI application using Promptfoo, document three successful injection exploits with corresponding mitigations, and publish a complete Model Card.

You can design, train, evaluate, containerise, and defend an enterprise-grade AI system in production-ready interview scenarios.

1. Capstone System Architecture & Specification4 hrs
   • Drafting a comprehensive Technical Design Document (TDD)
   • Defining data ingestion contracts, schemas, and volume requirements
   • Choosing model architectures and justifying build-versus-buy trade-offs
   • Establishing service level objectives (SLOs) for p95 latency and throughput
   • Reviewing and approving system architecture via peer RFC process
2. Data Pipeline & Model Training Implementation4 hrs
   • Implementing reproducible preprocessing and feature extraction pipelines
   • Executing distributed training or fine-tuning runs with checkpointing
   • Tracking hyperparameter trials and model artifacts in a central registry
   • Auditing datasets to ensure zero test contamination or feature leakage
   • Validating model convergence and metric targets against defined baselines
3. Model Evaluation, Reranking & Safety Integration4 hrs
   • Executing rigorous quantitative validation on held-out test datasets
   • Integrating input guardrails, moderation filters, and schema parsers
   • Benchmarking inference latency on CPU vs GPU hardware
   • Conducting adversarial red-teaming and prompt injection fuzzing
   • Authoring the final production Model Card and system runbook
4. API Service Packaging & Containerised Deployment4 hrs
   • Building the asynchronous FastAPI inference endpoints with Pydantic validation
   • Writing multi-stage Dockerfiles optimized for lightweight production distribution
   • Configuring container health checks and non-root execution privileges
   • Deploying the containerized AI service to a cloud environment
   • Building a reactive frontend dashboard in Streamlit for live demonstration
5. Observability, Latency Optimization & Runbook Design4 hrs
   • Configuring Prometheus metrics collection and Grafana dashboard visualization
   • Implementing structured JSON logging with request tracing identifiers
   • Optimizing inference throughput with model quantization and caching
   • Authoring standard operating procedures and incident rollback playbooks
   • Live chaos testing: validating recovery from memory limits and timeouts
6. Technical Interview Prep, System Design & Portfolio Defence4 hrs
   • Machine learning system design interview patterns and frameworks
   • Python and data structures problem-solving under live coding conditions
   • Walking interviewers through model evaluation metrics and trade-offs
   • Defending production failure modes and past architecture trade-offs
   • Structuring GitHub portfolio repositories and live demo walkthroughs

Hands-on project: Architect, train/fine-tune, evaluate, containerize, and deploy a full-scale AI application (such as an Enterprise RAG Assistant or Real-Time Multi-Modal Classifier) with an automated CI/CD pipeline, Prometheus observability, and a complete Model Card.