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.
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.
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.
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.
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.
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.
Defines data engineering strategy. Shapes data platform. Coordinates data teams. Optimizes data mesh/data fabric approaches.
Defines organizational data strategy. Designs enterprise data platform. Establishes data governance framework.
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.
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.
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.
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 standards for DS: mandatory model tests, automated evaluation gates, reproducibility requirements.
Classical Machine Learning
▼
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.
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.
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.
Shapes high-dimensional data strategy at organizational level. Evaluates state-of-the-art methods (contrastive learning, self-supervised representations) for scaling feature engineering.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Defines data strategy at product level. Establishes Query Optimization standards. Conducts data schema and scaling strategy reviews.
Deep Learning
▼
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.
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.
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.
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.
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.
Shapes pre-trained models and transfer learning strategy at organizational level. Defines investments in pre-training infrastructure. Evaluates foundation models and their applicability for organizational tasks.
Distributed Tracing
▼
Understands OpenTelemetry for ML: tracing prediction requests, monitoring model latency.
Instruments ML: distributed tracing for prediction pipeline, custom metrics, feature latency.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Relational Databases
▼
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.
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.
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.
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.
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.
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.
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.