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).
Defines security practices for the organization. Conducts threat modeling. Implements security training. Coordinates with security team.
Shapes security strategy. Defines security standards. Evaluates compliance requirements. Builds security culture.
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.
Defines secure coding standards. Implements security review process. Trains the team. Coordinates with AppSec.
Shapes secure SDLC. Defines security requirements. Implements DevSecOps practices.
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.
Defines auth strategy for the organization. Designs IAM architecture. Implements SSO. Standardizes authentication approaches.
Shapes company identity strategy. Evaluates IAM platforms. Designs zero-trust architecture.
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 strategy for the platform. Chooses between Celery, Dramatiq, arq for different cases. Designs distributed task processing. Implements monitoring and observability for tasks.
Defines company async processing strategy. Designs event-driven architecture. Evaluates managed services vs self-hosted. Establishes task processing standards.
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 caching strategy for the entire platform. Solves caching problems in microservice architecture. Designs cache coherence for distributed systems. Trains the team.
Defines caching architecture at company level. Evaluates consistency vs availability trade-offs. Designs geo-distributed caching. Establishes caching effectiveness metrics.
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 Redis architecture for the platform. Optimizes memory and performance at cluster level. Configures monitoring and alerting. Designs eviction and persistence strategy.
Defines company caching strategy. Evaluates Redis vs alternatives (Dragonfly, KeyDB). Designs multi-region caching. Establishes best practices.
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.
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.
Defines quality strategy at organizational level. Implements quality metrics in team OKRs. Shapes code quality culture. Evaluates ROI of quality investments.
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.
Defines code review standards. Introduces review culture. Configures automation. Establishes review guidelines.
Shapes review culture in the organization. Defines review processes. Implements review metrics.
Concurrency & Parallelism 1
▼
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 processing strategy for the platform. Chooses between asyncio, multiprocessing, threading for different tasks. Implements async development standards. Designs graceful degradation for async systems.
Defines concurrency strategy at company level. Evaluates new approaches (TaskGroups in Python 3.11+, uvloop). Designs distributed async systems. Establishes best practices for scaling async applications.
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.
Shapes container strategy at company level. Evaluates Docker vs alternatives (Podman). Designs image supply chain security.
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.
Defines data modeling standards for the organization. Designs cross-service data architecture. Implements data governance. Trains the team.
Shapes data architecture strategy. Designs enterprise data model. Defines data mesh principles.
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.
Defines migration strategy for the organization. Standardizes zero-downtime approaches. Implements migration review process. Plans large-scale migrations.
Shapes database evolution strategy. Designs cross-service migration orchestration. Defines tooling and automation.
Database Optimization 2
▼
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 for distributed databases. Uses expression indexes, BRIN for time-series. Configures GIN for JSONB and full-text search. Performs REINDEX without downtime.
Defines indexing strategy at company level. Establishes standards and automated review. Designs indexing for sharded systems.
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.
Designs optimization strategy for the system. Configures pg_stat_statements monitoring. Optimizes cross-shard queries. Trains the team.
Defines optimization strategy at company level. Establishes DBA practices. Designs architecture for query performance.
Git & Workflows 1
▼
Uses branching (feature branches, main). Makes commits with meaningful messages. Creates pull requests. Resolves simple merge conflicts. Uses .gitignore.
Uses rebase for clean history. Applies interactive rebase for squash. Uses cherry-pick and bisect. Configures git hooks (pre-commit). Works with git stash.
Defines git workflow for the organization. Configures monorepo/multirepo strategy. Implements conventional commits. Automates release management.
Shapes version control strategy. Evaluates monorepo tools. Designs git infrastructure at scale.
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.
Defines integration testing standards. Implements test infrastructure. Optimizes test pipeline. Standardizes approaches.
Shapes integration testing strategy at company level. Implements platform-level testing tools. Defines SLOs for test reliability.
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.
Defines logging standards for the organization. Optimizes log storage costs. Implements log-based monitoring. Standardizes logging libraries.
Shapes observability strategy. Defines logging architecture at scale. Evaluates log platforms.
Message Queues & Event Streaming 1
▼
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 Kafka infrastructure for the platform. Defines event standards and naming conventions. Designs multi-cluster setup. Implements topic and schema governance.
Defines event streaming strategy at company level. Evaluates Kafka vs Pulsar vs Redpanda. Designs event-driven architecture at organizational scale. Establishes event standards.
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.
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.
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 database architecture for the platform. Configures HA with Patroni. Designs sharding strategy. Monitors and tunes at cluster level.
Defines company database strategy. Evaluates PostgreSQL vs NewSQL. Designs multi-region database architecture. Establishes DBA practices.
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.
Defines company API strategy. Designs multi-API orchestration. Evaluates API management platforms. Establishes organizational API roadmap.
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.
Uses mocks (unittest.mock, pytest-mock). Configures coverage reports. Tests async code. Parameterizes tests via @pytest.mark.parametrize. Uses factory_boy for data generation.
Defines testing strategy for the organization. Implements testing standards. Mentors the team on testing. Evaluates coverage vs value.
Shapes testing culture across the organization. Defines testing quality metrics. Implements best practices at company level.
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 FastAPI/Django project structure. Uses middleware, background tasks, WebSockets. Configures authentication/authorization. Works with Alembic/Django migrations. Optimizes ORM queries (select_related, prefetch_related).
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.
Defines company framework strategy. Evaluates new frameworks (Litestar, Starlette). Designs platform-level solutions. Contributes to open-source frameworks.