What a Mid-level } should know

Analyzes algorithmic complexity of PHP code and SQL queries. Optimizes collection processing — replaces nested loops with hash tables. Applies binary search, greedy algorithms in business logic. Profiles via Xdebug.

Designs async flows: priority queues, delayed tasks, retry logic. Works with message brokers for inter-service communication. Handles errors and dead letter queues. Uses Fibers for concurrent I/O.

Configures static analysis at high strictness level. Refactors legacy code: extracts methods, simplifies conditions, eliminates god classes. Writes self-documenting code. Conducts peer code reviews.

Chooses structures for the task: SplPriorityQueue for queues, SplFixedArray for numeric data, generators for streaming. Understands PHP array internals as hash table. Works with category trees and dependency graphs.

Applies patterns deliberately: Observer for events, Decorator for extending functionality, Chain of Responsibility for middleware. Refactors code using appropriate patterns. Understands anti-patterns.

Applies SOLID in practice: extracts interfaces, uses composition over inheritance, follows LSP. Designs class hierarchies for business domains. Writes code with low coupling and high cohesion.

Independently applies PHP type system features — intersection types, enums with backed values, and readonly properties for immutable DTOs. Understands trade-offs between phpstan level strictness and development velocity. Applies type-safe patterns with generics in doc-blocks, typed collections, and strict return type declarations in code reviews.

Develops producers and consumers. Understands partitions, consumer groups, offsets. Handles errors: retry, dead letter queue. Uses Avro/Protobuf for serialization. Configures delivery guarantees (at-least-once, exactly-once).

Implements multi-level caching: OPcache for bytecode, APCu for local data, Redis for shared cache. Designs invalidation strategies: TTL, event-based, tag-based. Measures hit/miss ratio.

Independently implements Elasticsearch / OpenSearch tasks. Understands internals and optimizes performance. Writes tests.

Works with messaging in PHP: uses Symfony Messenger with RabbitMQ/Redis transport, configures Laravel Horizon for queue monitoring, applies routing by message type. Handles failed jobs through retry and dead letter queues, configures priority queues.

Independently implements tasks with PHP Frameworks. Understands internals and optimizes performance. Writes tests.

Designs exchange topology: fanout for broadcast, topic for routing, headers for complex rules. Configures dead letter queues and retry mechanisms. Ensures idempotent message processing.

Applies different strategies: cache-aside, write-through, write-behind. Uses Redis for queues (lists), rate limiting (sorted sets), pub/sub. Designs keys with namespaces. Handles cache stampede.

Independently implements Task Queue tasks. Understands internals and optimizes performance. Writes tests.

Solves connection management in PHP: configures PgBouncer/ProxySQL as external connection pooler for PHP-FPM, optimizes persistent connections considering FPM lifecycle. Monitors connection count via database status commands and configures wait_timeout.

Designs data schemas for business domains: normalization to 3NF, denormalization for performance, polymorphic relationships. Models soft deletes, record versioning, audit logs. Chooses between EAV and JSON columns for flexible attributes.

Analyzes execution plans via EXPLAIN ANALYZE. Creates composite indexes considering selectivity and column order. Uses covering indexes for optimizing frequent queries. Monitors unused indexes and their impact on write speed.

Writes safe migrations for PHP projects: adding columns with defaults, indexes without locking, separating destructive changes into phases. Manages seed data. Ensures rollback capability for each migration. Tests migrations on production data copies.

Works with sharding in PHP: implements multi-tenant database routing in Laravel via database resolver, configures Doctrine DBAL with multiple connections, applies shard selection middleware. Uses ProxySQL for transparent routing at DB level.

Designs normalized schemas for business domains. Optimizes queries via EXPLAIN and slow query log profiling. Uses MySQL specifics: partitioning, full-text search, JSON columns. Configures master-slave replication for read scaling.

Uses PostgreSQL features: JSONB for semi-structured data, CTEs for complex queries, window functions for analytics. Works with GIN/GiST indexes. Configures pg_stat_statements for monitoring. Applies LISTEN/NOTIFY for real-time events.

Optimizes SQL queries in PHP applications: eliminates N+1 via eager loading, rewrites subqueries into JOINs, uses batch operations. Analyzes slow query log. Applies query builder and raw SQL when ORM generates suboptimal queries.

Independently designs transaction management strategies in PHP applications using PDO, Doctrine, or Eloquent ORM. Implements proper transaction scoping for complex business operations. Handles deadlock detection and retry logic, manages savepoints, and optimizes transaction duration to reduce lock contention.

Generates OpenAPI specification from code automatically. Creates examples for each scenario: success, validation errors, 404, 500. Versions documentation. Adds authentication section with examples.

Automates API tests: integration tests for all endpoints, response structure assertions, auth flow testing. Creates fixtures and factories for test data. Runs in CI.

Implements versioning: version-based routing, transformers for different response formats, deprecation headers. Defines breaking vs non-breaking changes. Migrates clients between versions.

Designs efficient schemas: relay-style pagination, input types, unions/interfaces for polymorphism. Solves N+1 via DataLoader. Implements subscriptions for real-time. Configures query complexity limits.

Integrates PHP applications with gRPC services: generates PHP clients from .proto via protoc, configures channel credentials for TLS, handles errors through Status codes. Uses Spiral/RoadRunner for implementing gRPC servers in PHP without FPM limitations.

Implements rate limiting in PHP projects: configures custom RateLimiter in Laravel with per-user and per-IP strategies, uses Symfony RateLimiter component with token bucket and sliding window. Applies Redis for distributed rate limiting across FPM processes.

Designs APIs with pagination, filtering, sorting, and partial responses. Implements HATEOAS links. Versions APIs. Applies rate limiting and throttling. Documents via OpenAPI/Swagger.

Configures load balancing (L4 vs L7), reverse proxy, SSL termination. Understands CDN architecture. Diagnoses latency issues. Works with WebSockets and SSE for real-time.

Implements CQRS in PHP projects: uses Symfony Messenger or Ecotone for command/query bus, creates separate Doctrine read models (QueryBuilder + DTO) from write models (Entity + Repository). Configures event handlers for read model synchronization.