What a Senior } should know

Designs algorithmic solutions for complex business problems. Applies dynamic programming, greedy algorithms. Evaluates time-memory trade-offs. Optimizes algorithms considering cache locality and Python specifics (GIL, reference counting).

Designs async application architecture. Uses asyncio with Celery/Dramatiq for hybrid solutions. Debugs complex async issues (deadlocks, starvation). Optimizes event loop performance. Understands when async is not suitable (CPU-bound tasks).

Designs architecture for maintaining high code quality. Implements architectural decision records. Configures quality metrics in CI/CD. Conducts deep code reviews focused on architecture. Refactors legacy code without regression.

Designs custom data structures for specific tasks. Uses __slots__ for memory optimization. Applies immutable structures (frozenset, tuple) for thread-safety. Implements patterns using weakref to prevent memory leaks.

Combines patterns for complex architectural tasks. Applies CQRS, Event Sourcing, Specification pattern. Designs middleware pipelines. Adapts classic patterns to Python idioms (decorators, context managers, generators).

Designs concurrent systems considering GIL. Chooses between threading, multiprocessing, asyncio for tasks. Profiles multithreaded code. Uses shared memory for inter-process communication. Designs lock-free algorithms where possible.

Designs domain models using DDD approach. Applies metaclasses and descriptors for framework-level tasks. Creates flexible APIs using abstractions. Refactors legacy code with SOLID violations without breaking changes.

Designs type-safe APIs for libraries. Uses advanced typing (TypeVar, ParamSpec, Concatenate). Configures mypy plugins. Creates typed DSLs. Understands Python type system limitations.

Designs event-driven architecture on Kafka. Optimizes throughput and latency. Configures exactly-once semantics. Designs topic topology and partitioning strategy. Uses Kafka Streams for processing.

Designs multi-level caching strategy (L1/L2/L3). Optimizes cache warming and pre-fetching. Implements distributed cache invalidation. Chooses between consistency and performance.

Designs messaging architecture for Python services: chooses between RabbitMQ, Kafka, Redis Streams for different scenarios, implements transactional outbox for delivery guarantees, configures exactly-once semantics in Kafka. Designs schema registry for message format evolution.

Designs architecture for large FastAPI/Django applications. Configures async middleware pipelines. Creates custom FastAPI dependencies. Optimizes startup and shutdown. Integrates with Celery, Kafka, Redis.

Designs caching strategy for the service. Uses Redis Streams for event processing. Configures Redis Cluster for high availability. Optimizes memory usage (key design, compression). Implements distributed locks via Redlock.

Designs background processing architecture. Optimizes concurrency and prefetch. Configures priority queues. Implements idempotent tasks. Migrates between queues without task loss.

Designs connection management for Python systems: calculates optimal pool size (formula connections = (2 * CPU) + disk_spindles), configures multi-pool strategy for read replicas, implements connection routing (primary/replica) via SQLAlchemy binds. Diagnoses connection leaks and stale connections.

Designs domain models for complex business domains. Applies DDD in modeling. Designs event-sourced storage. Optimizes schema for read-heavy and write-heavy workloads.

Designs indexing strategies. Uses partial, covering, GIN/GiST indexes. Monitors pg_stat_user_indexes. Optimizes considering cardinality and selectivity.

Designs migration strategy for the service. Performs complex schema changes (splitting tables, changing types). Automates rollback. Migrates between database engines.

Designs sharding strategy for Python systems: selects shard key considering access patterns and data distribution, implements consistent hashing for balancing, designs cross-shard query aggregation. Configures Vitess or ProxySQL for transparent PostgreSQL/MySQL sharding.

Designs schemas for high-load systems. Configures partitioning (range, hash). Uses LISTEN/NOTIFY for real-time. Optimizes pg config for workload. Configures logical replication.

Deeply analyzes query plans. Uses materialized views. Optimizes bulk operations (COPY). Tunes work_mem, shared_buffers.

Designs API Gateway and webhook architecture. Creates API style guide. Implements idempotency keys. Evaluates REST vs GraphQL vs gRPC. Designs backward-compatible API with deprecation strategy.

Designs developer portal. Automates SDK generation from OpenAPI. Configures versioned documentation. Creates interactive examples. Implements docs-as-code approach.

