What a Senior } should know

Designs algorithms for large-scale data processing: chunk processing, cursor pagination, streaming. Optimizes memory-bound operations through generators. Finds and eliminates bottlenecks using Blackfire/Xhprof.

Designs event-driven architecture: pub/sub, saga pattern for distributed transactions, eventual consistency. Optimizes queue throughput. Ensures exactly-once and at-least-once processing semantics.

Implements quality metrics: cyclomatic complexity, coupling, code coverage. Designs architectural rules via PHPStan/Psalm custom rules. Automates quality control in CI. Mentors on clean code.

Designs efficient structures for production: bloom filters, LRU caches, trie for autocomplete. Optimizes memory consumption through generators, weak references, and typed arrays. Chooses between in-memory structures and Redis.

Combines patterns for complex problems: CQRS for read/write separation, Event Sourcing for audit, Specification for complex filters. Adapts patterns to project context rather than applying dogmatically.

Designs domain models following DDD: Entities, Value Objects, Aggregates. Applies GRASP principles for responsibility distribution. Refactors legacy code to clean object model without losing functionality.

Has deep expertise in PHP type system — designs domain models maximizing static analysis coverage with PHPStan/Psalm at maximum strictness levels. Architects type-safe frameworks using generics in templates, immutable value objects, and typed event systems. Mentors team on transitioning codebases to strict typing, effective phpstan baseline management, and type-safe ORM patterns.

Designs event-driven architecture on Kafka. Configures Kafka Connect for CDC (Debezium). Optimizes throughput (batching, compression, partitioning strategy). Designs event schema evolution strategy. Monitors lag, throughput via Prometheus/Grafana.

Designs caching for high-load: cache warming, stampede protection strategies (lock, early expiration), stale-while-revalidate. Optimizes the full stack: opcache tuning, query cache, CDN purge.

Designs search architecture: custom analyzers for Russian/English, synonym filters, fuzzy matching. Optimizes indexes: sharding strategy, reindex without downtime. Implements aggregations for analytics.

Designs messaging architecture for PHP systems: implements event-driven communication between PHP services via RabbitMQ with exchange routing, integrates PHP with Kafka via php-rdkafka for event streaming. Designs idempotent consumers and transactional outbox for consistency.

Designs solutions with PHP Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

Designs fault-tolerant messaging architecture: clustering, quorum queues, federation. Implements saga pattern through queues. Optimizes throughput and latency. Monitors lag and backpressure.

Designs distributed caching: Redis Cluster, sentinel for HA. Implements distributed locks, sliding window counters, leaderboards. Optimizes memory footprint through compression and correct data type selection.

Designs queue architecture: prioritization, rate limiting, circuit breaker for external services. Ensures exactly-once processing through idempotency keys. Monitors throughput, latency, failure rate.

Designs connection architecture for PHP systems: configures Swoole/RoadRunner for real connection pooling in long-running PHP, implements read/write splitting via ProxySQL, optimizes PgBouncer pool mode (session/transaction/statement) for different workloads. Solves prepared statement issues in transaction mode.

Designs schemas for complex domains: polymorphic relationships, EAV for flexible attributes, temporal data, audit trails. Applies denormalization for production. Models bounded contexts.

Designs indexing strategy: composite indexes considering selectivity, covering indexes to avoid table lookups, partial indexes for hot data. Monitors index usage and bloat.

Designs zero-downtime migrations: expand-contract pattern, online schema changes for large tables. Migrates data without production locking. Automates migration compatibility checks with current code.

Designs sharding strategy for PHP systems: implements consistent hashing for shard distribution, designs resharding with zero-downtime via dual-write pattern, configures Vitess for transparent MySQL sharding. Solves cross-shard reporting problems via materialized views or ETL.

Optimizes performance: partitioning, query optimizer hints, covering indexes. Configures master-slave replication. Analyzes slow query log. Designs schemas for high-write or high-read workloads.

Uses advanced features: CTEs, window functions, partial indexes, JSONB operators. Configures pg_stat_statements for monitoring. Optimizes via EXPLAIN ANALYZE. Configures logical replication.

Optimizes complex queries: subqueries vs JOINs, materialized views for aggregations, denormalization for hot paths. Profiles ORM queries. Eliminates lock contention and deadlocks in high-load scenarios.

Designs transactional strategy: optimistic vs pessimistic locking, advisory locks, serializable isolation for critical operations. Handles deadlocks. Implements saga pattern for distributed transactions.

Designs documentation as a product: developer portal, getting started guides, SDKs. Automates client generation from specification. Implements contract testing (specification = tests).

