What a Junior } should know

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.

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.

Follows coding standards (PSR-12). Writes clear variable and function names. Removes code duplication. Uses linters (PHP_CodeSniffer, PHPStan) and fixes issues.

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.

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.

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.

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.

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.

Uses Elasticsearch / OpenSearch at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.

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.

Uses PHP Frameworks at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.

Sends and receives messages via queues. Understands exchange, queue, routing key concepts. Configures simple direct-exchange routes. Processes messages with ack/nack.

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.

Uses Task Queues at a basic level. Performs simple tasks using ready-made templates. Understands basic concepts and follows team practices.

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.

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.

Creates migrations for DB schema changes: adding tables, columns, indexes. Understands forward and rollback. Tests migrations locally before applying. Follows naming conventions.

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.

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

Uses transactions for atomic operations: BEGIN/COMMIT/ROLLBACK. Understands ACID properties. Wraps related changes in transactions. Knows about isolation levels at a basic level.

Describes endpoints: request/response examples, required parameters, error codes. Uses OpenAPI annotations in code. Keeps Swagger UI up to date. Documents edge cases.

Tests APIs manually via Postman/Insomnia. Creates request collections. Checks status codes, response body, headers. Writes simple automated tests for main endpoints.

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.

Creates simple GraphQL schemas: types, queries, mutations. Understands the difference from REST. Implements resolvers for basic operations. Uses GraphQL playground for testing.

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.

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.