What a Senior } should know

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Enforces Hexagonal Architecture principles across team codebases. Reviews pull requests for proper port/adapter separation. Mentors developers on isolating domain logic from external dependencies.

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.

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).

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.

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.

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.

Designs observability strategy with On-Call Management. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.

Designs observability strategy with OpenTelemetry. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.

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.

Designs observability strategy with SLI / SLO / SLA. Implements distributed tracing. Defines SLIs/SLOs. Conducts post-mortems.

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.

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.

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.

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.

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.

Has deep expertise in Monorepo Tools. Designs solutions for production systems. Optimizes and scales. Mentors the team.

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.

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.