Given a scenario where a critical production service is experiencing intermittent latency spikes, describe your systematic approach to diagnose the root cause, identifying potential bottlenecks in the application code, infrastructure, or network, and outline the steps you would take to resolve it, including any coding-related optimizations.

Employ the MECE framework for diagnosis: 1. Monitor & Observe: Analyze APM (Datadog, New Relic) for service metrics (latency, error rates, throughput), infrastructure (CPU, memory, disk I/O, network I/O), and logs (ELK stack, Splunk) for anomalies. 2. Isolate: Use binary search or divide-and-conquer to narrow down the affected component (application, database, cache, network, load balancer). 3. Hypothesize: Formulate potential causes based on observations (e.g., database contention, inefficient queries, network saturation, resource exhaustion, garbage collection pauses). 4. Test & Validate: Introduce controlled changes or targeted tests to confirm hypotheses. 5. Resolve: Implement fixes (e.g., optimize database queries with indexing, introduce caching, scale resources, refactor inefficient code, update network configurations). 6. Verify & Prevent: Monitor post-fix, establish alerts, and implement preventative measures (e.g., chaos engineering, performance testing, code reviews).

My systematic approach to diagnosing intermittent latency spikes in a critical production service involves the following steps: First, I'd leverage comprehensive monitoring tools (e.g., Prometheus, Grafana, Datadog) to gather real-time metrics across the application, infrastructure (EC2, Kubernetes), and network layers. I'd look for correlations between latency spikes and resource utilization (CPU, memory, I/O), network throughput, and specific application endpoints or database queries. Analyzing logs (Splunk, ELK) for error patterns or unusual events would be crucial. Next, I'd isolate the problem domain using a process of elimination, starting with the application layer (e.g., inefficient code, N+1 queries, unoptimized database calls), then moving to infrastructure (resource contention, misconfigurations), and finally the network (packet loss, high latency between services). For resolution, coding-related optimizations might include: implementing caching (Redis, Memcached) to reduce database load, optimizing SQL queries with proper indexing, refactoring inefficient algorithms, or introducing asynchronous processing. Infrastructure-wise, scaling resources, optimizing load balancer configurations, or fine-tuning JVM garbage collection settings could be necessary. Post-resolution, I'd implement continuous monitoring and performance testing to prevent recurrence.