Algorithms & Data Structures 2
▼
Knows basic sorting and search algorithms. Evaluates O(n) for simple loops. Chooses between array_search, in_array, and isset by situation. Understands why nested loops are problematic with large datasets.
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.
Establishes performance budgets for API endpoints. Conducts code reviews focused on complexity. Implements automated monitoring for performance degradation. Makes decisions about architectural trade-offs.
Defines performance strategy at system level. Designs solutions for processing millions of records in real time. Balances computational complexity, memory consumption, and code readability at platform level.
Works with PHP arrays, associative arrays, and objects. Understands the difference between indexed and associative arrays. Uses array_map, array_filter, usort for data processing.
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.
Defines data handling standards for the team. Reviews structure choices in the context of scalability and maintainability. Implements DTOs and Value Objects as the foundation of the domain layer.
Designs data models at platform level. Makes strategic decisions about storage: in-memory vs persistent, centralized vs distributed. Defines serialization and data transfer standards between services.
API Management 3
▼
Describes endpoints: request/response examples, required parameters, error codes. Uses OpenAPI annotations in code. Keeps Swagger UI up to date. Documents edge cases.
Generates OpenAPI specification from code automatically. Creates examples for each scenario: success, validation errors, 404, 500. Versions documentation. Adds authentication section with examples.
Defines API documentation standards: mandatory sections, review process, automated freshness checks. Builds developer experience: onboarding, sandbox, changelog.
Shapes platform documentation strategy: unified developer portal, auto-generation, versioning. Defines standards for public API: SLA documentation, migration guides, deprecation policy.
Tests APIs manually via Postman/Insomnia. Creates request collections. Checks status codes, response body, headers. Writes simple automated tests for main endpoints.
Automates API tests: integration tests for all endpoints, response structure assertions, auth flow testing. Creates fixtures and factories for test data. Runs in CI.
Defines API testing standards: coverage requirements, mandatory test cases, performance budgets for endpoints. Implements automated regression testing.
Shapes API quality assurance strategy at platform level: testing infrastructure, cross-service integration testing, canary deployment validation.
Understands why API versioning is needed. Knows approaches: URL-path, header, query parameter. Follows the project's versioning policy. Maintains backward compatibility in own changes.
Implements versioning: version-based routing, transformers for different response formats, deprecation headers. Defines breaking vs non-breaking changes. Migrates clients between versions.
Defines versioning policy for the product: number of supported versions, deprecation timeline, change communication. Standardizes the process for releasing new API versions.
Shapes API lifecycle management at organizational level: governance, breaking change policy, automated compatibility checks, partner communication strategy.
Architecture Patterns 1
▼
Follows the project's layered architecture: controllers don't contain business logic, services work through repository interfaces. Understands dependency direction. Doesn't mix infrastructure code with domain code.
Applies Clean Architecture in PHP: extracts Use Cases, separates Domain and Infrastructure layers. Inverts dependencies through interfaces. Organizes code by features, not by file types. Writes domain code without framework dependency.
Defines team architectural standards: module structure, dependency rules between layers, PHPStan rules for architecture enforcement. Conducts architectural reviews. Balances architecture purity with delivery speed.
Shapes organizational architecture culture. Defines reference architecture for PHP services: Domain Layer, Application Layer, Infrastructure Layer. Designs shared kernel between services. Evaluates when clean architecture is justified and when it's excessive.
Authentication & Authorization 1
▼
Understands JWT structure: header, payload, signature. Implements login/logout with JWT tokens. Configures middleware for token validation. Knows the difference between authentication and authorization.
Implements OAuth 2.0 flows: authorization code, client credentials, refresh tokens. Configures scopes and permissions. Handles token expiration and renewal. Integrates with OAuth providers.
Defines authentication/authorization strategy for the product: identity provider, token format, session management policy. Standardizes auth approach across services.
Shapes organizational identity & access management strategy: centralized IAM, federation, zero-trust architecture. Defines compliance requirements for authentication.
Background Jobs & Task Queues 1
▼
Uses Task Queues at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.
Independently implements Task Queue tasks. Understands internals and optimizes performance. Writes tests.
Defines background processing standards: job class structure, error handling, retry policies, monitoring. Chooses between different queue backends based on workload.
Designs async processing platform: scheduling, workflow orchestration, distributed job processing. Ensures scalability and fault tolerance at organizational level.
Caching 2
▼
Understands why caching is needed and the main strategies. Caches results of heavy queries in the application. Uses HTTP caching (Cache-Control, ETag). Knows the cache invalidation problem.
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.
Shapes caching standards for all services: naming conventions, TTL policies, alerting on degradation. Makes decisions about caching technology selection for different layers.
Defines caching strategy at organizational level. Designs shared caching platform. Balances data freshness, response speed, and infrastructure cost.
Uses Redis for caching query results and sessions. Sets TTL for keys. Works with GET/SET/DEL commands. Understands when caching speeds things up and when it creates problems.
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.
Defines caching strategy for the product: cache levels (app, HTTP, CDN), invalidation policies, hit rate monitoring. Standardizes caching approaches across the team.
Designs platform caching architecture: multi-layer caching, geographic distribution, cache warming strategies. Balances consistency and performance at system level.
Clean Code & Refactoring 1
▼
Follows coding standards (PSR-12). Writes clear variable and function names. Removes code duplication. Uses linters (PHP_CodeSniffer, PHPStan) and fixes issues.
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.
Shapes code quality standards for the team. Configures quality gates in the pipeline. Balances development speed and quality. Implements continuous refactoring practices.
Defines technical debt strategy at organizational level. Makes decisions about legacy system migration. Establishes metrics and processes for maintaining codebase quality.
Data Modeling 2
▼
Designs simple schemas: tables, one-to-one, one-to-many, many-to-many relationships. Normalizes to 3NF. Chooses correct data types. Understands when soft delete is needed.
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.
Defines data modeling standards: naming conventions, mandatory fields (timestamps, soft deletes), schema versioning approach. Reviews models for new modules.
Designs data model at platform level: shared vs isolated databases, data mesh, cross-service data contracts. Defines organizational data model evolution strategy.
Creates migrations for DB schema changes: adding tables, columns, indexes. Understands forward and rollback. Tests migrations locally before applying. Follows naming conventions.
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.
Defines migration process for the team: migration reviews, automated rollback testing, staged deployment. Plans complex migrations with phased breakdown.
Designs schema evolution strategy at platform level: cross-service schema changes, database versioning strategy, automated migration validation pipeline.
Database Optimization 3
▼
Creates simple indexes to speed up WHERE and JOIN. Understands the difference between PRIMARY, UNIQUE, and regular indexes. Knows that indexes slow down INSERT/UPDATE. Uses EXPLAIN for verification.
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.
Defines indexing standards for the team: mandatory EXPLAIN in code review, automated monitoring of unused indexes, periodic reindex policy. Trains the team on query optimization.
Designs indexing strategy at platform level: balance between read and write performance, index maintenance automation, degradation monitoring across all services.
Uses EXPLAIN for execution plan analysis. Adds indexes for slow queries. Avoids SELECT * and N+1 problems. Understands the difference between lazy and eager loading in ORM.
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.
Implements performance-aware development culture: mandatory query review, automated slow query alerts, performance budgets for endpoints. Trains the team on reading execution plans.
Defines query optimization strategy at platform level: automated query analysis, query store monitoring, cross-service query performance baseline.
Uses transactions for atomic operations: BEGIN/COMMIT/ROLLBACK. Understands ACID properties. Wraps related changes in transactions. Knows about isolation levels at a basic level.
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.
Defines transactional standards: retry policies, timeouts, long-running transaction monitoring. Trains the team on proper isolation level usage and concurrent access.
Designs consistency strategy at platform level: strong vs eventual consistency, distributed transactions, two-phase commit vs saga. Defines trade-offs for different business scenarios.
GraphQL 1
▼
Creates simple GraphQL schemas: types, queries, mutations. Understands the difference from REST. Implements resolvers for basic operations. Uses GraphQL playground for testing.
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.
Defines GraphQL standards for the team: schema conventions, review process, monitoring. Makes decisions about GraphQL vs REST vs gRPC applicability for different scenarios.
Designs platform API architecture with GraphQL: federated gateway, schema registry, breaking change detection. Defines API evolution strategy for external and internal clients.
Message Queues & Event Streaming 2
▼
Understands message broker patterns in PHP: pub-sub with Symfony Messenger, queue workers with Laravel Queues. Follows team conventions for dispatching and consuming messages using Redis, RabbitMQ, or SQS drivers.
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.
Standardizes messaging in the PHP ecosystem: defines async communication patterns considering PHP process model limitations, implements Ecotone Framework for CQRS/event sourcing, designs PHP monolith integration with event-driven microservices. Trains teams on messaging best practices.
Shapes messaging strategy for the PHP platform: defines how PHP systems participate in enterprise event-driven architecture, designs async processing approaches considering FPM/Swoole/RoadRunner runtime. Influences architectural decisions for transitioning from synchronous to event-driven in PHP legacy.
Sends and receives messages via queues. Understands exchange, queue, routing key concepts. Configures simple direct-exchange routes. Processes messages with ack/nack.
Designs exchange topology: fanout for broadcast, topic for routing, headers for complex rules. Configures dead letter queues and retry mechanisms. Ensures idempotent message processing.
Defines inter-service communication strategy: sync vs async, RPC vs events. Standardizes message format and contracts. Implements monitoring and alerting for queues.
Designs event-driven architecture at platform level. Chooses between message brokers for different use cases. Defines delivery guarantees and messaging layer scaling strategy.
OOP & Design Patterns 1
▼
Creates classes with encapsulation, inheritance, and polymorphism. Understands interfaces and abstract classes. Follows the single responsibility principle in own code. Uses type hints and return types.
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.
Defines OOP standards for the team: coding guidelines, architectural decision records. Trains developers on correct principle application. Conducts design reviews of new modules.
Shapes object model at platform level. Determines where OOP is optimal and where functional or procedural approach is better. Designs shared kernel between services.
Relational Databases 2
▼
Writes SQL queries: SELECT with JOIN, WHERE, GROUP BY, ORDER BY. Creates tables with correct data types and constraints. Understands foreign keys and indexes. Works with MySQL Workbench or equivalent.
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.
Defines MySQL standards for the team: naming conventions, migration workflow, schema review. Makes decisions about sharding, read replicas for read-heavy workloads. Plans capacity.
Defines organizational database strategy: MySQL vs alternatives for different services. Designs data platform: replication, backup, disaster recovery, multi-region. Evaluates managed vs self-hosted.
Works with PostgreSQL: writes SQL queries, creates tables, understands data types (jsonb, arrays, uuid). Uses pgAdmin or CLI. Understands differences from MySQL in syntax and types.
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.
Defines PostgreSQL standards for the team: schema design guidelines, migration process, monitoring. Makes decisions about extensions (PostGIS, pg_trgm, TimescaleDB).
Designs PostgreSQL architecture at platform level: clustering, Patroni for HA, logical replication between services. Defines scaling strategy: read replicas, Citus for sharding.
REST API 1
▼
Creates CRUD endpoints with correct HTTP methods and status codes. Follows RESTful conventions: resource naming, nesting. Returns JSON with consistent structure. Handles errors with clear messages.
Designs APIs with pagination, filtering, sorting, and partial responses. Implements HATEOAS links. Versions APIs. Applies rate limiting and throttling. Documents via OpenAPI/Swagger.
Defines API design guidelines for the team: naming conventions, error format, pagination strategy. Conducts API design reviews. Implements contract-first development approach.
Shapes organizational API strategy: unified API gateway, authentication standards, rate limiting policy, versioning strategy. Designs platform public API.
Search Engines 1
▼
Uses Elasticsearch / OpenSearch at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.
Independently implements Elasticsearch / OpenSearch tasks. Understands internals and optimizes performance. Writes tests.
Defines full-text search strategy for the product: engine selection, indexing schema, synchronization pipeline with the main database. Standardizes search-as-a-service approach.
Designs search platform at organizational level. Defines scaling and fault tolerance strategy. Evaluates alternatives: Meilisearch, Typesense, OpenSearch for different use cases.
Type Systems 1
▼
Understands basics of PHP type system — strict_types declaration, type hints for function parameters and return types, and union types. Follows team conventions for PHPStan/Psalm static analysis levels and typed property declarations.
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.
Defines typing strategy for the codebase: strict_types, PHPStan level, generics via annotations. Implements Value Objects and enums for business logic. Controls type coverage via CI.
Shapes typing standards at platform level. Evaluates PHP type system evolution and plans migration. Determines balance between type strictness and development productivity.
Web Frameworks 1
▼
Uses PHP Frameworks at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.
Independently implements tasks with PHP Frameworks. Understands internals and optimizes performance. Writes tests.
Defines architectural decisions for PHP Frameworks at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines PHP Frameworks strategy at company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.