Configures consumer groups and partition assignment. Handles errors with retry and dead letter topics. Uses acks=all for reliability. Monitors consumer lag. Designs event schemas with Avro/JSON Schema.

Conducts code reviews. Gives constructive feedback. Checks logic, tests, security. Knows the difference between blocking and non-blocking comments. Uses suggestions.

Optimizes Dockerfile (multi-stage, layer caching). Configures health checks. Uses Docker networks and volumes. Debugs containers. Scans for vulnerabilities.

Uses rebase for clean history. Applies interactive rebase for squash. Uses cherry-pick and bisect. Configures git hooks (pre-commit). Works with git stash.

Designs multi-stage pipelines. Configures dependency caching. Uses matrix builds. Creates reusable workflows. Configures secrets management.

Implements OAuth2 flows (Authorization Code, Client Credentials). Configures OIDC with Keycloak. Implements refresh token rotation. Configures scopes and permissions.

Applies protection against CSRF, SSRF, XXE. Configures security headers. Checks dependencies for vulnerabilities (pip-audit, safety). Handles sensitive data (masking, encryption).

Uses CTEs, window functions, JSONB operations. Configures connection pooling (PgBouncer). Optimizes via EXPLAIN ANALYZE. Works with transactions and isolation levels. Configures pg_stat_statements.

Designs FastAPI/Django project structure. Uses middleware, background tasks, WebSockets. Configures authentication/authorization. Works with Alembic/Django migrations. Optimizes ORM queries (select_related, prefetch_related).

Uses various Redis structures (hashes, sets, sorted sets, lists). Applies pipeline for batch operations. Configures cache-aside and write-through patterns. Uses Redis pub/sub for notifications. Handles cache miss correctly.

Designs RESTful API with versioning and cursor-based pagination. Documents via OpenAPI/Swagger. Implements error responses with error codes. Uses PATCH for partial updates. Designs bulk endpoints.

Configures Celery with different brokers (Redis, RabbitMQ). Uses chains, groups, chords for workflows. Configures retry with exponential backoff. Monitors tasks via Flower. Handles errors and dead letter queues.

Uses mocks (unittest.mock, pytest-mock). Configures coverage reports. Tests async code. Parameterizes tests via @pytest.mark.parametrize. Uses factory_boy for data generation.

Works with asyncio: Tasks, gather, wait, semaphore. Uses aiohttp, httpx for async HTTP. Understands event loop and its limitations. Applies asyncio.Queue for producer-consumer pattern. Handles cancellation and timeouts.

Creates B-tree, UNIQUE, COMPOSITE indexes. Uses EXPLAIN for query plans. Knows when an index helps and when it hurts. Creates indexes for foreign keys.

Uses TestContainers for PostgreSQL, Redis, Kafka. Tests inter-service interactions. Configures fixtures for complex scenarios. Creates seed data.

Configures pre-commit hooks with ruff, mypy, black. Refactors code smells. Writes type hints for all code. Applies quality metrics (cyclomatic complexity, coverage). Participates constructively in code review.

Writes zero-downtime migrations. Uses expand-contract pattern. Migrates data with backfill. Configures automatic migration execution in CI/CD. Handles migration conflicts.

Analyzes via EXPLAIN. Eliminates N+1 (eager loading, select_related). Optimizes JOINs. Uses window functions (ROW_NUMBER, LAG/LEAD). Understands subquery types.

Designs network architecture for Python services: VPC, subnets, security groups, NAT gateways. Configures reverse proxy (nginx) for Gunicorn/Uvicorn. Understands service discovery, DNS-based routing. Optimizes inter-service latency.

Applies Strategy, Template Method, Decorator, Command in Python code. Uses Repository pattern for database access. Applies Unit of Work with SQLAlchemy sessions. Knows antipatterns and can refactor them.

Applies input validation at all levels. Uses secrets management (environment variables, Vault). Implements rate limiting. Handles errors without information leakage. Encrypts sensitive data at rest.

Applies SOLID in daily development. Uses abstract classes (ABC) and Protocol for interface definition. Understands composition over inheritance. Applies dependency injection via constructor. Uses mixins correctly.

Designs schemas for microservices. Applies denormalization for performance. Models polymorphic relationships (STI, MTI). Designs audit trails and soft deletes. Uses JSONB for flexible data.

Applies various strategies: cache-aside, write-through, write-behind. Implements event-based cache invalidation. Uses CDN caching for static content. Monitors cache hit rate. Handles cache stampede (thundering herd).

Configures structured logging with correlation IDs. Logs in JSON for EFK/Loki. Adds request tracing via middleware. Filters sensitive data from logs. Configures log aggregation.