Professional Python and FastAPI

Configure Ruff to format code and enforce a consistent set of linting rules.

Run a static type checker and correct type errors without suppressing valid warnings.

Write a pytest unit test for incident-domain logic using arrange, act, and assert.

Use parametrized tests to verify multiple incident severities, statuses, and boundary cases.

Create pytest fixtures with appropriate setup, teardown, and scope.

Use tmp_path and monkeypatch to isolate filesystem and environment-dependent behavior.

Replace an external collaborator with a focused test double rather than invoking the real service.

Assert expected exceptions and verify their relevant details.

Measure branch coverage and identify behavior that lacks meaningful tests.

Refactor incident status-transition logic into a pure function protected by unit tests.

Map incident-management resources to REST routes, HTTP methods, and status codes.

Create and run a FastAPI application with an ASGI development server.

Implement path and query parameters with explicit types and constraints.

Define Pydantic request models for creating and updating incidents.

Add field and model validation for cross-field incident rules.

Define response models that prevent internal or sensitive fields from leaking.

Return consistent client errors for missing resources and invalid operations.

Customize generated OpenAPI documentation with tags, summaries, and request examples.

Distinguish CPU-bound work from blocking and non-blocking I/O when choosing sync or async code.

Write and call async Python functions that await non-blocking I/O.

Run independent asynchronous operations concurrently while handling failures predictably.

Separate FastAPI routers, application services, domain models, and infrastructure adapters.

Define a typed repository contract with Protocol so domain services do not depend on PostgreSQL.

Inject services and repositories through FastAPI dependencies.

Load and validate environment-specific configuration with pydantic-settings.

Manage startup and shutdown resources with FastAPI lifespan handlers.

Design a relational schema for incidents, users, assignments, and timeline entries.

Map the incident schema to SQLAlchemy 2 declarative models.

Configure an asynchronous SQLAlchemy engine and per-request session lifecycle.

Implement repository operations to create, retrieve, update, and list incidents.

Map model relationships and load related data without triggering N+1 queries.

Define transaction boundaries around multi-step application-service operations.

Translate database constraint violations into domain-specific conflicts.

Create and apply reversible schema migrations with Alembic.

Enforce allowed incident status transitions with an explicit state machine.

Record an immutable timeline entry in the same transaction as each incident change.

Implement bounded filtering and sorting for the incident collection endpoint.

Implement paginated collection responses with navigation metadata.

Implement PATCH semantics that distinguish omitted fields from explicit null values.

Make incident creation safely repeatable by processing an idempotency key.

Detect conflicting concurrent updates with optimistic locking.

Choose a compatible API versioning strategy for a breaking contract change.

Create a focused threat model for the incident-management API.

Hash and verify user passwords with a password-specific adaptive hashing algorithm.

Issue short-lived signed access tokens containing minimal identity claims.

Validate token signature, expiry, issuer, and audience before resolving the current user.

Enforce role-based permissions through reusable FastAPI dependencies.

Enforce object-level authorization for incident visibility and modification.

Configure explicit production CORS origins and trusted hosts.

Prevent credentials and tokens from appearing in configuration output, logs, and error responses.

Test FastAPI endpoints with an HTTP client without starting an external web server.

Override FastAPI dependencies to isolate an endpoint from external collaborators.

Verify success, validation, not-found, and conflict responses against the API contract.

Run PostgreSQL integration tests against a disposable containerized database.

Isolate database tests so one test cannot affect another.

Verify that all Alembic migrations upgrade a clean database successfully.

Test authentication and authorization across representative roles and ownership cases.

Write a concurrency test that verifies optimistic locking or idempotency behavior.

Convert unhandled domain and infrastructure failures into safe, consistent API responses.

Emit structured JSON logs with useful operational context.

Propagate a correlation ID through requests, logs, and responses.

Implement separate liveness and readiness endpoints with meaningful checks.

Expose request rate, latency, and error metrics in Prometheus format.

Instrument a request path with OpenTelemetry traces across API and database operations.

Apply timeouts and bounded retries with backoff to an outbound dependency.

Run a basic load test and use latency percentiles and error rates to identify a bottleneck.

Build a minimal non-root container image for the FastAPI application.

Run the API, PostgreSQL, and supporting development services as a reproducible Compose stack.

Configure the ASGI server for container resource limits, proxy headers, and graceful shutdown.

Run database migrations as a controlled release step rather than on every application startup.

Create a CI pipeline that runs formatting checks, linting, type checking, tests, and migration validation.

Scan Python dependencies and the container image for known vulnerabilities.

Configure Kubernetes health probes and termination behavior for zero-downtime API rollouts.

Execute smoke tests and a rollback drill against a deployed incident-management API.