These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT and Claude as assistants for writing data processing and EDA code. Formulates prompts for generating pandas scripts, SQL queries, and basic visualizations. Verifies generated code correctness on test data.
Systematically applies LLM assistants to accelerate data science workflows: generating feature engineering code, writing experiment documentation, explaining complex statistical concepts. Critically evaluates proposed solutions.
Integrates LLM assistants into model research and prototyping workflows. Uses them for literature review, hypothesis generation, and ML pipeline code review. Establishes best practices for AI assistant usage across the team.
Defines AI assistant usage policy for the data science team. Establishes data security guidelines when working with LLMs, standardizes workflows. Evaluates ROI from introducing AI tools into data science processes.
Knows about Cursor as an AI-first IDE. Uses AI chat to explain ML code and data pipelines. Asks Cursor to clarify unfamiliar libraries like pandas, scikit-learn, or PyTorch.
Uses Cursor Composer for multi-file editing. Applies AI chat for refactoring. Generates tests via AI. Uses @ mentions to add context (files, documentation). Understands the difference between Chat and Composer modes.
Standardizes Cursor usage in the DS team. Creates .cursorrules templates for ML pipelines, notebooks, and experiment repos. Evaluates Cursor vs Copilot for data exploration. Integrates AI workflows into model review and experiment tracking. Configures MCP for data platform access.
Uses GitHub Copilot for autocompleting data processing code in Python. Applies for generating typical pandas operations, matplotlib charts, and SQL queries. Critically evaluates suggested code before applying.
Productively uses Copilot to accelerate data science workflow: feature engineering code, tests, documentation. Creates effective comment-prompts for ML code generation. Knows Copilot limitations for specialized ML code.
Establishes best practices for Copilot usage in data science teams. Evaluates quality of generated ML code, configures Copilot for specific ML frameworks. Integrates AI-assisted coding into the code review process.
Defines AI coding assistant usage policy for the data science team. Establishes security and IP compliance guidelines for Copilot usage. Evaluates Copilot ROI for various data science tasks and roles.
API Management
▼
Documents ML API: describes prediction endpoints, model inputs/outputs, example requests.
Creates ML documentation: model cards, API reference, integration guides, evaluation reports.
Designs ML documentation: model registry docs, automated model cards, experiment reports.
Defines documentation standards: mandatory model cards, API docs, review process.
Application Security
▼
Understands security for DS: data access control, model security basics. Protects sensitive training data.
Implements ML security: secure model serving, adversarial robustness, data privacy. Applies differential privacy.
Designs ML security: model security architecture, adversarial defense, data protection pipelines.
Defines ML security standards: model security requirements, data privacy policies, security review.
Applies secure coding for DS: secrets management, secure data access. Does not hardcode credentials in notebooks.
Implements security: encrypted data access, secure model serving, audit logging. Scans dependencies.
Designs secure ML: end-to-end data encryption, model access control, compliance automation.
Defines security standards: ML security guidelines, data protection, audit requirements.
Batch Processing
▼
Understands Apache Spark fundamentals for data science: Spark DataFrames for large-scale data analysis, basic Spark SQL queries, and MLlib for distributed model training. Follows team patterns for notebook-based Spark workflows and feature engineering at scale.
Independently uses Spark for large-scale analysis: writes optimized Spark SQL for complex aggregations, implements distributed feature engineering with window functions, and uses MLlib for hyperparameter tuning at scale. Manages Spark resource allocation for interactive analytics.
Designs Spark-based analytical frameworks: custom MLlib transformers for domain-specific features, distributed experiment pipelines, and Spark integration with GPU-accelerated training (Rapids). Optimizes end-to-end ML workflows from data preparation to model serving at petabyte scale.
Defines data engineering strategy. Shapes data platform. Coordinates data teams. Optimizes data mesh/data fabric approaches.
Understands Pandas basics for data science workflows: feature extraction from raw datasets, statistical analysis with groupby/agg, and data preparation for scikit-learn pipelines. Handles categorical encoding, normalization, and train/test splitting. Follows team practices for reproducible data processing.
Implements efficient ML data pipelines with Pandas/Polars: feature engineering with complex transformations, automated feature selection based on statistical tests, and efficient data sampling strategies. Uses Polars for high-performance feature computation on large datasets. Creates reproducible feature pipelines with proper versioning.
Designs ML data architecture with Pandas/Polars: feature store integration, automated feature validation pipelines, and efficient data loading for distributed training. Implements data quality frameworks for training data integrity. Creates organization-wide feature engineering libraries and standards. Mentors team on scalable data processing patterns for ML.
Defines data engineering strategy for ML teams. Shapes ML data platform: feature store architecture, data pipeline standards, and training data governance. Coordinates ML teams on shared feature engineering libraries and data quality practices. Drives adoption of modern data processing tools (Polars, Ray) for ML workloads.
Understands SQL-based ETL for ML data preparation. Writes basic queries to extract and filter training datasets. Follows established patterns for feature extraction and handles simple data type conversions in ETL steps.
Builds ETL pipelines for feature engineering and ML training data preparation. Implements SQL-based feature transforms, manages dataset versioning through snapshot tables, and ensures reproducibility of data extraction for model experiments.
Architects ETL workflows for end-to-end ML pipelines including feature stores. Designs scalable feature engineering transforms, implements data versioning strategies, and builds automated training data validation gates within ETL orchestration.
Defines ML data platform ETL strategy and feature engineering standards. Governs training data preparation workflows across DS teams, establishes data versioning policies, and coordinates ETL infrastructure for model training at scale.
Caching
▼
Uses Redis for DS: caches prediction results, feature values. Understands caching for ML serving.
Designs ML caching: feature store caching, prediction caching, model metadata. Optimizes serving latency.
Designs ML caching architecture: real-time feature serving, prediction caching strategy, cache warming.
Defines caching standards: feature serving requirements, cache policies, performance targets.
CI/CD
▼
Uses GitHub Actions for DS: automated model test runs, notebook linting. Understands basic CI workflow.
Designs CI for DS: automated model testing, data validation pipelines, notebook execution. Integrates MLflow into CI.
Defines CI/CD strategy: model training pipelines, automated evaluation, A/B test deployment. Implements ML CI best practices.
Defines CI/CD standards for DS: mandatory model tests, automated evaluation gates, reproducibility requirements.
Classical Machine Learning
▼
Understands Bayes' theorem and basic Bayesian inference concepts. Familiar with prior, likelihood, and posterior concepts, can apply Naive Bayes classifier for simple text classification tasks.
Applies Bayesian methods for A/B testing and model parameter estimation. Uses PyMC3/PyMC for building probabilistic models. Understands MCMC sampling and convergence diagnostics for result validation.
Designs complex Bayesian models: hierarchical models, Gaussian processes, Bayesian neural networks. Applies variational inference for scalable inference. Uses Bayesian optimization for hyperparameter tuning of ML models.
Defines Bayesian methods strategy for the data science team. Establishes standards for the Bayesian approach to experiments and decision-making. Trains the team on probabilistic programming and Bayesian workflow.
Understands fundamental scikit-learn algorithms (LogisticRegression, RandomForest, GradientBoosting) and their assumptions. Applies Pipeline and ColumnTransformer for reproducible feature engineering. Follows team guidelines for evaluation using classification_report and ROC-AUC.
Independently designs scikit-learn experiments with stratified cross-validation and custom scorers for research tasks. Understands bias-variance trade-offs between regularized models (Ridge, Lasso) and tree ensembles. Builds production pipelines with custom transformers and FeatureUnion.
Has deep expertise extending scikit-learn with custom estimators, meta-learners and stacking ensembles for production ML. Designs model selection with Bayesian optimization and automated feature engineering. Mentors the team on experiment reproducibility and model versioning.
Defines Classical ML (scikit-learn) strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Understands the curse of dimensionality concept and the need for dimensionality reduction. Applies PCA for feature reduction, interprets explained variance ratio. Visualizes high-dimensional data via t-SNE and PCA.
Applies various dimensionality reduction methods: PCA, SVD, UMAP, autoencoders for feature extraction. Selects the optimal method based on task and data. Uses dimensionality reduction as a preprocessing step to improve model quality.
Designs pipelines for very high-dimensional data (100K+ features). Applies non-linear dimensionality reduction, kernel PCA, variational autoencoders. Optimizes trade-off between compression ratio and information loss for production ML.
Defines dimensionality reduction standards for the data science team. Establishes guidelines for method selection for different data types. Coordinates integration of dimensionality reduction into the feature engineering platform.
Understands basic ensemble method principles: bagging, boosting, stacking. Uses Random Forest and simple ensembles from scikit-learn. Understands why ensembles outperform individual models through the bias-variance trade-off.
Independently designs ensemble solutions for production tasks. Uses blending and stacking, combines models of different types (linear, tree-based, neural). Optimizes ensemble composition through cross-validation and grid search.
Designs complex ensemble systems for production: cascading ensembles, mixture of experts, dynamic ensemble selection. Optimizes ensemble inference time for real-time serving. Balances accuracy and latency for production deployment.
Defines ensemble strategy for the team's ML projects. Establishes best practices for model selection and combination. Coordinates ensemble serving infrastructure development for production systems.
Understands the fundamentals of Experiment Design. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Designs complex experiments: multi-variant tests, sequential testing, stratified randomization. Applies causal inference methods: difference-in-differences, instrumental variables. Calculates minimum detectable effect and plans experiment duration.
Designs experimentation platforms for systematic A/B testing of ML models. Applies advanced methods: switchback experiments, cluster randomization, synthetic control. Establishes guardrail metrics and early stopping rules for safe experiments.
Defines experimentation culture in the data science team. Establishes experiment design standards and review processes. Coordinates experimentation platform development and integration with ML pipelines.
Creates basic features from structured data: one-hot encoding, label encoding, binning. Applies standard transformations: scaling, normalization, log-transform. Handles missing values through imputation strategies.
Designs feature engineering pipelines with domain-specific features. Creates temporal features, interaction features, aggregate features. Applies feature selection methods: mutual information, recursive feature elimination, L1 regularization.
Designs scalable feature engineering systems for production ML. Builds real-time feature computation via feature stores (Feast, Tecton). Applies automated feature engineering (featuretools) and feature drift detection for monitoring.
Defines feature engineering strategy for the data science team. Establishes shared feature catalog, quality standards, and feature documentation. Coordinates feature platform development and cross-team feature reuse.
Understands the fundamentals of Hypothesis Testing in ML. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Applies specialized statistical tests for ML tasks: bootstrap hypothesis testing, permutation tests, multiple comparison correction (Bonferroni, FDR). Calculates confidence intervals for ML metrics. Conducts statistical significance testing of models.
Designs frameworks for statistical validation of ML models. Applies sequential testing, always-valid confidence intervals for continuous monitoring. Uses causal inference: propensity score matching, regression discontinuity for ML impact assessment.
Defines statistical validation standards for the data science team. Establishes guidelines for test selection, sample size calculation, and result interpretation. Coordinates statistical infrastructure development for ML experiments.
Works in Jupyter Notebook/Lab for EDA, model prototyping, and result visualization. Structures notebooks with markdown descriptions, creates reproducible experiments. Uses magic commands and extensions for productivity.
Effectively uses JupyterLab for the full ML cycle: from EDA to model evaluation. Applies papermill for parameterized notebook runs, nbconvert for report generation. Configures kernels for various environments and projects.
Designs notebook-based workflows for team data science collaboration. Integrates notebooks with MLflow, DVC, and CI/CD. Establishes notebook development standards: templates, code quality checks, reproducibility. Creates reusable notebook components.
Defines notebook development infrastructure for the data science team. Coordinates JupyterHub setup, resource and access management. Establishes processes for transitioning from notebook prototypes to production code.
Works with pandas DataFrame for loading, cleaning, and analyzing data. Performs basic operations: filtering, grouping, aggregation, merge/join. Uses numpy for mathematical operations and array manipulation. Builds pivot tables and descriptive statistics.
Efficiently works with large datasets via pandas: chunked processing, dtype optimization, multi-index. Applies numpy vectorized operations for high-performance computing. Uses pandas profiling for automated EDA.
Designs high-performance data processing pipelines with pandas/numpy. Applies advanced techniques: Cython extensions, numba JIT compilation for numpy. Optimizes memory footprint through chunked processing and memory-mapped arrays for out-of-core computing.
Defines data handling standards for the data science team. Establishes shared data processing utilities and best practices. Coordinates migration from pandas to distributed frameworks (Dask, Polars, Spark) when needed.
Writes clean Python code for data science: data processing functions, EDA scripts, simple ML pipelines. Uses list comprehensions, generators, decorators. Works with virtual environments and dependency management via pip/conda.
Develops production-ready Python code for ML systems. Applies OOP for structuring ML code, type hints for API documentation. Uses dataclasses, pydantic for data validation. Writes modular, testable code with proper error handling.
Designs Python architecture for scalable ML systems. Optimizes performance through profiling, multiprocessing, async/await. Creates reusable packages and libraries for the data science team. Applies advanced patterns: metaclasses, context managers, descriptors.
Defines Python standards for the data science team: code style, architecture patterns, package management. Establishes shared Python infrastructure: internal packages, CI/CD templates, development tools. Conducts ML code architecture reviews.
Uses scikit-learn for the full ML cycle: preprocessing, model training, evaluation. Applies basic models: LogisticRegression, RandomForest, SVM, KMeans. Works with Pipeline, GridSearchCV, train_test_split for correct ML workflow.
Independently solves production tasks with scikit-learn using advanced preprocessing and model selection. Applies ColumnTransformer for heterogeneous data, custom transformers. Uses RandomizedSearchCV, cross_val_predict, and calibration tools.
Designs scalable ML solutions with scikit-learn for production. Creates custom estimators, scorers, and cross-validators. Optimizes production pipelines through partial_fit for incremental learning. Integrates scikit-learn with distributed computing.
Defines scikit-learn usage standards for the data science team. Establishes shared preprocessing pipelines and model templates. Coordinates decision-making: when scikit-learn is sufficient vs when DL frameworks are needed.
Conducts descriptive statistics and basic statistical data analysis. Calculates measures of central tendency, variance, and correlations. Builds confidence intervals and conducts basic statistical tests via scipy.stats.
Applies advanced statistical analysis: regression analysis, ANOVA, non-parametric tests, survival analysis. Conducts power analysis for experiment planning. Uses statsmodels for regression and time series decomposition.
Designs statistical frameworks for data science teams. Applies advanced methods: causal inference, mixed effects models, GAMs. Conducts simulation studies for methodology validation. Establishes statistical rigor standards for ML research.
Defines statistical analysis standards for the organization. Establishes guidelines for applying statistical methods to different business tasks. Coordinates statistical consulting for product and data science teams.
Understands the fundamentals of Time Series Analysis. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Applies advanced time series methods: Prophet, SARIMA, VAR, state space models. Conducts feature engineering for temporal data: lag features, rolling statistics, Fourier features. Uses cross-validation for time series (TimeSeriesSplit).
Designs production time series forecasting systems. Applies deep learning for time series: N-BEATS, Temporal Fusion Transformer, DeepAR. Implements probabilistic forecasting with quantile regression. Works with multivariate and hierarchical time series.
Defines forecasting strategy for the data science team. Establishes reusable forecasting framework and evaluation standards. Coordinates forecasting platform development for business users and automated systems.
Clean Code & Refactoring
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Python/R. Follows recommendations from senior developers when solving problems.
Independently applies code quality practices in data science. Writes organized experiment code with clear separation of data loading, feature engineering, and modeling. Understands trade-offs between notebook flexibility and modular code structure. Reviews ML code for data leakage, hyperparameter management, and result reproducibility.
Designs code quality standards for ML research codebases: experiment tracking conventions, notebook-to-module refactoring patterns, reproducibility requirements. Refactors prototype models into production-grade code with proper testing. Establishes review practices balancing research speed with code maintainability.
Defines Code Quality and Refactoring standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.
Cloud Providers
▼
Understands basic AWS concepts for data science workloads — S3 for datasets, SageMaker notebooks for experimentation, and ECR for container images. Uses existing configurations for Jupyter notebook environments on SageMaker. Performs simple operations like launching notebook instances and accessing training data under senior guidance.
Independently configures AWS services for data science workflows — SageMaker Studio, EMR for distributed processing, and Athena for ad-hoc querying. Writes IaC for reproducible experiment environments with GPU scheduling. Understands VPC networking for secure data access and IAM policies for cross-service data pipeline permissions.
Designs AWS infrastructure solutions for production data science platforms — SageMaker Pipelines for ML workflows, EMR for distributed feature engineering, and managed experiment tracking. Optimizes cost through SageMaker Savings Plans, spot training instances, and intelligent data lifecycle management. Implements security hardening with data encryption, cross-account isolation, and reproducible experiment environments.
Defines AWS infrastructure strategy for data science platforms spanning experiment environments and production ML serving. Establishes IaC standards for SageMaker Studio, distributed training clusters, and experiment reproducibility. Conducts architecture reviews optimizing ML workload costs and coordinates FinOps for data science compute resources.
Code Review
▼
Understands basic code review for ML code: reviewing experiment code changes, checking feature engineering logic, validating model training configurations. Follows team review guidelines for research code quality.
Independently conducts code reviews for ML code: evaluates experiment code quality, reviews feature engineering implementations, checks model training reproducibility. Provides constructive feedback balancing research exploration with code maintainability.
Designs code review processes for ML research: experiment code review standards, model training reproducibility checklists, research-to-production transition review gates. Mentors team on balancing research freedom with production code quality in reviews.
Defines code review strategy for ML research team: experiment code review standards, model quality review governance, research-to-production review practices. Establishes review culture balancing research freedom with code quality.
Concurrency & Parallelism
▼
Understands async for DS: asyncio for parallel data fetching, concurrent API calls to ML services.
Implements async data processing: parallel data loading, async model inference, concurrent feature extraction.
Designs async ML pipelines: parallel training experiments, async feature engineering, distributed data loading.
Defines async standards: parallel processing guidelines, async patterns for ML workflows.
Understands parallelism for DS: multi-processing for data loading, parallel model evaluation.
Implements parallel ML: multiprocessing for feature engineering, parallel hyperparameter tuning, concurrent data loading.
Designs parallel ML: distributed training, parallel experiment execution, multi-GPU optimization.
Defines parallelism standards: GPU utilization policies, distributed training guidelines.
Containerization
▼
Understands basic Docker concepts for data science: containerized Jupyter environments, Docker images for ML library dependencies, basic docker-compose for local data processing stack. Uses existing configurations for GPU-enabled training containers.
Independently configures Docker for data science: GPU-enabled Jupyter containers, multi-stage builds for model training images, docker-compose for experiment environments with data stores. Understands container resource management for ML workloads and volume mounting for dataset access.
Designs Docker infrastructure for ML workflows: reproducible training environments with pinned dependencies, GPU container orchestration for experiment pipelines, containerized model serving architecture. Implements best practices for experiment environment versioning and data volume management.
Defines Docker strategy for ML workflows: GPU container platform governance, experiment environment standardization, model container lifecycle policies. Conducts architecture reviews for containerized ML infrastructure and optimizes FinOps for GPU compute resources.
Data Quality
▼
Validates training datasets for completeness and label quality using pandas and numpy. Applies data profiling to detect missing values and distribution anomalies in Jupyter. Uses scikit-learn utilities for feature validation before model training. Documents data quality issues found during EDA.
Independently implements data pipelines with Data Quality tools. Optimizes performance. Ensures data quality.
Designs data architecture with Data Quality tools. Optimizes for big data. Implements data governance and quality frameworks.
Defines data quality strategy for ML teams ensuring high-quality training datasets. Coordinates validation standards across feature stores and model pipelines. Drives adoption of observability tools and quality gates before training. Aligns quality practices with MLOps and data mesh.
Data Visualization
▼
Builds basic ML experiment dashboards to track model metrics. Understands standard plots for feature importance and model performance. Integrates simple visualizations with MLflow or W&B following team practices.
Independently builds model monitoring dashboards tracking drift, accuracy, and latency metrics. Optimizes visualization pipelines for real-time experiment tracking. Integrates MLflow and W&B dashboards into team workflows for reproducible ML reporting.
Designs end-to-end ML observability dashboards covering model lifecycle from training to production. Optimizes visualization systems for large-scale experiment tracking across teams. Implements governance frameworks for feature importance reporting and model performance transparency.
Defines ML dashboard strategy for experiment tracking and model monitoring across data science teams. Shapes the MLOps visualization platform integrating MLflow, W&B, and custom dashboards. Coordinates ML teams on standardized reporting for model performance and feature importance.
Creates basic visualizations via matplotlib and seaborn: histograms, scatter plots, box plots, heatmaps. Visualizes feature distributions and correlations for EDA. Builds model metric charts: ROC curve, confusion matrix.
Creates interactive visualizations via Plotly and Altair for data exploration. Builds informative dashboards in Streamlit for communicating results to stakeholders. Visualizes experiment and A/B test results with confidence intervals.
Designs visualizations for explaining complex ML models: SHAP plots, partial dependence plots, attention maps. Creates custom visualizations for high-dimensional data via t-SNE/UMAP. Establishes visualization standards for the data science team.
Defines data and ML results visualization standards for the organization. Establishes report templates for different stakeholders: technical, product, business. Coordinates creation of self-service analytics dashboards.
Database Optimization
▼
Understands basic indexing concepts for efficient data retrieval during model training and feature engineering. Knows how indexes impact query speed when extracting large datasets. Follows team practices on creating indexes for frequently accessed feature tables.
Designs indexing strategies for feature engineering workloads: indexes for time-series feature extraction, spatial indexes for geospatial features, and GIN indexes for JSONB feature metadata. Optimizes data retrieval queries for training and inference pipelines. Understands index trade-offs for write-heavy experiment logging tables.
Designs indexing architecture for ML data infrastructure: vector indexes (HNSW, IVF) for embedding similarity search, time-series indexes for temporal feature stores, and specialized indexes for graph-based feature engineering. Configures database indexes for efficient model serving and real-time feature retrieval. Optimizes data access patterns across training and inference pipelines.
Defines data strategy at product level. Establishes Database Indexing standards. Conducts data schema and scaling strategy reviews.
Understands query optimization basics for ML data extraction: efficient feature retrieval queries, batch data loading patterns, and avoiding memory-heavy query patterns when extracting training datasets. Follows team practices for optimizing data pipeline queries.
Independently optimizes ML data queries: efficient feature extraction with window functions, batch loading strategies for training data, and incremental query patterns for streaming feature computation. Understands query optimizer behavior for complex feature engineering queries. Balances query performance with data freshness requirements.
Designs query architecture for ML data infrastructure: feature store query optimization, distributed query patterns for large-scale training data extraction, and real-time feature retrieval for model serving. Implements query caching for feature computation and automated query performance benchmarking. Mentors team on efficient data access patterns for ML workflows.
Defines data strategy at product level. Establishes Query Optimization standards. Conducts data schema and scaling strategy reviews.
Deep Learning
▼
Understands the fundamentals of Deep Learning. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently designs and trains deep learning models for production tasks. Works with CNN, RNN/LSTM, Transformer architectures. Applies regularization (dropout, batch norm, weight decay), optimizes hyperparameters through systematic search.
Designs complex deep learning architectures: multi-task learning, attention mechanisms, generative models (VAE, GAN). Optimizes training through mixed precision, distributed training, gradient accumulation. Applies knowledge distillation for model deployment.
Defines deep learning strategy for the data science team. Establishes training infrastructure standards and model architecture guidelines. Evaluates state-of-the-art approaches and makes decisions on their production adoption.
Understands basic neural network architectures: MLP, CNN, RNN/LSTM and their applications. Knows components: layers, activations, optimizers, loss functions. Creates simple architectures in PyTorch/Keras for typical classification and regression tasks.
Designs and implements modern architectures: Transformers, U-Net, ResNet, EfficientNet. Applies attention mechanisms, skip connections, residual learning. Selects optimal architecture based on task, data, and production requirements.
Designs custom architectures for specific business tasks. Applies neural architecture search (NAS), progressive growing, modular design. Optimizes architectures for latency/accuracy trade-off in production deployment.
Defines architectural guidelines for the team's deep learning projects. Establishes model zoo with pre-validated architectures. Coordinates research directions and evaluation of new architectural approaches for production use.
Builds simple neural networks in PyTorch for tabular data. Uses nn.Module for model definition. Understands tensor operations, autograd and basic training loop. Experiments with loss functions and optimizers (Adam, SGD). Tracks metrics across experiments.
Designs custom architectures with nn.Module for complex experiments. Uses PyTorch Lightning for structured training with callbacks and early stopping. Tunes hyperparameters with Optuna integration. Implements custom loss functions and LR schedulers. Profiles training bottlenecks.
Architects complex PyTorch training with distributed data parallelism. Implements custom autograd functions for research. Leads architecture decisions: attention mechanisms, residual connections, normalization. Mentors team on PyTorch debugging and profiling with torch.profiler.
Defines PyTorch standards for DS team: experiment structure, reproducibility requirements, model versioning. Evaluates ecosystem tools (Lightning, TorchRec) for team adoption. Reviews architectural decisions in training pipelines. Drives knowledge sharing on advanced patterns.
Understands the fundamentals of Reinforcement Learning. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Applies RL for business tasks: recommender systems, dynamic pricing, content personalization. Uses PPO, SAC, A2C via stable-baselines3. Designs reward functions for real-world tasks, handles sparse rewards.
Designs production RL systems: offline RL, contextual bandits, multi-agent RL. Applies model-based RL for data-efficient training. Addresses production RL challenges: safety constraints, online evaluation, sim-to-real transfer.
Defines RL strategy for the data science team. Establishes guidelines on RL vs supervised learning applicability. Coordinates RL infrastructure development: simulation environments, evaluation frameworks, safety tools.
Works with PyTorch or TensorFlow for training deep learning models. Creates Dataset/DataLoader, builds models via nn.Module or Sequential API. Trains models with basic training loops, logs loss and metrics.
Independently develops DL models in PyTorch/TensorFlow for production. Uses PyTorch Lightning or Keras for structuring training code. Applies transfer learning, learning rate scheduling, gradient clipping. Works with GPU training.
Designs production DL systems with PyTorch/TensorFlow. Optimizes training through mixed precision, distributed training (DDP/FSDP), gradient checkpointing. Exports models to ONNX/TorchScript for optimized inference.
Defines DL framework strategy for the data science team. Establishes training infrastructure standards and best practices. Coordinates GPU resource management and distributed training setup for the team.
Understands the concept of transfer learning: pre-trained models, feature extraction, fine-tuning. Applies transfer learning via Hugging Face and torchvision for image and text tasks. Knows when transfer learning is more effective than training from scratch.
Applies transfer learning with pre-trained models (ResNet, BERT) for domain-specific tasks. Fine-tunes models on custom datasets with appropriate learning rate scheduling. Evaluates trade-offs between full fine-tuning and feature extraction.
Designs transfer learning pipelines for scalable fine-tuning. Applies multi-task transfer learning, domain adaptation, few-shot learning. Creates domain-specific pre-trained models for the organization. Optimizes compute cost of transfer learning.
Defines transfer learning strategy for the data science team. Establishes internal model hub with pre-validated pre-trained models. Coordinates shared pre-training efforts and knowledge transfer across projects.
Distributed Tracing
▼
Understands OpenTelemetry for ML: tracing prediction requests, monitoring model latency.
Instruments ML: distributed tracing for prediction pipeline, custom metrics, feature latency.
Designs ML observability: end-to-end prediction tracing, model performance metrics, SLIs.
Defines observability standards: mandatory ML instrumentation, metric requirements.
Git & Workflows
▼
Uses Git for versioning notebooks and ML code. Performs basic operations: commit, push, pull, branch, merge. Works with .gitignore to exclude data and models from the repository. Understands Git flow for data science projects.
Applies advanced Git workflows for team data science work. Uses git hooks for automatic linter and test runs. Works with Git LFS for versioning models and datasets. Resolves merge conflicts in notebooks via nbdime.
Shapes Git strategy for ML projects: branching model for experiments, integration with DVC for data versioning. Configures CI/CD pipelines with Git hooks for automated ML code testing. Conducts code review of ML pipelines.
Defines versioning standards for the data science team: code, data, models, experiments. Establishes Git workflow guidelines for ML projects. Coordinates Git integration with the ML platform for reproducibility.
GraphQL
▼
Understands GraphQL for DS: flexible data queries for ML features, metadata exploration.
Designs GraphQL for ML: feature discovery API, model metadata queries, experiment exploration.
Designs ML data API: unified feature access, model registry GraphQL, real-time subscriptions.
Defines GraphQL standards for ML: schema design, access patterns, performance.
Integration Testing
▼
Tests ML integrations: model + API integration, data pipeline connectivity. Verifies end-to-end prediction flow.
Designs integration tests: model serving testing, feature pipeline validation, data source integration.
Defines ML integration testing: model deployment validation, A/B test infrastructure, data quality gates.
Introduces integration testing standards: mandatory model tests, deployment validation, quality gates.
Kubernetes & Orchestration
▼
Understands K8s for DS: containerized model serving, basic deployment. Runs notebooks in K8s.
Deploys ML in K8s: model serving (Seldon/KServe), training jobs, GPU scheduling. Configures resource limits.
Designs ML Kubernetes architecture: Kubeflow, distributed training, auto-scaling model serving.
Defines K8s standards for ML: GPU policies, model deployment patterns, resource management.
LLM & Generative AI
▼
Uses LLM APIs for basic text classification and named entity recognition tasks on structured datasets. Generates embeddings for simple similarity search and clustering. Applies pre-trained models to extract insights from text data, evaluating output quality with standard metrics.
Builds RAG pipelines combining vector stores with LLM generation for domain-specific knowledge retrieval. Designs embedding strategies for multi-modal similarity search. Fine-tunes classification heads on top of LLM embeddings and benchmarks results against traditional ML baselines on production data.
Designs advanced RAG architectures with hybrid retrieval, re-ranking, and context window optimization for domain-critical applications. Develops custom NER and relation extraction pipelines combining LLMs with structured knowledge graphs. Mentors team on embedding space analysis and LLM evaluation methodology.
Defines the strategic roadmap for LLM adoption in data science workflows across the organization. Establishes evaluation standards for LLM-augmented analytics including bias detection, hallucination measurement, and domain accuracy benchmarks. Drives build-vs-buy decisions for embedding infrastructure and RAG platforms.
Understands the concept of LLM fine-tuning: full fine-tuning vs parameter-efficient methods. Uses Hugging Face API for fine-tuning small models on custom data. Prepares training data in the correct format for various LLM platforms.
Independently conducts LLM fine-tuning using LoRA, QLoRA, and prefix-tuning. Configures training hyperparameters, monitors loss curves. Evaluates fine-tuned model quality through domain-specific benchmarks and human evaluation.
Designs fine-tuning pipelines for production LLM systems. Applies RLHF, DPO for model alignment. Optimizes training through DeepSpeed, FSDP. Conducts systematic evaluation via automated benchmarks and red-teaming.
Defines LLM fine-tuning strategy for the organization. Establishes data preparation, training, and evaluation standards for custom LLMs. Coordinates GPU infrastructure and budgets for LLM experiments.
Creates basic prompts for LLM: structured queries for data analysis, code generation, information extraction. Understands zero-shot and few-shot prompting principles. Iteratively improves prompts based on model response quality.
Applies advanced prompting techniques for data science tasks: chain-of-thought, self-consistency, ReAct. Designs prompt pipelines for analytics automation. Evaluates prompt quality through systematic benchmarking on test sets.
Designs production prompt engineering systems for scalable LLM applications. Applies prompt optimization, automatic prompt tuning. Builds prompt testing frameworks with regression testing and quality monitoring for production.
Defines prompt engineering strategy for the data science team. Establishes shared prompt library and best practices. Coordinates prompt development workflow with version control and collaborative review.
Logging
▼
Uses logging for DS: experiment logging via MLflow, structured metrics tracking. Logs training progress.
Implements structured logging: experiment tracking, model metrics, data pipeline logging. Integrates with monitoring.
Designs ML observability: experiment lineage, model performance tracking, data quality logging.
Defines logging standards: experiment tracking requirements, model monitoring, data quality logging.
Metrics & Monitoring
▼
Monitors ML via Prometheus/Grafana: model latency, prediction throughput. Views ML dashboards.
Creates ML monitoring: model performance dashboards, data drift metrics, feature importance tracking.
Designs ML monitoring: automated drift detection, performance alerting, experiment dashboards.
Defines ML monitoring standards: mandatory metrics, model health dashboards, alerting policies.
MLOps
▼
Tracks model training runs with hyperparameters, metrics, and dataset versions using MLflow or Neptune; follows team guidelines for organizing experiments into projects and comparing baseline results
Designs structured experiment hierarchies in MLflow or Neptune: groups related runs into parent experiments, tracks feature engineering decisions alongside model metrics, and understands trade-offs between tracking granularity and overhead
Architects scalable experiment tracking infrastructure: optimizes MLflow/Neptune deployments for high-throughput training, designs custom metric visualizations for complex model comparisons, and establishes governance policies for experiment metadata and artifact retention
Defines experiment tracking strategy for the data science function: selects and standardizes tooling (MLflow, W&B, Neptune) across teams, establishes cross-team experiment sharing protocols, and ensures tracking practices support model governance and audit requirements
Retrieves features from existing feature stores for model training. Understands the concept of feature reuse and online/offline serving. Follows team conventions for feature naming and versioning.
Engineers and registers new features in the feature store with proper documentation. Implements feature pipelines with point-in-time correctness to prevent data leakage. Evaluates feature importance and manages feature lifecycle for experiments.
Designs feature store architecture enabling cross-team feature sharing and discovery. Defines feature governance policies including versioning, deprecation, and access control. Mentors teams on feature engineering best practices and scalable feature pipelines.
Defines Feature Stores strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Understands the fundamentals of ML Deployment. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently deploys ML models to production using MLflow, BentoML, or TorchServe. Configures model versioning, A/B testing, and canary releases. Monitors prediction quality and data drift through automated alerts.
Designs ML serving infrastructure for high-throughput production systems. Optimizes inference through model optimization: ONNX, TensorRT, quantization. Implements feature store integration, online/offline serving, shadow mode for new models.
Defines ML deployment strategy for the data science team. Establishes production readiness standards: SLA, monitoring, rollback procedures. Coordinates ML engineering and DevOps for building a reliable ML serving platform.
Uses MLflow or W&B for basic experiment tracking: logging parameters, metrics, and artifacts. Structures experiments by projects, compares runs via UI. Saves models with metadata for reproducibility.
Independently builds experiment tracking workflow for ML projects. Integrates MLflow/W&B with training pipelines for automatic logging. Configures artifact storage, model registry, and experiment tags for work organization.
Designs enterprise experiment tracking infrastructure. Integrates tracking with CI/CD, automated model promotion, and deployment. Configures multi-team collaboration, access control, and experiment governance for large-scale data science work.
Defines experiment management standards for the data science team. Establishes experiment review processes, knowledge sharing, and best practices. Coordinates experiment platform development and integration with ML infrastructure.
Understands core ML metrics: accuracy, precision, recall, F1, ROC-AUC for classification; RMSE, MAE, R² for regression. Conducts cross-validation for generalization assessment. Builds confusion matrix and classification report via scikit-learn.
Applies advanced evaluation methods: stratified cross-validation, time-series split, nested cross-validation. Evaluates models considering business metrics: lift, gain charts, expected calibration error. Analyzes models for fairness and bias via disaggregated metrics.
Designs comprehensive evaluation frameworks for ML models: offline metrics, online metrics, business KPIs. Implements automated model validation gates before production deployment. Applies counterfactual analysis and SHAP for deep model diagnostics.
Defines model evaluation standards for the data science team. Establishes evaluation checklist for each ML task type. Coordinates model review process and alignment between offline metrics and business outcomes.
Tracks ML experiments in MLflow, logging hyperparameters, metrics, and model artifacts for reproducibility. Uses MLflow UI to compare runs across different algorithms (XGBoost, LightGBM, sklearn). Follows team standards for experiment naming, tagging, and artifact storage conventions.
Builds structured MLflow workflows for feature engineering, model selection, and hyperparameter optimization. Integrates with Optuna/Hyperopt for automated tuning with full trial logging. Manages model lifecycle in Model Registry, transitioning through staging and production stages.
Designs MLflow tracking architectures for production ML, integrating with CI/CD and automated validation gates. Implements custom plugins for domain-specific metrics and artifact stores (S3, GCS). Establishes model registry governance with approval workflows and rollback procedures.
Defines MLflow tracking standards across data science teams: naming conventions, metric taxonomies, and experiment organization. Drives Model Registry as single source of truth for governance. Reviews experiment design and tracking practices ensuring reproducibility across ML projects.
Understands basic model monitoring principles for ML experiments and deployed models. Tracks key metrics like accuracy, precision, recall using tools such as MLflow or Weights & Biases. Follows team standards for logging predictions, detecting data drift, and reporting model degradation.
Independently implements model monitoring across the ML lifecycle. Configures data drift detection with Evidently or Great Expectations, sets up feature distribution tracking, and builds automated retraining triggers. Understands trade-offs between statistical tests for drift detection in tabular and time-series data.
Designs end-to-end model monitoring architectures for production ML systems. Implements advanced drift detection combining statistical tests, model performance proxies, and business KPI correlation. Builds automated feedback loops from monitoring signals to retraining pipelines. Mentors team on observability best practices and incident response.
Defines model monitoring strategy at team and product level. Establishes standards for drift detection thresholds, alerting SLOs, and incident escalation across deployed models. Conducts reviews of monitoring coverage and drives adoption of observability tooling like Evidently or Arize across teams.
Understands model serving basics: exporting trained models (pickle, ONNX, SavedModel), basic API wrapper creation with Flask/FastAPI, and model input/output schema definition. Follows team practices for model packaging and deployment workflows.
Implements model serving solutions: containerized model deployment (Docker/K8s), monitoring for data drift and prediction quality, and canary deployment for safe model rollout. Uses MLflow/BentoML for model packaging and serving. Implements feature engineering in serving pipeline consistent with training.
Designs model serving architecture: scalable inference platforms, model registry integration with automated deployment, and online/offline feature consistency guarantees. Implements advanced monitoring: data drift detection, model performance degradation alerts, and automated retraining triggers. Creates serving best practices and model deployment standards. Mentors team on MLOps patterns.
Defines model serving strategy for ML teams. Establishes model deployment standards, serving infrastructure requirements, and monitoring governance. Conducts reviews of serving architectures. Drives adoption of MLOps best practices for reliable model deployment across teams.
Natural Language Processing
▼
Understands the fundamentals of Natural Language Processing. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Applies modern NLP methods: word embeddings (Word2Vec, FastText), sequence models (LSTM), pre-trained transformers (BERT, RuBERT). Solves tasks: NER, topic modeling, text summarization, semantic similarity. Fine-tunes BERT for domain-specific tasks.
Designs production NLP systems with LLM integration. Develops RAG pipelines, semantic search, document understanding systems. Optimizes NLP models for production: distillation, quantization, efficient inference. Works with multilingual NLP.
Defines NLP strategy for the data science team. Establishes reusable NLP components and shared text processing infrastructure. Coordinates the choice between custom NLP models and LLM-based approaches for different tasks.
Understands core Transformer architecture (attention mechanisms, positional encoding) and basic NLP pipelines. Uses pre-trained models from Hugging Face for text classification and NER tasks. Follows team guidelines for data preprocessing and tokenization workflows.
Fine-tunes Transformer models for domain-specific NLP tasks including sentiment analysis, summarization, and question answering. Evaluates trade-offs between model size, inference speed, and accuracy. Implements custom training loops with proper evaluation metrics and cross-validation.
Designs end-to-end NLP systems with Transformer models for production: custom architectures, distributed training, model distillation and quantization. Optimizes inference latency and throughput for real-time applications. Mentors team on advanced techniques like multi-task learning and domain adaptation.
Defines NLP and Transformer strategy at team level: selects model architectures, establishes training infrastructure, and sets quality benchmarks. Conducts architectural reviews of ML pipelines. Drives adoption of best practices for experiment tracking, model versioning, and reproducibility.
Networking
▼
Understands networking for DS: API calls to ML services, data transfer protocols. Configures secure connections.
Implements ML networking: model serving endpoints, distributed training communication, data pipeline networking.
Designs ML network architecture: GPU cluster networking, model serving load balancing, data transfer optimization.
Defines networking standards: ML service networking, security policies, performance requirements.
NoSQL Databases
▼
Queries ClickHouse from Python using clickhouse-driver or clickhouse-connect to extract datasets for ML experiments. Converts query results into pandas DataFrames for exploratory data analysis. Writes basic sampling queries using SAMPLE or ORDER BY rand() to create representative training subsets from large tables.
Builds feature extraction pipelines in ClickHouse using aggregation functions, window calculations, and array operations to generate ML features at scale. Implements efficient stratified sampling strategies for training data preparation on billion-row tables. Integrates ClickHouse with feature store patterns, materializing computed features for reuse across multiple ML models.
Architects end-to-end ML feature pipelines on ClickHouse, optimizing data extraction for training and inference workloads. Leverages ClickHouse's native ML functions and statistical aggregates for in-database feature computation at petabyte scale. Designs efficient data access patterns that minimize memory overhead when feeding large datasets into distributed training frameworks via chunked iteration.
Defines data strategy at product level. Establishes ClickHouse standards. Conducts data schema and scaling strategy reviews.
OOP & Design Patterns
▼
Applies patterns in DS: Pipeline pattern for data processing, Strategy for model selection. Organizes ML code.
Uses ML design patterns: feature store pattern, model registry, experiment tracking. Implements reproducible pipelines.
Designs ML architecture using patterns: ML platform patterns, model serving architecture, feature engineering patterns.
Defines ML architectural patterns: reference ML architectures, pattern catalog for the DS team.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Python/R. Follows recommendations from senior developers when solving problems.
Independently applies OOP/SOLID in ML research code: proper class design for experiment pipelines, encapsulated model wrappers with clean interfaces, single responsibility in feature engineering modules. Understands trade-offs between OOP structure and rapid prototyping in notebook-to-production workflows.
Applies OOP/SOLID in ML system architecture: abstract model interfaces for experiment framework, strategy pattern for hyperparameter optimization, clean abstractions for data loading/transformation. Designs reusable ML experiment frameworks that allow comparing different model architectures consistently.
Defines OOP/SOLID standards for ML research team: experiment pipeline class architecture, model wrapper interface contracts, feature engineering module design guidelines. Conducts reviews balancing OOP rigor with research iteration speed.
Prompt Engineering
▼
Creates basic prompts for LLM in the data science context: structured data extraction from text, description generation, classification. Understands differences between models (GPT-4, Claude, Llama) and their applicability for different tasks.
Designs prompt systems for automating data labeling and data augmentation. Applies structured output, JSON mode, function calling for LLM integration into data pipelines. Evaluates cost and quality of LLM-powered data processing.
Designs scalable prompt systems for production data science workflows. Optimizes cost/quality trade-offs through prompt chaining, caching, and model routing. Implements evaluation pipelines for prompt quality with automated regression testing.
Defines LLM usage strategy for data augmentation and labeling in the team. Establishes shared prompt library and evaluation standards. Coordinates cost management for LLM-powered data processing.
Recommender Systems
▼
Understands the fundamentals of Recommender Systems Fundamentals. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently applies Recommender Systems Fundamentals in practice. Understands trade-offs of different approaches. Solves typical tasks independently.
Has deep expertise in Recommender Systems Fundamentals. Designs solutions for production systems. Optimizes and scales. Mentors the team.
Defines Recommender Systems Fundamentals strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Relational Databases
▼
Writes SQL queries for data extraction and analysis: JOIN, GROUP BY, HAVING, subqueries. Conducts EDA via SQL in data warehouses. Works with aggregate functions and basic window functions for analytical queries.
Writes complex analytical SQL queries with window functions: LAG, LEAD, RANK, running totals. Creates CTE-based queries for feature engineering in data warehouses. Optimizes queries through EXPLAIN ANALYZE and proper indexing.
Designs SQL-based feature pipelines for production ML systems. Optimizes queries for BigQuery/Redshift/Snowflake with partitioning, clustering, materialized views. Creates dbt models for reproducible data transformations.
Defines SQL development standards for the data science team. Establishes shared SQL models and naming conventions. Coordinates data engineering and data science for effective data warehouse workflows.
Understands basic PostgreSQL for data science: extracting training datasets with SQL queries, understanding schema design for feature stores, basic query optimization for large data retrieval. Follows team conventions for ML data pipeline database interactions.
Independently designs schemas for ML data pipelines: optimizes queries for large-scale feature extraction, implements efficient data sampling strategies, configures COPY for fast bulk data loading into training pipelines. Understands trade-offs between SQL-based feature engineering and external processing frameworks.
Designs PostgreSQL architecture for ML data infrastructure: optimizes database for large-scale feature store operations, implements efficient data versioning and lineage tracking, configures partitioning and archival for training data lifecycle. Mentors team on SQL-based feature engineering patterns and data pipeline optimization.
Defines PostgreSQL data strategy for ML teams: establishes standards for feature store design and training data management, designs database architecture for reproducible ML experiments, drives adoption of PostgreSQL best practices for data science workflows.
REST API
▼
Understands basic REST API concepts for ML workflows: model prediction endpoints, feature data retrieval APIs, experiment tracking API basics. Follows team conventions for consuming and designing simple model serving APIs.
Independently designs REST APIs for ML services: model prediction endpoints with proper input validation, feature retrieval APIs, experiment result endpoints. Understands best practices for ML API response formats, model versioning in endpoints, and async prediction patterns.
Designs API architecture for ML services: model serving API patterns with versioning, feature store API design, experiment management endpoints. Defines API contracts for ML platform components. Mentors team on designing production-grade ML prediction APIs.
Defines API strategy for ML services at product level: model serving API standards, ML pipeline API governance, experiment management endpoint policies. Conducts API architecture reviews for ML platform services and establishes ML API design practices.
System Design
▼
Understands basic system design principles: client-server, REST API, databases. Knows how ML models integrate into production systems. Understands scalability challenges when deploying ML models and working with large data.
Designs ML systems considering scalability and reliability. Understands microservices architecture, message queues, caching for ML serving. Works with Docker for ML model containerization, configures basic monitoring and alerting.
Designs end-to-end ML systems: data ingestion, feature computation, training, serving, monitoring. Applies event-driven architecture for real-time ML. Optimizes system design for cost efficiency and reliability.
Defines architectural standards for the team's ML systems. Establishes reference architectures for typical ML use cases. Coordinates ML engineering and platform teams for building reliable ML infrastructure.
Unit Testing
▼
Writes basic unit tests for data science code using a test framework. Tests data processing functions, feature engineering, and model predictions. Understands the importance of testing for ML experiment reproducibility and data quality.
Systematically tests ML code: data processing pipelines, model training, inference. Applies fixtures, parametrize, mocking in pytest for test isolation. Writes data quality tests via Great Expectations. Configures test coverage for ML projects.
Designs testing strategy for ML systems: unit tests, integration tests, model performance tests. Creates testing frameworks for ML pipeline validation. Implements property-based testing via Hypothesis for data processing functions.
Defines testing standards for the data science team. Establishes test automation framework and CI/CD integration for ML tests. Coordinates quality gates for ML model deployment through automated testing.
Understands basic unit testing for ML code: pytest for data preprocessing functions, test fixtures with sample datasets, assertion patterns for model output shapes. Follows team practices for testing feature engineering and data transformation logic.
Independently writes unit tests for ML code: pytest for feature engineering and data transformation functions, test fixtures with reproducible datasets, edge case coverage for missing data handling. Integrates ML tests into CI/CD with fixed random seeds and tolerance-based assertions.
Designs testing strategy for ML research code: test pyramid balancing prototype speed and production reliability, statistical assertion frameworks for model quality, reproducibility testing with fixed seeds and data snapshots. Mentors team on transitioning research code to tested production modules.
Defines testing strategy at product level for ML projects: experiment reproducibility testing standards, model validation governance, statistical testing frameworks for model comparison. Establishes shift-left testing culture balancing research speed with production ML code quality.
Web Frameworks
▼
Uses Python Web Frameworks at a basic level in scikit-learn/pandas. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.
Independently implements tasks with Python Web Frameworks in scikit-learn/pandas. Understands internals and optimizes performance. Writes tests using cross-validation.
Designs solutions with Python Web Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines architecture for ML model serving and experiment tracking APIs using FastAPI and Django. Establishes standards for prediction endpoints, A/B test result APIs, and feature store integrations. Conducts design reviews and defines the roadmap for ML platform web services.