Alerting & On-Call 1
▼
Understands what SLA means for Python backend services — knows that 99.9% availability translates to ~8.7 hours allowed downtime per year. Understands why monitoring request latency, error rates, and worker process health matters for meeting service commitments.
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.
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.
Algorithms & Data Structures 2
▼
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.
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.
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 algorithmic strategies for the entire platform. Chooses between exact and approximate algorithms (HyperLogLog, Bloom filter). Implements algorithmic complexity standards in code review. Trains the team on complexity analysis.
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.
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.
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.
Selects data structures at system architecture level. Makes decisions on in-memory vs persistent structures. Designs custom collections for domain-specific tasks. Trains the team on efficient data structure usage.
API Management 3
▼
Adds descriptions to endpoints (docstrings, summary). Understands OpenAPI specification. Uses Swagger UI for testing. Documents request/response models.
Generates complete OpenAPI documentation from code. Configures Redoc or Swagger UI. Documents error codes and examples. Creates Postman collections. Writes guides for API consumers.
Designs developer portal. Automates SDK generation from OpenAPI. Configures versioned documentation. Creates interactive examples. Implements docs-as-code approach.
Defines API documentation standards for the organization. Implements unified API catalog. Automates documentation completeness checks.
Tests APIs via Postman or Insomnia. Creates basic request collections. Uses environment variables. Checks status codes and response body.
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.
Designs API testing strategy. Implements contract testing (Pact). Creates performance tests for APIs. Automates security testing (OWASP ZAP). Configures chaos testing for APIs.
Defines API testing standards for the organization. Implements unified testing framework. Automates API quality gates.
Understands why API versioning is needed. Knows URL-based versioning (/api/v1/). Maintains backward compatibility when adding fields. Follows team guidelines.
Implements versioning via URL, header, or content-type. Designs deprecation policy with Sunset headers. Supports multiple versions simultaneously. Writes migration guides for clients.
Designs versioning strategy for the service. Automates backward-compatibility checks. Creates contract tests between versions. Designs version routing in API Gateway.
Defines versioning strategy for the organization. Standardizes versioning approach. Designs automatic client migration.
Application Security 2
▼
Knows OWASP Top 10. Understands SQL injection and XSS. Uses parameterized queries. Validates input data via Pydantic.
Applies protection against CSRF, SSRF, XXE. Configures security headers. Checks dependencies for vulnerabilities (pip-audit, safety). Handles sensitive data (masking, encryption).
Conducts security code reviews. Configures SAST/DAST scanning. Designs security-first architecture. Implements defense in depth.
Defines security practices for the organization. Conducts threat modeling. Implements security training. Coordinates with security team.
Validates input data. Doesn't store passwords in plain text (bcrypt). Uses HTTPS. Doesn't log sensitive data. Follows security checklist.
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.
Designs secure-by-default architecture. Implements defense in depth. Conducts security code audits. Configures automated security testing.
Defines secure coding standards. Implements security review process. Trains the team. Coordinates with AppSec.
Authentication & Authorization 1
▼
Understands JWT: header, payload, signature. Uses JWT for authentication. Knows OAuth2 flows at a basic level. Stores tokens securely.
Implements OAuth2 flows (Authorization Code, Client Credentials). Configures OIDC with Keycloak. Implements refresh token rotation. Configures scopes and permissions.
Designs auth architecture for microservices. Implements service-to-service auth (mTLS, JWT). Configures RBAC/ABAC. Implements token introspection and revocation.
Defines auth strategy for the organization. Designs IAM architecture. Implements SSO. Standardizes authentication approaches.
Background Jobs & Task Queues 1
▼
Understands background task concepts. Creates simple Celery tasks. Uses delay() and apply_async(). Understands the difference between synchronous and asynchronous processing.
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.
Designs background processing architecture. Optimizes concurrency and prefetch. Configures priority queues. Implements idempotent tasks. Migrates between queues without task loss.
Designs background processing strategy for the platform. Chooses between Celery, Dramatiq, arq for different cases. Designs distributed task processing. Implements monitoring and observability for tasks.
Caching 2
▼
Understands why caching is needed. Knows cache-aside pattern. Uses TTL for automatic invalidation. Understands stale data problem.
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).
Designs multi-level caching strategy (L1/L2/L3). Optimizes cache warming and pre-fetching. Implements distributed cache invalidation. Chooses between consistency and performance.
Designs caching strategy for the entire platform. Solves caching problems in microservice architecture. Designs cache coherence for distributed systems. Trains the team.
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.
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 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 Redis architecture for the platform. Optimizes memory and performance at cluster level. Configures monitoring and alerting. Designs eviction and persistence strategy.
CI/CD 1
▼
Understands CI/CD pipeline. Creates simple GitHub Actions workflows. Runs tests and linters in CI. Uses actions from marketplace.
Designs multi-stage pipelines. Configures dependency caching. Uses matrix builds. Creates reusable workflows. Configures secrets management.
Designs CI/CD strategy for microservices. Creates custom actions. Configures deploy pipelines with approvals. Implements quality gates and security scanning.
Defines CI/CD standards for the organization. Optimizes runner infrastructure. Implements deployment strategies. Standardizes pipelines.
Clean Code & Refactoring 1
▼
Follows PEP 8 standards. Uses linters (flake8/ruff) and formatters (black). Writes docstrings for functions. Understands clean code principles: meaningful names, small functions, DRY.
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.
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.
Establishes code quality standards for the organization. Implements coding guidelines and style guides. Trains the team on clean code practices. Designs processes for maintaining quality at scale.
Cloud Providers 1
▼
Knows core services: EC2, S3, RDS, Lambda. Uses AWS Console. Understands IAM roles and policies. Deploys via CLI.
Configures VPC, Security Groups, ALB. Uses ECS/EKS for containers. Works with SQS/SNS for messaging. Configures CloudWatch for monitoring. Uses Terraform for IaC.
Designs AWS architecture for production. Optimizes cost. Configures multi-AZ for HA. Uses Lambda for serverless. Configures CloudFront CDN.
Designs AWS strategy for the organization. Configures multi-account structure. Implements FinOps. Defines cloud security policies.
Code Review 1
▼
Participates in reviews as a reviewee. Understands reviewer comments. Fixes code based on feedback. Knows basic self-review checklist.
Conducts code reviews. Gives constructive feedback. Checks logic, tests, security. Knows the difference between blocking and non-blocking comments. Uses suggestions.
Conducts architectural reviews. Focuses on design decisions. Mentors through review. Automates checks (linters, CODEOWNERS). Evaluates trade-offs.
Defines code review standards. Introduces review culture. Configures automation. Establishes review guidelines.
Concurrency & Parallelism 2
▼
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.
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.
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 async processing strategy for the platform. Chooses between asyncio, multiprocessing, threading for different tasks. Implements async development standards. Designs graceful degradation for async systems.
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.
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.
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 concurrency strategy for services. Makes decisions on concurrency model (multi-process, async, hybrid). Optimizes resource-intensive computations. Trains the team on safe thread management.
Containerization 1
▼
Writes Dockerfiles for Python applications. Uses docker-compose for local development. Understands image layers and caching. Uses .dockerignore.
Optimizes Dockerfile (multi-stage, layer caching). Configures health checks. Uses Docker networks and volumes. Debugs containers. Scans for vulnerabilities.
Defines containerization strategy. Standardizes base images. Implements security practices. Optimizes registry infrastructure.
Data Modeling 2
▼
Creates basic schemas with tables and relationships. Understands 1:1, 1:N, N:M relationships. Applies normalization up to 3NF. Uses proper data types.
Designs schemas for microservices. Applies denormalization for performance. Models polymorphic relationships (STI, MTI). Designs audit trails and soft deletes. Uses JSONB for flexible data.
Designs domain models for complex business domains. Applies DDD in modeling. Designs event-sourced storage. Optimizes schema for read-heavy and write-heavy workloads.
Defines data modeling standards for the organization. Designs cross-service data architecture. Implements data governance. Trains the team.
Creates migrations using migration tools. Understands forward and rollback. Adds columns and tables. Tests migrations locally.
Writes zero-downtime migrations. Uses expand-contract pattern. Migrates data with backfill. Configures automatic migration execution in CI/CD. Handles migration conflicts.
Designs migration strategy for the service. Performs complex schema changes (splitting tables, changing types). Automates rollback. Migrates between database engines.
Defines migration strategy for the organization. Standardizes zero-downtime approaches. Implements migration review process. Plans large-scale migrations.
Database Optimization 3
▼
Understands why connection pooling is needed: connection reuse to DB, latency reduction, preventing connection exhaustion. Knows that SQLAlchemy and Django ORM use pools by default, can configure basic parameters (pool size, max overflow).
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.
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.
Defines connection management strategy for the platform: standardizes pool configuration for different workload types, designs centralized proxy layer (PgBouncer/ProxySQL) for connection multiplexing, implements monitoring and alerting for pool exhaustion. Trains teams on connection issue troubleshooting.
Understands that indexes speed up SELECT. Knows CREATE INDEX syntax. Adds indexes as recommended. Understands that indexes slow down INSERT.
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.
Designs indexing strategies. Uses partial, covering, GIN/GiST indexes. Monitors pg_stat_user_indexes. Optimizes considering cardinality and selectivity.
Designs indexing strategies for distributed databases. Uses expression indexes, BRIN for time-series. Configures GIN for JSONB and full-text search. Performs REINDEX without downtime.
Writes basic SQL (SELECT, JOIN, WHERE, GROUP BY). Understands that queries can be slow. Knows that EXISTS is faster than IN for subqueries.
Analyzes via EXPLAIN. Eliminates N+1 (eager loading, select_related). Optimizes JOINs. Uses window functions (ROW_NUMBER, LAG/LEAD). Understands subquery types.
Deeply analyzes query plans. Uses materialized views. Optimizes bulk operations (COPY). Tunes work_mem, shared_buffers.
Designs optimization strategy for the system. Configures pg_stat_statements monitoring. Optimizes cross-shard queries. Trains the team.
Git & Workflows 1
▼
Uses branching (feature branches, main). Makes commits with meaningful messages. Creates pull requests. Resolves simple merge conflicts. Uses .gitignore.
Defines branching strategy (GitFlow, trunk-based). Configures branch protection rules. Uses git worktrees. Optimizes git for large repositories. Recovers data through reflog.
Defines git workflow for the organization. Configures monorepo/multirepo strategy. Implements conventional commits. Automates release management.
Integration Testing 1
▼
Understands the difference between unit and integration tests. Tests API endpoints. Uses test database for integration tests.
Uses TestContainers for PostgreSQL, Redis, Kafka. Tests inter-service interactions. Configures fixtures for complex scenarios. Creates seed data.
Designs integration testing strategy. Creates test environments. Automates contract testing. Tests failure scenarios.
Defines integration testing standards. Implements test infrastructure. Optimizes test pipeline. Standardizes approaches.
Kubernetes & Orchestration 1
▼
Understands core resources: Pod, Deployment, Service. Deploys applications via kubectl. Reads pod logs. Understands ConfigMaps and Secrets.
Configures Deployments, Services, Ingress. Sets up HPA for autoscaling. Configures readiness and liveness probes. Uses namespaces. Debugs pod issues.
Designs K8s manifests for microservices. Configures resource limits and QoS. Uses PodDisruptionBudgets. Configures RBAC. Optimizes scheduling.
Designs K8s architecture for the platform. Defines namespace strategy. Implements GitOps. Standardizes manifests via Helm/Kustomize.
Logging 1
▼
Uses logging module instead of print. Understands log levels (DEBUG, INFO, WARNING, ERROR). Adds context to logs. Uses structlog or python-json-logger.
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.
Designs logging strategy for microservices. Configures centralized logging (EFK, Loki). Creates dashboards for log analysis. Optimizes log volume. Implements log-based alerting.
Defines logging standards for the organization. Optimizes log storage costs. Implements log-based monitoring. Standardizes logging libraries.
Message Queues & Event Streaming 2
▼
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.
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.
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 Kafka infrastructure for the platform. Defines event standards and naming conventions. Designs multi-cluster setup. Implements topic and schema governance.
Understands basic message broker concepts: publish/subscribe, point-to-point, message queues. Can send and receive messages via RabbitMQ (pika) or Redis pub/sub. Knows why async communication between services is needed.
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.
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.
Defines messaging strategy for the organization: standardizes patterns (saga, choreography vs orchestration, event sourcing), implements monitoring/alerting for message lag and consumer health. Designs Kafka topic partitioning for optimal parallelization and data locality.
Metrics & Monitoring 1
▼
Understands metrics concepts (counter, gauge, histogram). Views Grafana dashboards. Knows PromQL basics. Adds basic metrics to the application.
Creates custom metrics with prometheus-client. Writes PromQL queries (rate, histogram_quantile). Creates Grafana dashboards. Configures basic alerting rules.
Designs monitoring strategy for services. Configures SLI/SLO monitoring. Creates RED/USE dashboards. Optimizes cardinality. Configures recording rules.
Defines monitoring standards for the organization. Implements unified dashboards. Configures multi-cluster monitoring. Optimizes Prometheus infrastructure.
Networking 1
▼
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.
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.
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.
OOP & Design Patterns 2
▼
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.
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.
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).
Selects architectural patterns at system level. Builds catalog of approved patterns for the team. Designs framework-level solutions using patterns. Evaluates trade-offs of different approaches.
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__).
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 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.
Establishes design standards for the team. Conducts architectural reviews focused on SOLID. Designs extensible frameworks and plugin systems. Trains the team on proper OOP application in Python.
Relational Databases 1
▼
Writes SQL queries: SELECT, JOIN, WHERE, GROUP BY. Creates tables with proper data types. Uses ORM for CRUD. Understands foreign keys and constraints.
Designs schemas for high-load systems. Configures partitioning (range, hash). Uses LISTEN/NOTIFY for real-time. Optimizes pg config for workload. Configures logical replication.
Designs database architecture for the platform. Configures HA with Patroni. Designs sharding strategy. Monitors and tunes at cluster level.
REST API 1
▼
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.
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.
Designs API strategy: standards, governance, developer portal. Implements API-first design process. Designs BFF pattern. Establishes API review board.
System Design 1
▼
Understands client-server architecture. Knows HTTP request lifecycle. Understands basic concepts: latency, throughput, availability. Knows what a load balancer and CDN are.
Designs simple systems: URL shortener, REST API. Understands CAP theorem. Knows patterns: caching, load balancing, database replication. Evaluates non-functional requirements.
Designs distributed systems. Applies patterns: Circuit Breaker, Bulkhead, Retry. Designs for fault tolerance and graceful degradation. Evaluates capacity planning.
Designs architecture at domain level. Conducts architecture decision reviews. Defines NFRs for services. Trains the team on system design.
Type Systems 1
▼
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.
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).
Designs type-safe APIs for libraries. Uses advanced typing (TypeVar, ParamSpec, Concatenate). Configures mypy plugins. Creates typed DSLs. Understands Python type system limitations.
Implements typing strategy for the organization. Establishes type hint standards and guidelines. Configures type checking infrastructure in CI. Trains the team on advanced typing.
Unit Testing 1
▼
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.
Designs test architecture for the project. Creates custom fixtures and plugins. Optimizes test speed (parallel, selective). Tests complex scenarios (state machines, race conditions).
Defines testing strategy for the organization. Implements testing standards. Mentors the team on testing. Evaluates coverage vs value.
Web Frameworks 1
▼
Creates CRUD endpoints with FastAPI or Django REST Framework. Uses Pydantic for validation. Understands dependency injection. Works with Django ORM/SQLAlchemy for basic queries.
Designs architecture for large FastAPI/Django applications. Configures async middleware pipelines. Creates custom FastAPI dependencies. Optimizes startup and shutdown. Integrates with Celery, Kafka, Redis.
Creates templates and cookiecutters for new services. Chooses between FastAPI, Django, Flask for different use cases. Designs shared libraries for the team. Standardizes development approaches.