AI Coding Assistants 1
▼
Uses Copilot for PHP code generation: data processing functions, validations, typical patterns. Understands when suggestions are correct and when corrections are needed. Writes meaningful comments for better suggestions.
Productively works with Copilot in PHP projects: generates tests from existing code, creates migrations from models, writes middleware. Uses Copilot Chat for explaining legacy code and finding bugs. Critically evaluates suggestions for security concerns.
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.
Introduces Copilot to the team: configures policies, defines usage boundaries. Evaluates AI tool ROI. Trains developers on effective practices. Monitors security aspects — secret leaks, license compliance.
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.
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.
Establishes performance budgets for API endpoints. Conducts code reviews focused on complexity. Implements automated monitoring for performance degradation. Makes decisions about architectural trade-offs.
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.
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.
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.
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.
Designs documentation as a product: developer portal, getting started guides, SDKs. Automates client generation from specification. Implements contract testing (specification = tests).
Defines API documentation standards: mandatory sections, review process, automated freshness checks. Builds developer experience: onboarding, sandbox, changelog.
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.
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.
Defines API testing standards: coverage requirements, mandatory test cases, performance budgets for endpoints. Implements automated regression testing.
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.
Designs versioning strategy: sunset policy, changelog automation, consumer-driven contract testing. Ensures smooth migration between versions without client downtime.
Defines versioning policy for the product: number of supported versions, deprecation timeline, change communication. Standardizes the process for releasing new API versions.
Application Security 1
▼
Does not trust user input: validates, sanitizes, type-checks. Uses ORM instead of raw SQL. Stores secrets in environment variables, not in code. Does not log sensitive data.
Applies defense in depth: validation at every layer, principle of least privilege, secure session management. Implements audit logging for critical operations. Handles errors without leaking internal details.
Designs secure-by-default architecture: encrypted at rest/in transit, secrets management, automated credential rotation. Implements zero-trust approach between services. Conducts threat modeling.
Implements secure development lifecycle: threat modeling at design phase, automated security testing, post-deployment scanning. Develops security champions in the team.
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.
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.
Defines team architectural standards: module structure, dependency rules between layers, PHPStan rules for architecture enforcement. Conducts architectural reviews. Balances architecture purity with delivery speed.
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.
Designs auth architecture: centralized identity service, token introspection, RBAC/ABAC. Implements SSO between services. Configures MFA. Ensures secure token storage and rotation.
Defines authentication/authorization strategy for the product: identity provider, token format, session management policy. Standardizes auth approach across services.
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.
Designs queue architecture: prioritization, rate limiting, circuit breaker for external services. Ensures exactly-once processing through idempotency keys. Monitors throughput, latency, failure rate.
Defines background processing standards: job class structure, error handling, retry policies, monitoring. Chooses between different queue backends based on workload.
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.
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.
Shapes caching standards for all services: naming conventions, TTL policies, alerting on degradation. Makes decisions about caching technology selection for different layers.
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.
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.
Defines caching strategy for the product: cache levels (app, HTTP, CDN), invalidation policies, hit rate monitoring. Standardizes caching approaches across the team.
CI/CD 1
▼
Understands CI/CD pipeline: build, test, deploy. Configures basic workflow: running tests and linter on push/PR. Works with artifacts. Reads failed build logs.
Designs pipelines: parallel jobs, matrix builds for different versions, dependency caching. Configures deployment stages: staging → production. Integrates security scanning.
Designs CI/CD architecture: reusable workflows, self-hosted runners for specific tasks, blue-green/canary deployments. Optimizes build time. Automates rollback.
Defines CI/CD standards for the team: mandatory checks, deployment policy, environment management. Implements GitOps practices. Monitors deployment frequency and lead time.
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.
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.
Shapes code quality standards for the team. Configures quality gates in the pipeline. Balances development speed and quality. Implements continuous refactoring practices.
Code Review 1
▼
Participates in PHP code review: checks readability, naming, PSR-12 compliance. Leaves constructive comments with suggestions. Learns from feedback on own PRs. Describes PRs with context: what, why, how to test.
Conducts quality PHP code reviews: checks architecture (layers, dependencies), SQL queries (N+1, indexes), security (SQL injection, XSS). Provides feedback on SOLID violations. Suggests alternative solutions with justification.
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.
Shapes code review culture in the team: defines what to check at each level, establishes review SLAs, implements automated checks. Reviews architectural decisions and ADRs. Resolves disagreements in the review process.
Concurrency & Parallelism 1
▼
Understands the concept of asynchrony. Works with task queues for background processing. Moves heavy operations (email, report generation) to background jobs. Knows the difference between sync and async processing.
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.
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.
Defines async processing strategy for the product: choosing between sync API, async jobs, event streaming. Implements error handling and queue monitoring standards.
Containerization 1
▼
Writes Dockerfile for PHP applications: base image, dependency installation, code copying. Uses docker-compose for local development (app + DB + Redis). Understands volumes and networks.
Optimizes Docker images: multi-stage builds, minimal size, layer caching. Configures health checks. Manages secrets through environment variables. Debugs issues in containers.
Designs container architecture: base images for the team, security hardening (non-root, read-only fs), resource limits. Optimizes build time. Configures container orchestration.
Defines containerization standards: base images, security policies, CI/CD pipeline for docker builds. Implements container scanning and vulnerability management.
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.
Designs schemas for complex domains: polymorphic relationships, EAV for flexible attributes, temporal data, audit trails. Applies denormalization for production. Models bounded contexts.
Defines data modeling standards: naming conventions, mandatory fields (timestamps, soft deletes), schema versioning approach. Reviews models for new modules.
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.
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.
Defines migration process for the team: migration reviews, automated rollback testing, staged deployment. Plans complex migrations with phased breakdown.
Database Optimization 5
▼
Understands connection management in PHP: knows that each FPM process creates a separate DB connection, understands why persistent connections (PDO::ATTR_PERSISTENT) are needed. Knows that PHP lacks built-in connection pooling.
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 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.
Standardizes connection management for the PHP platform: defines connection architecture (FPM + PgBouncer vs Swoole native pool), creates monitoring and alerting for connection utilization. Designs capacity planning for database connections considering PHP scaling patterns.
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.
Designs indexing strategy: composite indexes considering selectivity, covering indexes to avoid table lookups, partial indexes for hot data. Monitors index usage and bloat.
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.
Understands sharding in PHP context: knows why data needs to be split across multiple DB servers, can connect to different databases in Laravel/Symfony. Understands the main limitations of sharding for PHP applications.
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 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.
Standardizes sharding in the PHP ecosystem: creates Composer packages for standard sharding setup, designs migration tools for per-shard schema management, implements monitoring for shard health and balance. Defines resharding strategy for growing PHP projects.
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.
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.
Implements performance-aware development culture: mandatory query review, automated slow query alerts, performance budgets for endpoints. Trains the team on reading execution plans.
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.
Designs transactional strategy: optimistic vs pessimistic locking, advisory locks, serializable isolation for critical operations. Handles deadlocks. Implements saga pattern for distributed transactions.
Defines transactional standards: retry policies, timeouts, long-running transaction monitoring. Trains the team on proper isolation level usage and concurrent access.
Git & Workflows 1
▼
Confidently works with Git in PHP projects: commit, push, pull, branch, merge. Follows the team's git-flow or trunk-based model. Writes meaningful commit messages. Resolves simple merge conflicts in PHP files and composer.lock.
Uses Git at an advanced level: interactive rebase for clean history, cherry-pick for hotfixes, bisect for finding regressions. Configures .gitattributes for PHP projects. Manages composer.lock conflicts. Reviews PRs with architecture focus.
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.
Shapes team Git workflow: branching model, PR process, review requirements, merge policies. Defines rules for monorepo or multi-repo. Implements automation: auto-merge, required checks, CODEOWNERS.
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.
Designs GraphQL architecture: schema stitching/federation for microservices, persisted queries for production, custom directives. Optimizes performance: caching, batching, query depth limiting.
Defines GraphQL standards for the team: schema conventions, review process, monitoring. Makes decisions about GraphQL vs REST vs gRPC applicability for different scenarios.
Integration Testing 1
▼
Understands the difference between unit and integration tests. Tests API endpoints: HTTP requests, response verification. Uses a test database. Configures seed data for tests.
Tests component interactions: API + DB + cache + queue. Uses testcontainers for isolation. Automates test environment setup/teardown. Tests email, file storage, external APIs through mock servers.
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 integration testing standards: mandatory scenarios, performance testing, environment management. Implements automated integration testing in the deployment pipeline.
Logging 1
▼
Uses Monolog for logging in PHP applications. Logs errors, warnings, and info messages with context. Understands log levels (debug, info, warning, error, critical). Adds request_id for tracing.
Configures structured logging in PHP: JSON format via Monolog formatters, context processors (user_id, request_id, session). Organizes log channels: app, security, performance. Integrates with ELK/Loki for centralized collection.
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.
Defines logging standards for the team: mandatory fields, levels, retention policies. Implements log-based monitoring and alerting. Reviews logging during incidents. Ensures compliance requirements for log storage.
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.
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.
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.
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.
Designs fault-tolerant messaging architecture: clustering, quorum queues, federation. Implements saga pattern through queues. Optimizes throughput and latency. Monitors lag and backpressure.
Defines inter-service communication strategy: sync vs async, RPC vs events. Standardizes message format and contracts. Implements monitoring and alerting for queues.
Networking 1
▼
Understands TCP/IP, DNS, HTTP/HTTPS at a practical level. Debugs network issues via curl, ping, traceroute. Knows the difference between HTTP 1.1 and 2.0. Understands SSL/TLS certificates.
Configures load balancing (L4 vs L7), reverse proxy, SSL termination. Understands CDN architecture. Diagnoses latency issues. Works with WebSockets and SSE for real-time.
Designs network architecture: VPC layout, subnet strategy, security groups, WAF. Optimizes network latency. Configures DNS failover and geo-routing. Ensures DDoS protection.
OOP & Design Patterns 2
▼
Knows and applies basic patterns: Singleton, Factory, Strategy. Understands why dependency injection is needed. Uses Repository for database operations. Follows patterns adopted in the project.
Applies patterns deliberately: Observer for events, Decorator for extending functionality, Chain of Responsibility for middleware. Refactors code using appropriate patterns. Understands anti-patterns.
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.
Shapes team architectural standards based on patterns. Decides which patterns to apply at project level. Conducts architectural reviews focused on correct pattern application.
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.
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.
Defines OOP standards for the team: coding guidelines, architectural decision records. Trains developers on correct principle application. Conducts design reviews of new modules.
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.
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.
Defines MySQL standards for the team: naming conventions, migration workflow, schema review. Makes decisions about sharding, read replicas for read-heavy workloads. Plans capacity.
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.
Uses advanced features: CTEs, window functions, partial indexes, JSONB operators. Configures pg_stat_statements for monitoring. Optimizes via EXPLAIN ANALYZE. Configures logical replication.
Defines PostgreSQL standards for the team: schema design guidelines, migration process, monitoring. Makes decisions about extensions (PostGIS, pg_trgm, TimescaleDB).
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.
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.
Defines API design guidelines for the team: naming conventions, error format, pagination strategy. Conducts API design reviews. Implements contract-first development approach.
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.
Designs search architecture: custom analyzers for Russian/English, synonym filters, fuzzy matching. Optimizes indexes: sharding strategy, reindex without downtime. Implements aggregations for analytics.
Defines full-text search strategy for the product: engine selection, indexing schema, synchronization pipeline with the main database. Standardizes search-as-a-service approach.
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.
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.
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.
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.
Designs solutions with PHP Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines architectural decisions for PHP Frameworks at product level. Establishes standards. Conducts design reviews and defines technical roadmap.