What a Junior } should know

Knows basic sorting and search algorithms. Understands Big-O notation for simple cases (O(1), O(n), O(n²)). Can estimate complexity of a simple loop. Uses built-in sorted() and collections for problem solving.

Understands async programming concept. Writes simple async/await functions. Knows the difference between sync and async code. Uses httpx or aiohttp for async HTTP requests.

Follows PEP 8 standards. Uses linters (flake8/ruff) and formatters (black). Writes docstrings for functions. Understands clean code principles: meaningful names, small functions, DRY.

Knows core Python data structures: list, dict, set, tuple. Understands the difference between mutable and immutable types. Uses list comprehension and dict comprehension. Knows when to use set instead of list for lookups.

Knows basic patterns: Singleton, Factory, Observer. Understands the purpose of Repository and Service Layer. Can recognize patterns in existing code. Applies simple patterns on senior's recommendation.

Understands thread and process concepts. Knows about GIL in CPython and its impact. Uses threading for simple I/O-bound tasks. Understands the difference between threading and multiprocessing.

Understands encapsulation, inheritance, polymorphism in Python. Creates classes with __init__, properties, and methods. Knows SOLID principles at a basic level. Uses property decorators and dunder methods (__str__, __repr__).

Uses basic type hints: str, int, list[str], Optional. Understands why typing is needed in Python. Knows main types from typing module. Runs mypy for type checking.

Creates CRUD endpoints with FastAPI or Django REST Framework. Uses Pydantic for validation. Understands dependency injection. Works with Django ORM/SQLAlchemy for basic queries.

Understands the message broker concept. Writes simple producers and consumers with confluent-kafka-python. Knows what topic, partition, offset are. Understands at-least-once semantics.

Understands why caching is needed. Knows cache-aside pattern. Uses TTL for automatic invalidation. Understands stale data problem.

Uses Redis as simple key-value cache via redis-py. Understands TTL and expiration. Caches API call results. Knows basic commands: GET, SET, DEL, EXISTS.

Understands background task concepts. Creates simple Celery tasks. Uses delay() and apply_async(). Understands the difference between synchronous and asynchronous processing.

Writes SQL queries: SELECT, JOIN, WHERE, GROUP BY. Creates tables with proper data types. Uses ORM for CRUD. Understands foreign keys and constraints.

Creates basic schemas with tables and relationships. Understands 1:1, 1:N, N:M relationships. Applies normalization up to 3NF. Uses proper data types.

Understands that indexes speed up SELECT. Knows CREATE INDEX syntax. Adds indexes as recommended. Understands that indexes slow down INSERT.

Creates migrations using migration tools. Understands forward and rollback. Adds columns and tables. Tests migrations locally.

Writes basic SQL (SELECT, JOIN, WHERE, GROUP BY). Understands that queries can be slow. Knows that EXISTS is faster than IN for subqueries.

Creates CRUD endpoints with proper HTTP methods. Uses status codes (200, 201, 400, 404, 500). Understands JSON request/response. Adds query parameters for filtering and pagination.

Adds descriptions to endpoints (docstrings, summary). Understands OpenAPI specification. Uses Swagger UI for testing. Documents request/response models.

Tests APIs via Postman or Insomnia. Creates basic request collections. Uses environment variables. Checks status codes and response body.

Understands why API versioning is needed. Knows URL-based versioning (/api/v1/). Maintains backward compatibility when adding fields. Follows team guidelines.

Writes Dockerfiles for Python applications. Uses docker-compose for local development. Understands image layers and caching. Uses .dockerignore.

Knows core services: EC2, S3, RDS, Lambda. Uses AWS Console. Understands IAM roles and policies. Deploys via CLI.

Understands core resources: Pod, Deployment, Service. Deploys applications via kubectl. Reads pod logs. Understands ConfigMaps and Secrets.

Understands TCP/IP, DNS, HTTP/HTTPS in the context of Python applications. Knows how ports, firewall rules, load balancers work. Diagnoses connection issues via curl, telnet, netstat. Configures CORS in Django/FastAPI.

Understands CI/CD pipeline. Creates simple GitHub Actions workflows. Runs tests and linters in CI. Uses actions from marketplace.

Writes unit tests with pytest. Uses assert statements and fixtures. Tests happy path and edge cases. Understands test isolation. Runs tests locally and in CI.

Understands the difference between unit and integration tests. Tests API endpoints. Uses test database for integration tests.

Understands JWT: header, payload, signature. Uses JWT for authentication. Knows OAuth2 flows at a basic level. Stores tokens securely.

Knows OWASP Top 10. Understands SQL injection and XSS. Uses parameterized queries. Validates input data via Pydantic.

Validates input data. Doesn't store passwords in plain text (bcrypt). Uses HTTPS. Doesn't log sensitive data. Follows security checklist.

Understands client-server architecture. Knows HTTP request lifecycle. Understands basic concepts: latency, throughput, availability. Knows what a load balancer and CDN are.

Understands metrics concepts (counter, gauge, histogram). Views Grafana dashboards. Knows PromQL basics. Adds basic metrics to the application.

Uses logging module instead of print. Understands log levels (DEBUG, INFO, WARNING, ERROR). Adds context to logs. Uses structlog or python-json-logger.

Uses branching (feature branches, main). Makes commits with meaningful messages. Creates pull requests. Resolves simple merge conflicts. Uses .gitignore.

Participates in reviews as a reviewee. Understands reviewer comments. Fixes code based on feedback. Knows basic self-review checklist.