AI Coding Assistants 1
▼
Independently evaluates GitHub Copilot for technical team workflows: configures Copilot integration with team development environments, assesses code quality impact of AI-generated suggestions, establishes review practices for AI-assisted code contributions. Understands trade-offs between AI productivity gains and maintaining code standards.
Designs GitHub Copilot adoption strategies for technical teams: optimizes team-wide prompt engineering practices and code review workflows, implements quality metrics for AI-generated code contributions, measures development velocity impact. Mentors team on balancing AI-assisted productivity with code quality standards.
Defines GitHub Copilot strategy for technical teams: establishes prompt engineering standards and code review workflows for AI-generated code, designs metrics for measuring AI-assisted development effectiveness, drives Copilot adoption aligned with technical excellence practices.
Defines organizational GitHub Copilot strategy for technical excellence: evaluates enterprise AI development platform capabilities and adoption strategies, designs governance for AI-assisted development practices across engineering organizations, establishes standards for measuring AI impact on developer experience and code quality at scale.
Alerting & On-Call 1
▼
Configures SLI/SLO for team-owned microservices — defines latency percentile targets, error rate thresholds, and dependency health indicators. Creates comprehensive service dashboards with burn rate alerts. Participates in on-call rotation and leads incident analysis with structured post-mortem follow-ups.
Designs observability strategy with SLI / SLO / SLA. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.
Defines product observability strategy for team-owned service portfolios — establishes SLO-based approach for microservice reliability, coordinates incident management with dependent teams, and optimizes MTTD/MTTR through improved monitoring and on-call processes.
Defines the organization's observability strategy. Implements platform solutions. Shapes reliability culture. Defines enterprise SLO framework.
Algorithms & Data Structures 2
▼
Independently evaluates algorithmic choices in code reviews and designs: identifies suboptimal algorithm selections, discusses complexity trade-offs with team members, guides algorithm selection for common patterns. Analyzes performance implications of algorithmic decisions in team's codebase.
Evaluates algorithmic decisions in team's system designs and code reviews. Identifies performance bottlenecks caused by suboptimal algorithm choices. Mentors team on algorithmic trade-offs for production workloads. Guides selection between algorithmic approaches considering scalability, maintainability, and performance requirements.
Defines algorithmic standards for engineering team: performance optimization review processes, algorithm selection guidelines, computational complexity assessment practices. Conducts architectural reviews of algorithmic decisions in system-critical components.
Defines organizational algorithmic strategy at technical leadership level: enterprise performance engineering governance, cross-team algorithm selection standards, computational efficiency maturity programs. Makes strategic decisions on performance tooling investments and shapes engineering excellence culture.
Independently evaluates data structure choices in team code reviews and technical designs. Identifies appropriate data structures for common system patterns. Discusses data modeling trade-offs with the team during design reviews.
Evaluates data structure decisions in system designs and architectural reviews. Guides team on optimal data structure choices for specific problem domains. Identifies performance bottlenecks caused by suboptimal data structure selection. Mentors developers on trade-offs between different data structure families for production workloads.
Defines data structure standards for engineering team: data model design review processes, database schema conventions, API data format guidelines. Conducts architectural reviews of data structure decisions. Establishes team knowledge base on data structure selection for common system patterns.
Defines organizational data structure strategy at technical leadership level: enterprise data model governance, cross-team schema standardization programs, data structure competency development. Makes strategic decisions on data architecture tooling and engineering practices evolution.
API Gateway & Service Communication 1
▼
Independently configures API gateway patterns for team services: sets up routing rules, request/response transformations, basic rate limiting and authentication policies. Understands trade-offs between gateway-level and service-level cross-cutting concerns.
Designs API gateway architectures for production systems: implements BFF pattern, configures canary routing and traffic splitting, sets up circuit breakers and retry policies at gateway level. Optimizes gateway performance and establishes monitoring for API traffic.
Defines API gateway standards for engineering teams: designs gateway topology for microservice ecosystems, establishes API contract and versioning conventions, implements centralized auth and observability through gateways. Leads cross-team API design reviews.
Shapes organizational API gateway strategy: evaluates gateway platforms for enterprise-wide adoption, designs multi-region gateway architectures with global traffic management, establishes API governance and lifecycle management frameworks. Mentors lead engineers on gateway architecture decisions.
Application Security 1
▼
Applies OWASP security practices across team development workflows — integrates security scanning into CI/CD pipelines, ensures OWASP Top 10 coverage in code reviews, and coordinates vulnerability remediation priorities. Uses SAST/DAST tools and dependency vulnerability scanners to maintain security baseline.
Designs team-level security practices integration into development workflows — implements threat modeling as part of design process, automated security gates in deployment pipelines, and dependency vulnerability management. Conducts architectural threat modeling and security design reviews. Mentors team on secure coding patterns and OWASP-aware development practices.
Defines security strategy for product development workflows across team boundaries. Establishes security policies for threat modeling requirements, security gate automation, and dependency vulnerability management. Coordinates cross-team security reviews and trains development teams on OWASP-aware architecture design.
Defines enterprise security strategy for software development spanning all technology stacks and product domains. Shapes security architecture governance aligning OWASP best practices with organizational development workflows. Coordinates compliance programs and represents engineering perspective in enterprise security governance and community engagement.
Architecture Governance 4
▼
Applies ADR practices in technical leadership: writes well-structured Architecture Decision Records with context, options analysis, and consequences. Reviews team ADRs for technical accuracy and maintains ADR repository with consistent numbering and status tracking.
Designs ADR practice for technical teams: establishes lightweight decision records for code-level choices, defines escalation criteria for architecture-level ADRs, and implements ADR-as-code workflows integrated with version control and CI/CD pipelines.
Defines the product's architectural strategy with Architecture Decision Records. Establishes architecture guidelines. Conducts architecture reviews.
Defines enterprise ADR standards and technical decision-making framework. Shapes engineering culture around evidence-based architectural decisions with measurable outcomes. Establishes cross-team ADR review boards and drives adoption of decision records as first-class engineering artifacts.
Implements architecture fitness functions for team projects: writes automated tests for architectural constraints (dependency direction, layer isolation), configures ArchUnit/NetArchTest checks in CI. Understands how fitness functions support evolutionary architecture and prevent architectural drift.
Designs comprehensive fitness function suites for production systems: implements holistic architectural checks covering coupling, cohesion, performance budgets, and security constraints. Creates custom fitness functions for domain-specific architectural requirements and mentors team on architectural testing.
Defines fitness function standards across engineering teams: designs reusable fitness function libraries, establishes architectural compliance dashboards, integrates fitness functions into architecture review processes. Leads adoption of evolutionary architecture practices through measurable quality gates.
Shapes organizational evolutionary architecture through fitness functions: designs enterprise fitness function platforms, establishes architectural governance frameworks with automated compliance monitoring, defines reference architectures with embedded fitness functions. Mentors leads on architectural quality measurement.
Applies technical debt management when designing components. Understands trade-offs between delivery speed and code quality. Participates in architectural discussions, tracks debt via SonarQube metrics, and enforces code quality gates during code reviews.
Designs system architecture with technical debt management at the forefront. Makes architectural decisions on refactoring prioritization and documents them via ADR. Evaluates code-level debt using SonarQube metrics and enforces quality gates to prevent new debt accumulation.
Defines the product's architectural strategy with Technical Debt Management. Establishes architecture guidelines. Conducts architecture reviews.
Defines the organization's architectural strategy for technical debt elimination. Designs reference architectures with built-in refactoring prioritization and SonarQube quality gates. Establishes architecture governance for code-level debt tracking and continuous quality improvement.
Applies Technology Radar practices in technical leadership: evaluates new technologies through structured PoCs, contributes technology assessments to team radar, and makes informed adoption/hold/retire decisions. Tracks technology lifecycle and plans migration paths for deprecated tools.
Designs Technology Radar practices for technical teams: establishes technology evaluation frameworks with measurable criteria, creates migration playbooks for technology transitions, and implements automated technology inventory tracking. Mentors team on evidence-based technology decision-making.
Defines the product's architectural strategy with Technology Radar. Establishes architecture guidelines. Conducts architecture reviews.
Defines enterprise Technology Radar standards and technology lifecycle management. Shapes engineering culture around continuous technology evaluation and evidence-based adoption. Establishes cross-organizational technology assessment boards and drives strategic technology investments aligned with business goals.
Architecture Patterns 2
▼
Applies Clean Architecture when designing components and enforces dependency rules across the team. Reviews code for architectural conformance and participates in discussions about layer boundaries and inversion of control.
Designs system architecture with Clean Architecture and enforces dependency rules through architecture tests and automated checks. Establishes ADR processes in the team, ensures proper layer separation, and evaluates non-functional requirements.
Defines the product's architectural strategy with Clean Architecture. Establishes architecture guidelines. Conducts architecture reviews.
Defines the organization's architectural strategy enforcing Clean Architecture principles across all teams. Designs reference architectures with dependency rules and architecture testing frameworks. Establishes governance through ADR processes and review standards.
Applies Hexagonal Architecture when designing components. Understands trade-offs. Participates in architectural discussions.
Enforces Hexagonal Architecture principles across team codebases. Reviews pull requests for proper port/adapter separation. Mentors developers on isolating domain logic from external dependencies.
Defines the product's architectural strategy with Hexagonal Architecture. Establishes architecture guidelines. Conducts architecture reviews.
Shapes the organization's architectural strategy around Hexagonal Architecture and clean boundaries. Designs reference implementations for domain isolation patterns. Establishes architecture review processes ensuring hexagonal compliance.
CI/CD 1
▼
Independently manages GitHub Actions CI/CD for technical teams: configures pipeline standards for code quality enforcement, implements progressive deployment strategies, automates engineering workflow operations. Manages CI/CD practices for technical delivery processes.
Designs CI/CD architecture for technical teams: optimizes pipeline speed and reliability for developer productivity, implements progressive delivery strategies for production services, architects deployment automation with proper rollback mechanisms. Mentors team on CI/CD engineering best practices.
Defines DevOps strategy for technical teams: establishes CI/CD standards for developer productivity and delivery reliability, implements platform engineering approaches for deployment automation, drives engineering excellence through CI/CD best practices.
Defines the organization's DevOps strategy. Designs internal developer platform. Shapes engineering excellence culture.
Clean Code & Refactoring 1
▼
Independently applies code quality practices as a technical lead. Facilitates productive code reviews focusing on design patterns and architectural decisions. Understands trade-offs between code quality enforcement and team autonomy. Reviews cross-cutting concerns for consistency: error handling patterns, logging standards, and API design conventions.
Designs team-wide code quality strategy: establishes review standards calibrated to project maturity, defines refactoring priorities based on defect hotspots and velocity data. Configures automated quality gates in CI/CD pipelines. Mentors developers on design patterns and coaches teams on systematic technical debt reduction.
Defines code quality standards for engineering team: code review process design, refactoring prioritization framework, automated quality tool adoption. Conducts architectural reviews of system-critical components. Establishes team-wide quality metrics and improvement cycles.
Defines organizational code quality strategy at technical leadership level: enterprise code review standards, cross-team refactoring governance, quality engineering maturity model. Makes decisions on quality tooling investments and shapes organization-wide engineering excellence programs.
Cloud Providers 1
▼
Independently configures AWS services for team microservice deployments — ECS/EKS, ALB, RDS, and ElastiCache. Writes IaC for common infrastructure patterns including blue-green deployments and auto-scaling policies. Understands VPC networking for service-to-service communication and IAM best practices for least-privilege access.
Designs AWS infrastructure solutions for production microservice platforms — ECS/EKS deployments, API Gateway integrations, and serverless architectures. Optimizes cost through compute right-sizing, caching strategies, and reserved capacity planning. Implements security hardening with VPC design, WAF rules, and IAM permission boundaries for team workloads.
Defines AWS infrastructure strategy for product platform workloads spanning development and production environments. Establishes IaC standards for microservice deployments, observability, and cost governance. Conducts architecture reviews of team AWS configurations and drives FinOps optimization for product infrastructure.
Defines organizational cloud strategy for AWS-based platform infrastructure spanning development and production environments. Evaluates multi-cloud architectures for workload portability and vendor risk management. Designs enterprise-grade infrastructure governance and establishes FinOps practices for cloud cost accountability across product teams.
Code Review 1
▼
Independently conducts thorough code reviews: evaluates architecture and design decisions, reviews performance and security implications, checks coding standards compliance. Provides constructive feedback fostering team growth and maintaining code quality.
Designs code review processes for the team: review standards and quality gates, constructive feedback guidelines, review cycle time optimization. Mentors team on conducting thorough reviews that balance quality enforcement with developer velocity.
Defines code review strategy for the team: review process standards and SLAs, quality gate definitions, constructive feedback guidelines. Establishes review culture that balances thoroughness with developer productivity.
Defines organizational code review strategy at technical leadership level: enterprise review process governance, cross-team review standardization programs, review culture excellence initiatives. Makes strategic decisions shaping engineering review culture across the organization.
Collaboration Tools 2
▼
Implements docs-as-code in the development workflow: documentation requirements in PR checklists, automated API reference generation (OpenAPI, GraphQL schema), and developer guides co-located with code. Establishes documentation standards for the team and ensures consistency.
Designs documentation strategy for the product: living documentation, automated API docs from source annotations (Swagger, TypeDoc), versioned guides aligned with release cycles. Implements documentation quality gates in CI/CD. Creates architectural documentation standards (ADRs, C4 diagrams) and ensures team adoption.
Defines documentation-as-code strategy at the product/department level. Establishes standards for API documentation, architecture decision records, and developer guides. Drives adoption of developer portal (Backstage, Docusaurus) for centralized documentation. Creates governance for documentation ownership and maintenance.
Defines enterprise documentation-as-code strategy: platform-level documentation infrastructure, developer portal governance, and documentation quality as an engineering KPI. Shapes organizational culture around documentation as a competitive advantage. Drives cross-team documentation standardization and knowledge management.
Applies InnerSource practices in technical leadership: establishes code contribution standards, reviews cross-team pull requests, and maintains shared library documentation. Facilitates technical knowledge sharing through InnerSource project governance.
Designs InnerSource technical practices: shared codebase architecture, API-first internal platforms, and cross-team code review standards. Implements automated contribution quality gates and documentation-as-code for shared components.
Defines InnerSource technical strategy: shared platform architecture, reusable component libraries, and cross-team development standards. Establishes technical governance for internal open-source projects with release management and versioning policies.
Defines enterprise InnerSource technical architecture and platform strategy. Shapes organization-wide engineering practices for internal code sharing, API governance, and developer experience. Mentors leads on building sustainable InnerSource ecosystems.
Concurrency & Parallelism 2
▼
Independently evaluates async programming decisions in code reviews: reviews concurrency patterns, identifies race conditions and deadlock risks, ensures proper error handling in async code. Discusses async trade-offs during design reviews.
Designs async architectures for team projects: async service communication patterns, concurrency strategy selection, error handling and resilience in async systems. Mentors team on async best practices and diagnosing concurrency issues.
Defines async programming standards for engineering team: concurrency pattern guidelines, async architecture reviews, error handling standards for async code. Establishes best practices for async patterns across team projects.
Defines organizational async strategy at technical leadership level: enterprise concurrency pattern governance, cross-team async architecture standards, async maturity model for engineering teams. Makes strategic decisions shaping async programming culture across the organization.
Independently evaluates multithreading approaches for team projects: reviews concurrent code for safety and performance, identifies race conditions and deadlock risks in architecture, selects appropriate concurrency models for system requirements. Explains threading trade-offs for system design decisions.
Has deep expertise in multithreading across technology stacks: designs concurrent system architectures for team projects, identifies and resolves complex race conditions and performance bottlenecks, selects appropriate concurrency models for system requirements. Mentors team on production-ready concurrent programming practices.
Defines multithreading standards for technical teams: establishes guidelines for concurrent system architecture selection, conducts reviews of multi-threaded code for safety and performance, creates training materials on advanced concurrency patterns and anti-patterns.
Defines organizational multithreading strategy for engineering: evaluates enterprise concurrency models and framework selection, makes technology decisions on threading architectures for platform-wide adoption, mentors leads on advanced concurrent system design and performance optimization.
Containerization 1
▼
Independently configures Docker for team projects: Dockerfile best practices for production images, docker-compose for local development environments, container CI/CD pipeline configuration. Understands container networking, security scanning, and resource management for team infrastructure.
Designs Docker infrastructure for team projects: standardized base images, multi-stage build optimization, container security scanning integration. Implements best practices for development environment consistency, CI/CD container pipelines, and production deployment hardening.
Defines Docker infrastructure strategy for team: base image standardization, container CI/CD pipeline governance, development environment container policies. Conducts architecture reviews for containerized deployments and optimizes FinOps for team container resources.
Defines organizational container strategy at technical leadership level: enterprise container adoption standards, cross-team base image governance, container security compliance programs. Designs enterprise-grade container infrastructure and shapes engineering culture around container best practices.
Distributed Tracing 1
▼
Configures OpenTelemetry for team-owned microservices — instruments service endpoints with spans, metrics, and structured logs following OTel semantic conventions. Creates service dashboards with latency percentiles and error rate alerts. Participates in on-call rotation and analyzes distributed traces for cross-service incident resolution.
Designs observability strategy with OpenTelemetry. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.
Defines the product's observability strategy. Establishes SLO-based approach. Coordinates incident management. Optimizes MTTD/MTTR.
Defines the organization's observability strategy. Implements platform solutions. Shapes reliability culture. Defines enterprise SLO framework.
Docs-as-Code 1
▼
Uses Mermaid, PlantUML, or D2 for technical design documents, component diagrams, and data flow visuals. Chooses appropriate diagram types for sequence and interaction modeling. Creates clear architecture sketches for the team independently.
Designs production-grade component diagrams, detailed data flow visuals, and sequence diagrams for complex systems using Mermaid, PlantUML, or D2. Optimizes technical documentation with layered diagram views. Mentors engineers on design documentation best practices.
Defines diagramming strategy for technical design documentation, component modeling, and data flow visualization at the team level. Establishes standards for sequence diagrams, API interaction visuals, and system boundary maps. Conducts reviews of technical diagram clarity and accuracy.
Defines organization-wide diagramming strategy for technical design documentation, component modeling standards, and data flow visualization patterns. Establishes enterprise approaches to sequence diagrams and system boundary mapping. Mentors leads and architects on technical diagramming excellence.
Domain-Driven Design 2
▼
Applies DDD Strategic Patterns when designing components. Understands trade-offs. Participates in architectural discussions.
Applies Context Mapping to decompose monoliths into cohesive microservices. Makes architectural decisions on Ubiquitous Language enforcement within team boundaries. Evaluates domain events as integration contracts between upstream and downstream contexts.
Defines the product's architectural strategy with DDD Strategic Patterns. Establishes architecture guidelines. Conducts architecture reviews.
Defines the organization's DDD adoption roadmap from legacy systems to strategic domain models. Designs reference architectures for event-driven context integration at scale. Establishes governance for bounded context lifecycle, team alignment, and cross-domain contracts.
Applies DDD Tactical Patterns when designing components. Understands trade-offs. Participates in architectural discussions.
Designs codebase architecture with DDD tactical patterns. Establishes aggregate design guidelines, domain event contracts, and repository abstractions. Conducts architectural reviews ensuring proper separation of domain and infrastructure layers.
Defines the product's architectural strategy with DDD Tactical Patterns. Establishes architecture guidelines. Conducts architecture reviews.
Defines organization's DDD adoption strategy and reference architectures. Establishes architecture governance with pattern libraries, aggregate design guidelines, and domain modeling workshops. Shapes enterprise-wide domain-driven development culture.
Git & Workflows 2
▼
Independently applies Git advanced practices for technical leadership: designs branching strategies for team projects, resolves complex multi-branch merge scenarios, configures Git hooks for code quality enforcement. Understands trade-offs between different workflow models (GitFlow, trunk-based, GitHub Flow) for team contexts.
Designs Git workflows for technical teams: implements branching strategies optimized for team size and release cadence, configures advanced merge queues and CI gatekeeping, resolves complex multi-branch integration scenarios. Mentors team on Git internals knowledge for effective troubleshooting and history management.
Defines Git strategy for technical teams: establishes branching and merge policies optimized for team delivery metrics, designs Git hook ecosystems for automated quality enforcement, drives adoption of advanced Git techniques (worktrees, sparse checkout) for developer productivity.
Defines organizational Git strategy for technical excellence: evaluates enterprise Git platform capabilities and migration paths, designs governance for branching models and workflow standardization across teams, establishes standards for Git-based developer experience optimization and tooling.
Independently applies Monorepo Tools in practice. Understands trade-offs of different approaches. Solves typical tasks independently.
Has deep expertise in Monorepo Tools. Designs solutions for production systems. Optimizes and scales. Mentors the team.
Defines Monorepo Tools strategy at the team/product level. Establishes standards and best practices. Conducts reviews.
Defines Monorepo Tools strategy at the organizational level. Establishes enterprise approaches. Mentors leads and architects.
GraphQL 1
▼
Independently designs GraphQL schemas for team-owned services with proper type hierarchies and federation boundaries. Implements resolver patterns, dataloader batching, and connection-based pagination. Reviews team API designs and writes comprehensive schema documentation and testing guidelines.
Designs GraphQL API architecture for production microservice ecosystems with schema federation and domain-driven boundaries. Defines error handling standards, pagination patterns, and query cost analysis policies. Optimizes resolver performance through dataloader strategies and query plan analysis. Mentors team on schema design best practices.
Defines GraphQL API strategy across product domains. Establishes schema design standards, federation governance, and API lifecycle management processes. Conducts cross-team schema design reviews and coordinates unified API experience across consumer applications.
Defines organizational GraphQL API strategy spanning all product domains and engineering teams. Designs platform-level schema registry and federated gateway architecture. Establishes enterprise API governance standards, developer tooling for schema-first development, and organizational API design review processes.
gRPC 1
▼
Independently designs gRPC services for team-owned microservices — defines proto schemas with proper type hierarchies and oneof patterns, implements interceptors for logging and authentication, and establishes proto style guidelines. Writes comprehensive API documentation and integration tests for service contracts.
Designs gRPC API architecture for production microservice platforms — interceptor chains for cross-cutting concerns, proto schema evolution with backward compatibility guarantees, and deadline propagation across service boundaries. Defines error handling standards with rich status details and optimizes gRPC performance through connection management and compression strategies.
Defines API strategy at the product level. Establishes design standards. Conducts API design reviews. Coordinates cross-team API interaction.
Defines organizational gRPC API strategy spanning all product domains and engineering teams — designs platform-level proto governance, schema registry infrastructure, and enterprise code generation pipelines. Establishes organizational API standards for gRPC service development ensuring consistency and backward compatibility.
Incident Management 1
▼
Configures on-call management for product services: service-level alerting aligned with SLOs, PagerDuty/OpsGenie integration, and on-call rotation optimization. Creates runbooks for common incidents and automates remediation where possible. Mentors team on incident response practices and blameless post-mortems.
Designs observability strategy with On-Call Management. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.
Defines on-call management strategy for the product. Establishes SLO-based alerting approach, incident management framework, and post-mortem process. Coordinates cross-team incident response. Optimizes MTTD/MTTR through observability improvements and automated remediation.
Defines the organization's observability strategy. Implements platform solutions. Shapes reliability culture. Defines enterprise SLO framework.
Infrastructure as Code 1
▼
Independently manages team's Terraform infrastructure. Writes IaC for application environments, CI/CD pipelines, and monitoring stacks. Reviews team members' Terraform PRs for security and best practices. Understands networking fundamentals (VPC, subnets, security groups) in Terraform context.
Designs modular Terraform architecture for the product infrastructure. Creates reusable modules with comprehensive documentation and versioning. Implements policy as code (Sentinel/OPA) for compliance enforcement. Configures Terragrunt for DRY multi-environment configurations. Automates drift detection and remediation. Mentors team on IaC best practices.
Defines IaC strategy for the product organization. Evaluates Terraform vs Pulumi vs Crossplane for different use cases. Implements self-service infrastructure via Terraform modules integrated with developer portal (Backstage). Designs multi-account/multi-project landing zones. Drives FinOps through infrastructure tagging and cost estimation in CI. Manages Terraform at scale (1000+ resources).
Defines the organization's cloud and infrastructure strategy at the enterprise level. Evaluates multi-cloud vs single-cloud approaches based on business objectives and regulatory requirements. Designs enterprise-grade infrastructure platforms with self-service capabilities. Establishes FinOps culture and practices across the organization. Influences industry through thought leadership on infrastructure automation.
Infrastructure Security 1
▼
Implements secrets management patterns in team services: environment-specific Vault paths, dynamic database credentials, and application-level secret caching with TTL. Reviews PRs for proper credential handling and ensures no secret leakage in logs or error messages. Integrates secret scanning into CI/CD pipeline.
Designs secrets management strategy for the product: Vault agent sidecar patterns for Kubernetes, transit encryption for sensitive data, and PKI integration for service-to-service mTLS. Implements automated secret rotation with zero-downtime application reloading. Creates monitoring for secret access patterns and policy violations. Mentors team on production-grade secrets architecture.
Defines secrets management strategy at the product/department level. Establishes standards for secret rotation policies, audit logging requirements, and access control patterns. Evaluates Vault Enterprise features vs open-source for team needs. Drives adoption of automated secret management across all services.
Defines enterprise security strategy with secrets management as foundational infrastructure. Shapes security architecture across all products and platforms. Coordinates compliance requirements (SOC2, ISO27001) for credential handling. Drives adoption of zero-trust credential patterns and automated secrets lifecycle management across the organization.
Kubernetes & Orchestration 1
▼
Independently configures Kubernetes deployments for team-owned microservices. Writes IaC for common deployment patterns including rolling updates, health probes, and HPA. Understands Kubernetes networking and security basics for multi-team cluster environments and namespace-level RBAC.
Designs Kubernetes infrastructure for production microservice deployments with service mesh, observability, and GitOps workflows. Implements cost and performance optimization through HPA/VPA tuning, pod topology constraints, and resource right-sizing. Applies security hardening best practices and mentors team on Kubernetes operations excellence.
Defines Kubernetes infrastructure strategy for product platform workloads across development and production environments. Establishes IaC standards for deployment patterns, observability, and cost management. Conducts architecture reviews of team Kubernetes configurations and coordinates cross-team infrastructure decisions and FinOps optimization.
Defines organizational cloud strategy for Kubernetes-based platform infrastructure spanning development and production environments. Evaluates multi-cloud architectures for workload portability and vendor risk management. Designs enterprise-grade Kubernetes platforms and establishes FinOps practices for organizational cloud cost governance.
Logging 1
▼
Configures observability practices for technical teams: establishes structured logging standards for service components, reviews dashboard and alert configurations for effectiveness, tracks operational metrics for reliability improvements. Participates in incident management and drives post-mortem practices.
Designs observability strategy for technical teams: implements distributed tracing and correlation across services, defines SLIs/SLOs aligned with product reliability targets, drives post-mortem culture and incident learning. Mentors team on observability-driven development and operational excellence practices.
Defines observability strategy for technical products: establishes SLO-based approach for service reliability targets, coordinates incident management and on-call practices across teams, optimizes MTTD/MTTR through improved monitoring, alerting, and runbook standardization.
Defines organizational observability strategy for technical excellence: implements enterprise reliability platforms and observability tooling standards, shapes reliability culture through engineering practices and architectural patterns, defines enterprise SLO framework for service reliability and developer experience.
Metrics & Monitoring 1
▼
Configures Prometheus and Grafana practices for technical teams: establishes monitoring standards for service components, reviews dashboard effectiveness and alert noise levels, tracks operational metrics for reliability improvements. Participates in incident management and drives observability practices.
Designs observability strategy with Prometheus & Grafana for technical teams: implements monitoring standards across service components, defines SLIs/SLOs aligned with product reliability targets, drives post-mortem culture and incident learning. Mentors team on observability-driven development practices.
Defines observability strategy for technical products with Prometheus & Grafana: establishes SLO-based approach for service reliability targets, coordinates incident management and on-call practices, optimizes MTTD/MTTR through improved monitoring and alerting standardization.
Defines organizational observability strategy for technical excellence with Prometheus & Grafana: implements enterprise reliability platforms and monitoring tooling standards, shapes reliability culture through engineering practices, defines enterprise SLO framework for service reliability and developer experience.
Microservices Patterns 1
▼
Drives microservices decomposition decisions: identifies bounded contexts via domain modeling sessions, defines service contracts and API boundaries. Applies Strangler Fig pattern for incremental migration. Establishes inter-service communication standards (sync vs async) and data ownership rules across services.
Leads complex microservices decomposition initiatives: defines bounded context boundaries through Event Storming and domain modeling. Designs Strangler Fig migration with feature-flag-driven traffic shifting. Implements CQRS with event sourcing for high-consistency domains. Establishes service contracts, versioning strategy, and backward compatibility standards. Mentors teams on decomposition anti-patterns (distributed monolith, shared databases).
Defines the product's architectural strategy with Microservices Decomposition. Establishes architecture guidelines. Conducts architecture reviews.
Defines organization-wide microservices decomposition philosophy: establishes DDD strategic design as core architectural discipline, creates bounded context discovery frameworks used across all teams. Designs evolutionary architecture patterns enabling incremental decomposition without big-bang rewrites. Architects platform capabilities (service mesh, event backbone, Saga orchestration) as organizational standards. Drives decomposition maturity model and architectural review process. Mentors leads on balancing decomposition idealism with pragmatic delivery constraints.
OOP & Design Patterns 2
▼
Independently evaluates and guides design pattern usage: reviews architectural decisions for appropriate abstraction levels, identifies pattern misuse and over-engineering, facilitates team discussions on pattern trade-offs for maintainability. Explains design pattern implications for system evolution and developer productivity.
Has deep expertise in evaluating and applying design patterns: designs team-level architectural patterns aligned with system requirements, identifies anti-patterns and refactoring opportunities, optimizes pattern decisions for long-term code maintainability. Mentors team on strategic pattern application and architectural decision-making.
Defines design pattern standards for technical teams: establishes architectural review practices for pattern consistency across services, creates guidelines for pattern selection and refactoring strategies, conducts training on advanced patterns and anti-pattern recognition.
Defines organizational strategy for design patterns in engineering: evaluates enterprise approaches to pattern governance and competency development, makes technology decisions on architectural pattern standards, mentors leads on strategic pattern application for organizational technical excellence.
Independently evaluates OOP/SOLID application in team code reviews: identifies proper abstraction boundaries, reviews inheritance vs composition decisions, ensures dependency inversion in service architecture. Discusses design pattern trade-offs with the team and maintains coding standards.
Applies OOP/SOLID in team's architectural decisions: enforces clean abstraction boundaries in system designs, reviews code for proper dependency management and interface design, mentors on design pattern trade-offs. Guides team on pragmatic application of SOLID principles avoiding over-engineering.
Defines OOP/SOLID standards for engineering team: design pattern usage guidelines, architectural review processes for class hierarchies, refactoring strategies for legacy code. Conducts reviews ensuring consistent application of SOLID principles across all team projects.
Defines organizational OOP strategy at technical leadership level: enterprise design pattern governance, cross-team SOLID maturity assessment, code architecture excellence programs. Makes strategic decisions on refactoring tooling investments and shapes engineering culture around clean design.
Release Management 1
▼
Integrates feature flags into the team's development workflow for trunk-based development. Implements flag-driven canary releases and progressive delivery strategies. Establishes naming conventions and flag categorization. Monitors flag impact on system performance and user metrics.
Architects scalable feature flag infrastructure supporting thousands of flags with low-latency evaluation. Designs flag dependency graphs to prevent conflicting configurations. Implements server-side and client-side flag SDKs with local caching and streaming updates for real-time targeting.
Defines technical standards for feature flag platforms across the engineering organization. Establishes flag evaluation performance SLAs and reliability requirements. Drives adoption of flag-based testing strategies including dark launches and shadow traffic. Reviews flag architectures for complex cross-service features.
Defines the organization's DevOps strategy. Designs internal developer platform. Shapes engineering excellence culture.
REST API 1
▼
Independently evaluates REST API design in code reviews: reviews endpoint structure and naming conventions, evaluates pagination and error handling patterns, ensures API versioning consistency. Understands best practices for team API design guidelines and developer experience.
Designs API architecture for team products: API design standards and review processes, versioning and deprecation strategies, API documentation and developer portal requirements. Defines API contracts for inter-service communication. Mentors team on consistent RESTful API design.
Defines API strategy for team at product level: API design standards and review processes, versioning and deprecation governance, API documentation and portal requirements. Conducts API architecture reviews and establishes API quality standards for the team.
Defines organizational API strategy at technical leadership level: enterprise API design governance, cross-team API standardization programs, API tooling investment decisions. Designs enterprise-grade API architecture and shapes engineering culture around API excellence.
System Design 2
▼
Applies high-load architecture when designing components. Understands trade-offs in connection pooling, async processing, and rate limiting. Establishes performance budgets for the team and reviews code for high-load anti-patterns.
Designs system architecture with high-load patterns, making ADR-documented decisions on connection pooling, async processing pipelines, and rate limiting strategies. Sets performance budgets for teams and enforces high-load coding standards across services.
Defines the product's architectural strategy with High Load Architecture. Establishes architecture guidelines. Conducts architecture reviews.
Defines the organization's architectural strategy for high-load systems. Designs reference architectures for connection pooling, async processing pipelines, and rate limiting at scale. Establishes organization-wide performance budgets and high-load engineering excellence standards.
Applies system design principles when designing product components: defines service boundaries, evaluates data storage choices, and designs communication patterns between services. Understands trade-offs in consistency, availability, and partition tolerance. Participates actively in architectural decision-making.
Designs system architecture for product: service decomposition, data architecture, and integration patterns. Makes architectural decisions (ADRs) balancing scalability, reliability, and development velocity. Evaluates non-functional requirements and designs for operational excellence. Creates architecture documentation and mentors team on design thinking.
Defines the product's architectural strategy with System Design Fundamentals. Establishes architecture guidelines. Conducts architecture reviews.
Defines organizational architecture strategy: establishes reference architectures, architecture governance framework, and technology selection criteria. Designs architecture for enterprise-scale systems with focus on long-term evolution and sustainability. Drives architectural excellence across the organization through mentoring leads and establishing best practices.
Technical Documentation 1
▼
Independently applies C4 model and arc42 to document the architecture of team services and their integrations. Authors ADRs that clearly capture context, decision, and consequences of technical choices. Understands trade-offs between diagram-as-code tools (Structurizr, PlantUML) and visual editors. Keeps documentation aligned with CI/CD pipelines and deployment topology.
Designs the architecture documentation strategy for complex multi-service systems using C4 and arc42. Establishes ADR conventions including numbering, lifecycle states, and superseding rules. Mentors developers on creating meaningful component and container diagrams rather than superficial overviews. Integrates documentation generation into CI pipelines using Structurizr DSL or similar diagram-as-code tools.
Defines architecture documentation strategy at the team and product level, selecting appropriate C4 depth and arc42 sections per service criticality. Establishes best practices for ADR authoring including templates, status workflows, and linking to implementation PRs. Conducts regular architecture documentation reviews to prevent drift between diagrams and actual system state. Champions documentation-as-code culture with automated rendering and publishing pipelines.
Defines architecture documentation strategy at the organizational level, standardizing C4 and arc42 usage across all engineering departments. Establishes enterprise ADR governance with centralized registries, cross-domain linking, and automated staleness detection. Drives adoption of architecture documentation toolchains (Structurizr, Backstage, architectural fitness functions) at scale. Mentors leads and architects on building self-sustaining documentation ecosystems that remain accurate as the organization evolves.