Designs API testing strategy: contract tests, load tests, chaos testing. Creates mock servers for dependencies. Tests race conditions and concurrent access. Automates smoke tests for production.

Designs versioning strategy: sunset policy, changelog automation, consumer-driven contract testing. Ensures smooth migration between versions without client downtime.

Designs GraphQL architecture: schema stitching/federation for microservices, persisted queries for production, custom directives. Optimizes performance: caching, batching, query depth limiting.

Designs gRPC integration for PHP systems: determines which services to implement as gRPC servers (Spiral/RoadRunner) vs gRPC clients, configures retry logic and deadline propagation, integrates with OpenTelemetry for end-to-end tracing. Optimizes performance through persistent connections.

Designs rate limiting for PHP systems: implements multi-tier limiting (nginx → PHP middleware → per-endpoint), configures rate limiting at reverse proxy level to reduce PHP load. Designs adaptive limiting with dynamic thresholds based on server load and response times.

Designs APIs for complex domains: batch operations, long-running tasks with polling, webhooks. Implements content negotiation, conditional requests (ETag/If-Modified-Since). Optimizes API for mobile clients.

Designs fault-tolerant cloud architecture: multi-AZ, auto-scaling groups, disaster recovery. Configures VPC peering, Transit Gateway. Implements zero-downtime deployments. Optimizes costs through Reserved/Spot instances.

Designs container architecture: base images for the team, security hardening (non-root, read-only fs), resource limits. Optimizes build time. Configures container orchestration.

Designs Kubernetes architecture: namespace strategy, network policies, RBAC. Configures GitOps (ArgoCD/Flux). Optimizes resource utilization. Migrates stateful services.

Designs network architecture: VPC layout, subnet strategy, security groups, WAF. Optimizes network latency. Configures DNS failover and geo-routing. Ensures DDoS protection.

Designs CI/CD architecture: reusable workflows, self-hosted runners for specific tasks, blue-green/canary deployments. Optimizes build time. Automates rollback.

Designs integration testing strategy: what to test via integration vs unit, parallel execution, test isolation. Creates test environments as code. Implements contract testing with external services.

Defines testing strategy: testing pyramid, when TDD is mandatory vs when excessive. Designs BDD framework for the team. Integrates acceptance tests in CI with isolated environment.

Designs test architecture: test doubles strategy, shared fixtures, custom assertions for the domain. Tests edge cases and race conditions. Optimizes test suite speed. Implements mutation testing.

Designs auth architecture: centralized identity service, token introspection, RBAC/ABAC. Implements SSO between services. Configures MFA. Ensures secure token storage and rotation.

Conducts security audits: identifies injection points, broken access control, insecure deserialization. Configures security headers. Implements rate limiting for brute-force protection. Automates SAST/DAST in CI.

Designs secure-by-default architecture: encrypted at rest/in transit, secrets management, automated credential rotation. Implements zero-trust approach between services. Conducts threat modeling.

Maximizes productivity with Copilot: generating complex SQL queries, configurations, integration tests. Builds workflows where AI accelerates routine while developers focus on architecture. Creates prompt templates for typical PHP tasks.

Designs PHP applications using Clean/Hexagonal Architecture: Ports & Adapters for integrations, Domain Events for bounded context communication. Refactors legacy to clean architecture without stopping development. Defines anti-corruption layers.

Designs CQRS for PHP systems: implements Ecotone Framework for full CQRS/ES, builds async projections via RabbitMQ, configures read stores (Elasticsearch, Redis) separate from write database. Ensures testability through in-memory event store for integration tests.

Designs PHP system architecture: monolith decomposition into modules/services, event-driven interaction, CQRS for high-load operations. Defines API contracts between services. Conducts capacity planning and designs for load.

Designs PHP platform monitoring: RED metrics for API, USE metrics for infrastructure. Configures distributed tracing. Creates SLI/SLO dashboards. Optimizes metric cardinality. Implements alerting runbooks for on-call.

Designs logging strategy for the PHP platform: correlation IDs between services, distributed tracing via OpenTelemetry. Configures alerts on log patterns. Optimizes log volume without losing diagnostic value.

Conducts architectural reviews: evaluates change impact on the system, backward compatibility, performance implications. Reviews migrations, API contracts, infrastructure configurations. Mentors through review — explains why, not just what to fix.

Defines branching strategy for PHP projects: release branches, feature flags vs long-lived branches. Configures git hooks for quality gates (PHPStan, tests). Automates changelog and semantic versioning. Resolves complex conflicts during large refactorings.