Designs API testing strategy. Implements contract testing (Pact). Creates performance tests for APIs. Automates security testing (OWASP ZAP). Configures chaos testing for APIs.

Designs versioning strategy for the service. Automates backward-compatibility checks. Creates contract tests between versions. Designs version routing in API Gateway.

Designs gRPC API for microservice architecture: defines proto file versioning strategy, configures gRPC-gateway for REST compatibility, implements health-checking and graceful shutdown. Optimizes performance through connection pooling and keepalive parameters.

Designs distributed rate limiting for Python microservices: implements sliding window counter via Redis Lua scripts for atomicity, configures rate limiting at API Gateway level (Kong, AWS API Gateway). Designs adaptive throttling with dynamic limits based on backend health and load.

Designs AWS architecture for production. Optimizes cost. Configures multi-AZ for HA. Uses Lambda for serverless. Configures CloudFront CDN.

Designs Docker strategy for microservices. Optimizes build pipeline. Configures private registry. Implements rootless containers. Designs dev environments.

Designs K8s manifests for microservices. Configures resource limits and QoS. Uses PodDisruptionBudgets. Configures RBAC. Optimizes scheduling.

Designs network infrastructure for the Python platform: multi-AZ, cross-region replication, CDN for static content. Configures service mesh for microservices. Implements mTLS, network policies. Optimizes network calls through connection pooling and keep-alive.

Designs Terraform architecture for the Python platform: reusable modules, multi-account strategy, blue-green deployments. Automates provisioning through CI/CD. Implements policy-as-code via Sentinel/OPA.

Designs CI/CD strategy for microservices. Creates custom actions. Configures deploy pipelines with approvals. Implements quality gates and security scanning.

Designs integration testing strategy. Creates test environments. Automates contract testing. Tests failure scenarios.

Designs test architecture for the project. Creates custom fixtures and plugins. Optimizes test speed (parallel, selective). Tests complex scenarios (state machines, race conditions).

Designs auth architecture for microservices. Implements service-to-service auth (mTLS, JWT). Configures RBAC/ABAC. Implements token introspection and revocation.

Conducts security code reviews. Configures SAST/DAST scanning. Designs security-first architecture. Implements defense in depth.

Designs secure-by-default architecture. Implements defense in depth. Conducts security code audits. Configures automated security testing.

Designs CQRS architecture for Python services: defines pattern applicability boundaries, selects read model synchronization strategy (sync vs async projections), implements event-driven projections via Kafka/RabbitMQ. Integrates CQRS with event sourcing for full change auditability.

Designs distributed systems. Applies patterns: Circuit Breaker, Bulkhead, Retry. Designs for fault tolerance and graceful degradation. Evaluates capacity planning.

Applies DDD tactical patterns in Python: Aggregates with SQLAlchemy unit-of-work, Domain Events via event bus, Specification pattern with filter objects. Designs aggregate boundaries using Python protocols. Balances rich domain model with Pythonic simplicity.

Architects Python microservices decomposition: designs bounded context boundaries extracting Django/FastAPI services, implements CQRS with separate read/write models. Manages data consistency via Saga pattern with Celery or Temporal workflows. Evaluates service granularity: balances Python runtime overhead against decomposition benefits. Implements contract testing with Pact.

Designs monitoring strategy for services. Configures SLI/SLO monitoring. Creates RED/USE dashboards. Optimizes cardinality. Configures recording rules.

Defines and implements comprehensive SLOs for Python service portfolios with burn rate alerts correlated to worker health and event loop metrics. Creates SLO dashboards spanning Django/FastAPI services with distributed tracing through OpenTelemetry. Manages error budgets and conducts post-mortem analysis. Designs graceful degradation with circuit breaker patterns and async task prioritization.

Designs logging strategy for microservices. Configures centralized logging (EFK, Loki). Creates dashboards for log analysis. Optimizes log volume. Implements log-based alerting.

Conducts architectural reviews. Focuses on design decisions. Mentors through review. Automates checks (linters, CODEOWNERS). Evaluates trade-offs.

Defines branching strategy (GitFlow, trunk-based). Configures branch protection rules. Uses git worktrees. Optimizes git for large repositories. Recovers data through reflog.