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.

Configures VPC, Security Groups, ALB. Uses ECS/EKS for containers. Works with SQS/SNS for messaging. Configures CloudWatch for monitoring. Uses Terraform for IaC.

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

Configures connection pooling in Python: optimizes SQLAlchemy pool (QueuePool vs StaticPool, pool_pre_ping, pool_recycle), configures psycopg2/asyncpg pool for async applications. Uses PgBouncer for connection multiplexing in FPM-like architecture. Monitors pool utilization.

Implements CQRS in Python projects: separates command and query handlers via mediatr-like libraries, designs separate read models (denormalized view tables or materialized views). Ensures eventual consistency between write and read sides.

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.

Develops gRPC services in Python with grpcio/grpcio-tools: designs .proto files, implements server-side and client-side streaming, configures interceptors for logging and authentication. Integrates gRPC with asyncio for non-blocking request processing.

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

Configures Deployments, Services, Ingress. Sets up HPA for autoscaling. Configures readiness and liveness probes. Uses namespaces. Debugs pod issues.

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.

Creates custom metrics with prometheus-client. Writes PromQL queries (rate, histogram_quantile). Creates Grafana dashboards. Configures basic alerting rules.

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

Implements rate limiting in Python services: configures SlowAPI/FastAPI limiter with Redis backend, implements token bucket and sliding window algorithms, applies different limits for different endpoints and user tiers. Configures throttling in Django REST Framework with custom throttle classes.

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.

Defines SLIs for Python services — p99 latency from middleware instrumentation, error rate from exception handlers, and worker pool health indicators. Configures SLI monitoring with Prometheus client and custom metrics. Understands error budgets and participates in on-call rotation for Python service reliability.

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.

Writes Terraform modules for Python infrastructure: ECS/EKS for Django/FastAPI, RDS PostgreSQL, ElastiCache Redis, SQS/SNS. Manages environments via workspaces. Configures remote state in S3 with locking via DynamoDB.

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

Applies algorithms for real code optimization. Understands amortized complexity (dict, list.append). Uses heapq, bisect, deque for optimal solutions. Chooses between sorting and hash table for search tasks.

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.

Generates complete OpenAPI documentation from code. Configures Redoc or Swagger UI. Documents error codes and examples. Creates Postman collections. Writes guides for API consumers.

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.

Uses concurrent.futures for thread and process pools. Applies multiprocessing for CPU-bound tasks. Understands race conditions and uses Lock, RLock. Works with shared state through Queue and Pipe.

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

Designs simple systems: URL shortener, REST API. Understands CAP theorem. Knows patterns: caching, load balancing, database replication. Evaluates non-functional requirements.

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.

Works with message brokers in Python projects: uses Celery with RabbitMQ/Redis for background tasks, implements pub/sub via confluent-kafka or aiokafka, applies competing consumers and fan-out patterns. Configures dead letter queues for error handling.

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.

Implements versioning via URL, header, or content-type. Designs deprecation policy with Sunset headers. Supports multiple versions simultaneously. Writes migration guides for clients.

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.

Applies collections (OrderedDict, Counter, deque, namedtuple). Uses dataclasses for structured data. Understands dict internals (hash table). Selects optimal data structure for the task. Works with trees and graphs using dictionaries.

Automates API tests via testing tools. Creates test fixtures for APIs. Uses Postman/Newman for automated collections. Tests edge cases and error handling. Generates reports.

Uses TypedDict, Protocol, Literal, Union, Generic. Configures mypy with strict mode for modules. Creates custom type aliases. Understands variance (covariant/contravariant). Writes types for complex APIs (overload, ParamSpec).

Works with sharded databases in Python: uses Django database routers for multi-database routing, implements shard selection logic based on tenant_id or user_id. Understands sharding trade-offs: cross-shard queries, join limitations, data distribution skew.