Skill UI

A master-level architect specializing in reviewing and guiding complex, modern distributed systems. This skill excels at evaluating adherence to patterns like Clean Architecture, DDD, and Microservices. Use it when assessing scalability, resilience, security posture, and maintainability across major design changes, ensuring the resulting system is robust and future-proof.

Designs and executes chaos experiments, failure-injection frameworks, and game days for distributed systems, providing runbooks, manifests, rollback plans, and continuous resilience automation in CI/CD.

Expert guide for designing robust, scalable, and resilient backend systems. Covers modern patterns including Microservices, Event Sourcing, CQRS, and advanced API contracts (REST, GraphQL, gRPC). Specializes in defining service boundaries, implementing distributed transactions (Saga), and integrating comprehensive security measures like OAuth 2.0 and mTLS.

This skill provides comprehensive guidance on implementing distributed tracing using industry standards like OpenTelemetry and tools such as Jaeger/Tempo. It enables developers to monitor the end-to-end lifecycle of a request across multiple microservices. Use this skill to debug latency issues, visualize complex service dependencies, pinpoint performance bottlenecks, and accurately trace error propagation in highly distributed systems.

This skill is designed for advanced error detective work. It analyzes complex log streams, correlates stack traces across distributed systems, and detects anomalous error patterns. It helps identify root causes by correlating errors with system deployments and changes, providing actionable findings for immediate fixes and long-term prevention strategies.

Guides designing robust microservices with service boundaries, event-driven communication, saga orchestration, API gateways, health checks, and anti-pattern awareness for resilient distributed systems.

This skill provides a comprehensive framework for mastering microservices architecture patterns. It covers critical aspects of building robust, distributed systems, including defining service boundaries (Domain-Driven Design), managing inter-service communication, handling distributed data transactions, and implementing various resilience patterns (e.g., circuit breaker, circuit breaker). It is essential for large-scale system decomposition.

Expert skill in designing and implementing comprehensive observability stacks for enterprise microservices. Covers advanced monitoring (Prometheus, Grafana), distributed tracing (Jaeger, OpenTelemetry), centralized logging (ELK, Splunk), and defining SLIs/SLOs. Ideal for ensuring high availability, mastering incident response, and performing reliability engineering on large-scale, distributed applications.

This skill simulates an expert performance engineer capable of diagnosing complex bottlenecks across the entire technology stack. It covers modern observability techniques (OpenTelemetry, APM), advanced profiling (CPU, Memory, I/O), and sophisticated load testing strategies (k6, Chaos Engineering). Use this when optimizing scalability, reducing latency, improving throughput, or architecting highly reliable, performant distributed systems in cloud environments.

Execute controlled chaos experiments to proactively test system resilience, fault tolerance, and recovery capabilities. This toolkit simulates real-world failures, such as network latency, service crashes, resource exhaustion, and dependency outages, ensuring that microservices degrade gracefully and recover automatically. It is essential for modern distributed systems validation.

A comprehensive skill set for mastering enterprise-grade Scala development. Expertise covers functional programming, distributed systems, and big data processing using technologies like Pekko, Akka, Spark, ZIO, and Cats Effect. Ideal for designing and implementing resilient, scalable microservices based on Domain-Driven Design principles.

A comprehensive guide to configuring Sentry error tracking and performance monitoring across modern application architectures. Learn how to implement coherent, end-to-end distributed tracing for monoliths, microservices, serverless functions (Lambda/Cloud Functions), event-driven systems, SPAs, and mobile applications, ensuring all application hops are monitored from a single source.