Production ML Deployment Architecture & System Diagnostics
Design production ML systems, diagnose failures, optimize architecture
What You Can Do
This skill helps you architect production-grade ML deployments, diagnose failures in distributed systems, and optimize performance bottlenecks through systematic architectural analysis. You'll design resilient inference pipelines, troubleshoot data flow issues, and identify optimization opportunities using proven MLOps patterns. Get actionable recommendations grounded in architecture-first thinking rather than point fixes.
Features
Build containerized inference pipelines with load balancing, auto-scaling, and multi-region strategies
Systematically trace failures across distributed components (data ingestion, model serving, orchestration)
Analyze latency, throughput, and resource utilization across GPU/CPU/memory/networking
Design redundancy, circuit breakers, fallback strategies, and graceful degradation patterns
Set up metrics, traces, logs, and alerting hierarchies for production systems
Right-size infrastructure, identify wasteful patterns, and balance performance vs. cloud spend
Design data validation, feature engineering workflows, and data quality monitoring
Example Output
Example 1: Deployment Architecture for Real-Time Inference
Component Topology:
┌─────────────────┐
│ Load Balancer │ (health check every 5s)
└────────┬────────┘
│
┌────┴────┐
│ │
┌───▼──┐ ┌───▼──┐
│ Pod 1 │ │ Pod 2 │ (auto-scale 2-10 pods based on QPS)
└───┬──┘ └───┬──┘
│ │
└────┬─────┘
│
┌────▼──────────┐
│ Feature Store │ (cached, 500ms TTL)
└────┬──────────┘
│
┌────▼──────────┐
│ Model Server │ (TorchServe + GPU)
└────────────────┘
Key Decisions:
• p95 latency: 120ms (50ms model, 30ms network, 40ms cache)
• Failover: Circuit breaker opens after 5 errors
• Auto-scale trigger: CPU > 70% for 2 minutes
Example 2: Production Failure Diagnosis
Issue: Inference latency spiked to 2s; error rate hit 15%
Root Cause Chain:
- Feature Store cache eviction (Redis memory full)
- Cache misses → DB fallback queries
- DB bottleneck → slow feature fetches
- Model server queued requests → timeout after 30s
- Client retries → cascading failures
Immediate Fix: Increased Redis memory, implemented cache prewarming Prevention: Set alerts at 80% memory; implement bulkhead isolation for feature store timeouts
Example 3: Cost Optimization Plan
Current: 4x GPU instances, $12k/month (avg utilization 25%)
Optimizations:
- Reduce to 2x GPU + spot pricing (-60% cost)
- Implement request batching (collect 32 predictions)
- Add CPU fallback for low-latency requests
- Cache 80% of prediction outputs
Result: $4.8k/month (60% savings) with p95 latency unchanged
What's Included
- SKILL.md file: Complete skill with decision trees, diagnostic workflows, and architecture templates
- Deployment Architecture Templates: Reference blueprints for single-region, multi-region, and edge ML deployments
- Failure Diagnosis Checklist: Systematic protocol to trace issues across data ingestion, model serving, and orchestration layers
- Performance Analysis Worksheet: Structured format to collect latency, throughput, and resource utilization metrics
- Monitoring Setup Guide: SLO definitions, alerting thresholds, and dashboard templates for production ML systems
- Resilience Pattern Library: Circuit breakers, bulkheads, timeouts, retry logic, and graceful degradation patterns
- Cost Analysis Template: Cloud resource costing model and optimization opportunities worksheet
Who It's For
- ML/Platform Engineers — deploying and maintaining production ML systems at scale
- DevOps/SRE teams — managing infrastructure reliability and performance optimization
- ML Research Leaders — scaling experimental models to production workloads
- Solutions Architects — designing enterprise ML deployment strategies
- System Performance Engineers — optimizing latency-sensitive ML workloads
Best For
- Architecting containerized ML inference systems at scale
- Diagnosing and resolving production outages in ML pipelines
- Optimizing GPU utilization and reducing compute costs
- Designing multi-region or edge ML deployment strategies
- Implementing monitoring and observability for production ML systems
You might also like
You can accelerate your entire antenna design workflow—from initial concept to optimized specifications—by leveraging Claude's knowledge of electromagnetic theory, antenna types, and design trade-offs. Claude helps you parameterize designs, identify optimal configurations for your frequency band and application, and prepare detailed briefs for simulation and manufacturing. You'll generate design reviews, impedance-matching solutions, and validation checklists without context-switching to multiple tools.
You can convert raw API code, OpenAPI specs, GraphQL schemas, and implementation details into production-ready reference documentation. The skill generates systematically organized endpoint documentation with parameter tables, real request/response examples, error code catalogs, authentication details, rate limits, and SDK usage snippets in multiple programming languages—creating the authoritative developer reference for REST APIs, GraphQL APIs, WebSocket APIs, and webhook schemas.
Rapidly analyze production incidents by correlating observability signals—logs, metrics, traces, and events—to identify the true root cause instead of symptoms. You'll reconstruct incident timelines, quantify impact scope, and generate both immediate remediation steps and long-term prevention measures.
This skill guides you through designing Kalman filters for your specific state estimation and sensor fusion problems. You'll learn to diagnose filter divergence, tune covariance matrices (Q and R), and validate observability—turning mathematical theory into production-ready filters. The skill provides step-by-step workflows, diagnostic tools, and practical templates for common applications like GPS/IMU fusion, SLAM, and aircraft navigation.
Claude analyzes your code diffs and generates standardized commit messages that follow the Conventional Commits specification. The skill automatically determines the correct commit type, scope, and description based on the changes you've made, ensuring your messages are parseable by automation tools while remaining human-readable for code reviewers.
You'll transform high-level feature requirements into a complete development plan covering API design, frontend implementation, testing strategy, and documentation. The skill helps you identify dependencies, parallelize work across frontend and backend teams, and establish quality gates that ensure features ship bug-free with proper error handling and logging.
You get a comprehensive security and gas optimization review of your Solidity smart contracts. The skill identifies common vulnerabilities like reentrancy attacks, overflow/underflow bugs, and unchecked external calls, while also pinpointing expensive operations and suggesting specific gas optimizations. Use this as a pre-audit screening to catch issues early and prepare your code for professional security review.
You can rapidly design, optimize, and validate chromatographic and LC-MS/MS methods for analyzing drugs and metabolites in biological matrices. This skill guides you through analytical method development workflows—including parameter selection, sensitivity optimization, and regulatory strategy—while ensuring ICH Q2(R2) and FDA compliance throughout the development process.