Lead SRE or Software Engineer

Refactor a Python automation script into packages with explicit domain, application, and infrastructure responsibilities.

Manage a reproducible Python service environment using pyproject.toml, pinned dependencies, and isolated virtual environments.

Add Python type annotations and use a static type checker to identify interface defects.

Define validated configuration and request models using Pydantic.

Apply dependency inversion to replace an infrastructure dependency without changing domain logic.

Create a consistent exception hierarchy that separates domain, validation, and infrastructure failures.

Enforce formatting, linting, and type-checking standards with automated development commands.

Translate a service requirement into resources, operations, and explicit API acceptance criteria.

Specify a REST API contract with OpenAPI request, response, and error schemas.

Implement a FastAPI endpoint with typed validation and dependency injection.

Map domain and infrastructure failures to stable HTTP error responses.

Implement pagination, filtering, and deterministic sorting for a collection endpoint.

Apply an API compatibility strategy when introducing a breaking contract change.

Implement a service client that validates responses and reports actionable failures.

Write focused pytest unit tests for domain behavior using arrange-act-assert structure.

Use fakes, stubs, and mocks selectively to isolate an external dependency.

Write parameterized tests for validation boundaries and failure cases.

Create an integration test that exercises a service endpoint and a real test database.

Verify an API implementation against its published contract.

Use coverage and mutation results to identify a meaningful gap in a test suite.

Configure a continuous-integration quality gate for tests, linting, and static type checks.

Design a normalized PostgreSQL schema from a service data model and its access patterns.

Implement a repository interface that keeps persistence details outside domain logic.

Define a transaction boundary that preserves a business invariant during concurrent updates.

Create a backward-compatible schema migration with a safe rollback or roll-forward plan.

Use EXPLAIN output to select an index for a slow query.

Configure database connection-pool limits from service and database capacity constraints.

Implement a Redis cache-aside path with explicit expiration and invalidation behavior.

Choose between Kafka, MQTT, and synchronous APIs for a stated communication requirement.

Define a versioned event schema with compatibility rules and required metadata.

Configure a Kafka producer's keying, acknowledgment, and retry behavior for a delivery requirement.

Implement a consumer that manages consumer-group processing and offset commits correctly.

Make an event handler idempotent using a durable deduplication record.

Apply the transactional outbox pattern to avoid a database-and-message dual-write inconsistency.

Design dead-letter and replay procedures that prevent poison messages from blocking recovery.

Select synchronous execution, threads, asyncio, or multiprocessing for a given Python workload.

Implement cancellation and timeout handling in an asyncio operation.

Prevent a race condition in shared state using an appropriate synchronization mechanism.

Create a load-test scenario with representative traffic, latency targets, and pass criteria.

Use profiling evidence to locate a CPU, memory, or I/O bottleneck in a Python service.

Measure the effect of one performance optimization against a repeatable baseline.

Estimate service capacity from throughput, latency, concurrency, and utilization measurements.

Construct a dependency failure map for a multi-service request path.

Allocate per-dependency timeout budgets from an end-to-end latency objective.

Configure bounded retries with exponential backoff and jitter for a stated failure mode.

Apply a circuit breaker or bulkhead to limit cascading failure.

Design an idempotency-key workflow for safely repeated write requests.

Select a consistency model for a workflow and explain its user-visible consequences.

Implement graceful degradation or load shedding for an overloaded dependency.

Design a controlled fault experiment with explicit safety limits and recovery criteria.

Create a lightweight threat model covering assets, trust boundaries, likely threats, and mitigations.

Enforce authentication and resource-level authorization on a service operation.

Load application secrets through a managed secret interface without exposing them in code or logs.

Generate an SBOM and evaluate a vulnerable dependency for exploitability and remediation urgency.

Harden a service container using a minimal image, non-root execution, and restricted runtime settings.

Build a CI pipeline that tests, scans, packages, and signs a service artifact.

Define progressive-delivery health checks and an automated rollback condition.

Specify a reusable service template that gives developers a secure, observable deployment path.

Instrument a Python request path with OpenTelemetry traces, metrics, and structured logs.

Propagate correlation context across an HTTP call and a Kafka message.

Build a service dashboard around request rate, errors, latency, and saturation signals.

Derive a user-centered service-level indicator from a critical application journey.

Configure a multi-window error-budget burn alert for a stated service-level objective.

Use correlated telemetry to identify the failing component in a distributed request trace.

Verify that telemetry detects and explains a controlled service fault.

Convert an incident finding into a testable code or architecture improvement.

Convert business requirements into measurable availability, latency, scalability, security, and cost attributes.

Estimate peak workload and growth assumptions for a proposed service.

Define service boundaries by separating business capabilities and data ownership.

Choose synchronous or asynchronous communication for an interaction using coupling and failure criteria.

Select a data store by comparing access patterns, consistency, scale, and operational burden.

Create context, container, and component views for a proposed system using the C4 model.

Write an architecture decision record that documents alternatives, trade-offs, and consequences.

Evaluate an architecture against failure scenarios, operability, security, and cost constraints.

Write a concise technical proposal that connects an engineering change to customer and business outcomes.

Facilitate a design review using explicit criteria, recorded decisions, and assigned follow-up actions.

Break an architecture initiative into milestones with dependencies, risks, and measurable completion criteria.

Prioritize reliability work and technical debt using impact, risk, effort, and error-budget evidence.

Delegate a technical workstream with clear decision boundaries, checkpoints, and success measures.

Create a mentoring plan that uses observable skill goals and actionable feedback.

Facilitate a blameless incident review that produces systemic corrective actions with accountable owners.

Present an architecture trade-off recommendation differently for engineers, product partners, and executives.

Write a one-page capstone brief defining the user problem, system boundary, success metrics, and constraints.

Assemble an architecture evidence pack containing C4 views, key decisions, a threat model, and reliability targets.

Trace one critical user journey across the API, data store, messaging path, and observability signals.

Execute a controlled progressive release and demonstrate rollback from a failed health criterion.

Run a bounded fault scenario and collect evidence of detection, containment, and recovery.

Conduct a structured design-review presentation and record how feedback changes the solution.

Write a portfolio case study that quantifies software, reliability, and leadership outcomes.

Create a 30-60-90-day development plan mapped to hybrid lead-engineer responsibilities and promotion evidence.