Backend engineering / FastAPI
FastAPI development.
Typed contracts, data and integrations.
Define the API, permissions and operating model before selecting async libraries. Plan a Python integration, webhook, model-serving or product API with explicit validation, data-session, job and receiving-team handover evidence.
Discuss FastAPI requirements โContents ยท FastAPI
Start with the API contract and business invariants.
FastAPI work can include typed REST interfaces, WebSockets, partner integrations, webhooks, SaaS/marketplace data and model-serving endpoints. Map callers, records, permitted actions, provider effects and failure recovery first. One API can support multiple clients only when their versioning, identity and data contracts are designed and tested.
FastAPI architecture can use feature APIRouters, Pydantic settings/schemas, dependency wiring, SQLAlchemy sessions, Alembic and pytest. Confirm what exists in the chosen codebase and what is custom work. Verify validation, identity, database lifetimes and failure behavior in the running implementation.
Use Python libraries where they fit the domain, while comparing built-in admin/content needs, existing Flask/Django systems, TypeScript dependencies and CPU/model workload. Neither an API-first label nor async syntax establishes universal speed, lower hosting cost or a faster launch.
A handover needs build, data and operating evidence.
Specify repository/history, Python/runtime and locked dependencies, Pydantic schemas/settings, OpenAPI, tests, database/Alembic history, container/release files, workers, storage and runbook. Demonstrate clean install, build, release and restored backup by the receiving team. Transfer authorised credentials securely, not in source or example environment files.
Separate custom-work rights from reusable templates, packages, models/training data, media and external APIs. Agree confidentiality, IP assignment, branding, permitted reuse, support and exit terms in writing. Historical universal ownership, NDA timing and immediate independence promises are not verified current offers.
Compare validation, interfaces and deployment, not a universal winner.
- Async and workers:FastAPI uses ASGI; actual blocking libraries, worker/thread/process topology and downstream limits determine behaviour. Express and Flask deployments also need actual configuration checks.
- Validation:Pydantic can validate/convert declared data. Express/Flask can use selected libraries. No schema tool supplies business authorization or every invariant.
- Documentation:generated OpenAPI can reduce duplicate definitions, but custom responses, dependencies and implementation still need contract tests and review.
- Libraries:compare maintained Python model/data packages, npm needs, ORM/admin/content requirements and receiving-team skills. A registry size is not fit evidence.
- Operations:measure representative data, dependency latency, resource use, overload and recovery. No framework label proves a cheaper or faster system.
The source heading also names Django REST and Spring Boot beyond its actual FastAPI/Express/Flask columns. Preserve those as alternatives to evaluate rather than inventing missing rankings. Choose Django admin/content facilities, an existing Flask codebase or JVM integration when actual requirements support that choice.
Six buyer decisions before a FastAPI engagement.
What is it useful for?
Assess typed HTTP, webhooks, integrations, streaming/WebSockets and Python model/data interfaces against actual domain and operating needs.
Django, Flask or FastAPI?
Compare existing code, admin/content, ORM, extensions, async requirements and receiving-team skills without a universal time-to-launch claim.
Can it serve models?
Define preprocessing, model version, lifecycle, evaluation, input/output, data privacy and CPU/GPU placement. An async route does not accelerate inference.
Where should it run?
Choose actual container/VM/managed/function capabilities, limits, startup, networking and connection behaviour from the workload.
How fast will it be?
Measure queries, serialization, providers, event-loop blocking, workers, pools, resources, overload and recovery under representative data.
Who owns delivery?
Compare project, embedded-team and ongoing options with named API, data, security, release and incident owners and current terms.
Routers, services and repositories need explicit boundaries.
The source proposes APIRouter modules owning schemas, use-case services, repositories and database models, with Depends wiring. Choose boundaries that expose transaction scope, permissions and provider effects. A layered directory does not guarantee a new feature cannot affect an existing endpoint.
Dependencies can supply authentication, session and configuration with test overrides, but a dependency graph is not a permission policy. Specify which routes require which checks and test the actual wiring, including forbidden and unauthenticated paths. A fake dependency does not replace integrated database/provider evidence.
Agree errors, pagination, versioning, idempotency and serialization for web, mobile, admin and partner consumers. Generate clients where helpful, then test compatibility at build and runtime. A field rename becomes a build error only when the affected client is regenerated, checked and actually uses the updated contract.
Pydantic validates declared structures, not all business meaning.
Pydantic can coerce input into declared types by default. Strict behaviour is a configuration/field/validation choice, not a FastAPI default or universal refusal of every JSON representation. Check actual input mode, types, constraints, extra fields and validators. A type checker does not validate runtime requests.
A parsed ID or enum does not establish record ownership, allowed state transitions, currency, range or privacy. Add domain and database invariants plus explicit authorization. Not every request has a Pydantic body, and validation/error behaviour can be customized; do not promise every malformed value becomes a field-level422 before any application work.
response_model/return declarations can validate and filter normal output, but the selected schema can still include private fields. Returning a Response directly bypasses automatic validation/conversion/documentation. Check every response path, exception, stream/log and selected model instead of claiming internal fields cannot leak.
Generated OpenAPI reflects declarations and custom configuration, not proof the whole contract cannot drift. Check schema changes against agreed status codes, headers, security requirements, custom responses and actual serialized output, including failure cases.
The JWT dependency needs claims, user state and permission checks.
The sample reads JWT_SECRET from the environment, uses HTTPBearer, decodes a token with a fixed HS256 algorithm allowlist, catches PyJWT errors, constructs CurrentUser from sub and a role default, and injects it into a /me route. It illustrates dependency wiring, not complete identity or authorization.
- The fixed algorithm selection is preferable to trusting an attacker-controlled token alg. The actual key needs adequate strength, secure delivery, rotation and deliberate algorithm/key configuration. JWT signature integrity is not encryption.
- PyJWT checks some registered claims only when present. This decode call does not require exp or sub, or supply expected issuer/audience. Define required claims, validation and token purpose explicitly; do not describe every accepted token as expiring or from the intended issuer.
- claims["sub"] is outside the PyJWT exception handler and a missing sub can raise KeyError. Invalid CurrentUser data can also raise separate validation errors. Map malformed/missing claims to controlled authentication failure rather than an accidental server error.
- The default role string and /me echo do not enforce roles, resource/tenant access, disabled/deleted user state, revocation or current permissions. Verify the principal and allowed operation separately, including stale roles.
- The shown bearer dependency error/status behaviour depends on the installed framework/security configuration. Test missing/wrong scheme, malformed, expired, not-yet-valid, wrong issuer/audience and forbidden users with the intended status/headers.
- The code assumes startup configuration and a token-issuing system not shown here. It does not implement login, password reset, refresh, logout, second factors, provider identity linking or a production key service.
Inspect tests and real wire responses for those cases, with secrets/tokens excluded from logs. Verify that the authentication dependency is applied to every intended route and that the complete identity, token and data-access behavior meets the contract.
Technical example
Source sample, not an installed backend or verified deployment. The limitations above apply.
# FastAPI JWT auth dependency - recovered illustrative sample
import os
from typing import Annotated
import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from pydantic import BaseModel
JWT_SECRET = os.environ["JWT_SECRET"] # from the environment, never in source
bearer = HTTPBearer()
app = FastAPI()
class CurrentUser(BaseModel):
id: str
role: str
def get_current_user(
creds: Annotated[HTTPAuthorizationCredentials, Depends(bearer)],
) -> CurrentUser:
try:
claims = jwt.decode(creds.credentials, JWT_SECRET, algorithms=["HS256"])
except jwt.PyJWTError:
raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Invalid or expired token") from None
return CurrentUser(id=claims["sub"], role=claims.get("role", "user"))
@app.get("/me")
def read_me(user: Annotated[CurrentUser, Depends(get_current_user)]) -> CurrentUser:
return userasync def does not move blocking work off the event loop.
Await appropriate async database/HTTP operations inside async endpoints. A blocking driver, requests call or heavy computation called directly still runs where it is called and can block that worker. Async syntax does not automatically make a synchronous library nonblocking.
FastAPI runs ordinary def path functions and ordinary def dependencies it invokes in a threadpool. A normal helper called directly by your code is not automatically offloaded. Select async drivers or deliberate thread/process/service boundaries, then check cancellation, timeouts, thread capacity and shared-state safety.
Threads can help appropriate blocking I/O or native code that releases the GIL; they do not guarantee CPU-bound Python parallelism. Model inference and preprocessing may need processes, accelerators, batching or a dedicated service. Measure startup, queueing, memory and overload, not only the handler body.
Bound concurrent requests/tasks, external connections, message sizes and queues. A slow query can still exhaust pools even when awaited. Adding workers increases some capacity and also connections/memory; it is not a substitute for actual backpressure and database/provider limits.
Use a session lifecycle that matches each task and response.
SQLAlchemy AsyncSession is mutable, stateful transaction context and is not safe to share across multiple concurrent tasks. Use an appropriate session per task/use case; do not gather concurrent operations on one injected session on the assumption async makes it safe. Explicitly close/rollback and inspect query behaviour.
Define actual database constraints, indexes, transaction/isolation boundaries and idempotency for money, stock and identity. Async SQLAlchemy, Alembic or a repository does not establish a correct ledger, safe concurrent checkout or duplicate-safe webhook. Test failures and reconciliation with the real database.
Choose eager loading/bounded queries and inspect implicit I/O, serialization and pagination. Set pool limits across all workers/replicas against database capacity. Redis/Memcached need tenant-safe keys, expiry, invalidation and privacy; they are not authoritative payment/inventory state.
Dependencies with yield have version/scope-dependent cleanup behaviour. Current documentation distinguishes function scope, which closes before response sending, from request scope. Streaming must not use a session already closed, and long streams need deliberate resource ownership. Rehearse migrations and recovery, not only an ORM happy path.
Model serving needs lifecycle, privacy and per-worker resource plans.
Load shared resources through an appropriate lifespan/startup lifecycle and clean them up. Each process normally has its own memory, so loading a large model in each worker can multiply memory use. A startup hook does not mean one model instance shared across every replica or worker.
Specify preprocessing/features, model version, validation, evaluation, data rights, privacy, logging and explainability appropriate to the use case. Pydantic types do not establish clinical quality, financial suitability, fairness or FHIR/other domain conformance. Specialist and domain-specific tests remain required.
Choose batching, caching, CPU/GPU/process topology, timeouts, capacity and fail/overload behaviour from measured needs. A cached prediction needs model/version/data-safe keys and retention rules. Calling a model from async def does not make inference nonblocking or bound its memory.
Separate model development/training from API serving scope. An output or confidence score is not a verified business outcome. A fallback must not invent a clinical assessment, successful payment or external action that never occurred.
In-process background tasks are not a durable queue.
FastAPI BackgroundTasks schedules work after a response in the application process. It is not an independently durable job broker or proof of eventual delivery. Important work needs explicit persistence, retry/idempotency, ownership, observability and recovery choices.
Celery or another worker system adds broker/worker configuration, timeouts, retries, backoff, dead/failed jobs, safe replay and capacity duties. Enqueue success is not completed business execution. Coordinate database commits and provider effects with an outbox/reconciliation or another appropriate design.
Verify provider signatures, replay protection, quotas and uncertain outcomes for payments, logistics, notifications and webhooks. A timeout can follow an accepted charge; blind retries cannot imply a new legitimate charge. Keep credentials out of payload/logs and name the operator who resolves stuck work.
WebSockets, GraphQL and serverless need their own contracts.
REST, GraphQL and WebSockets are different interface choices. GraphQL needs a selected library/schema, field permissions and query limits; it is not a complete automatic interface from a FastAPI app. WebSockets need connection/message authorization, origin/session rules, backpressure, reconnect, stale state and deployment capacity.
Socket. IO is a higher-level protocol, not an interchangeable name for a raw WebSocket endpoint. The source delivery example uses both labels; verify client/server libraries, transport paths, compatibility and multiworker fan-out rather than silently treating them as the same API.
Choose actual ASGI/Uvicorn, container, VM, managed scale-to-zero or function capabilities. A Lambda adapter does not provide a long-lived raw socket session inside a short request invocation; gateway/connection architecture and limits must be checked separately. Large model packages, startup, networking, timeout and persistent state affect fit.
Behind a trusted proxy, configure forwarded headers, root paths, TLS and host/origin behaviour deliberately. Neither Nginx nor a load balancer is mandatory in every environment. Scope migrations, assets/storage, secrets, health checks, rollout and restored backups with a named receiving-team operator.
Docs visibility is a choice, not the authorization boundary.
Implement authenticated identity plus explicit object, tenant, role and field access. Review safe SQL/dynamic structure, uploads, external URL access, token/session/CSRF/CORS rules and rate/resource limits. A Depends call or response schema is not a full permission system.
Choose whether docs and schema should be available on the intended API. Disabling Swagger/ReDoc or changing their URLs does not authenticate endpoints, and disabling docs alone can leave OpenAPI accessible. Inspect actual docs_url, redoc_url, openapi_url and network/access controls. Public documentation is not itself proof of a vulnerable API.
pydantic-settings/environment variables keep configuration separate from source only when secrets are delivered, scoped and rotated safely. They do not encrypt a secret simply by loading it. Review dependency updates, logs/traces, privacy/retention and operator access with actual tests and deployment inspection.
Type checking, static analysis, coverage and a load report are limited evidence, not a security or regulatory certificate. Healthcare, PCI/payment and other sector claims require separately scoped specialist evidence; no such certification is asserted here.
Three engagement shapes with clear base/custom boundaries.
- Base adaptation:inspect actual backend, features, rights, apps/admin and provider setup; separate configuration/branding from extra FastAPI work.
- Custom API build:agree contracts, data, roles, integrations, jobs, model serving, acceptance, deployment and receiving-team handover.
- Ongoing development:define priorities, review/release cadence, Python/FastAPI/Pydantic/Starlette updates, security/incident duties, operating bills and exit support.
Confirm present availability and terms. Historical prices, minimum budgets, retainers, cancellation notice, delivery intervals, included support and team promises are not verified current offers.
Six quality areas with observable evidence.
- Review:router/dependency wiring, permissions, validation/output, blocking work, sessions, transactions and external effects.
- Tests:pytest/service, HTTPX/API and actual database/provider cases, including forbidden, missing claims, duplicates, concurrent and failure paths.
- Profiling/load:production-like image, data, workers, pools, model memory, latency/errors, overload and recovery.
- Handover:source/history, locked dependencies, setup/OpenAPI, schemas/Alembic, tests, workers, secure access and runbook.
- Release:reviewed build, secrets, data migration, health/rollout, smoke checks and restored backup.
- Operations:exceptions, traces, route timings, worker restarts, queue/pool state, privacy/retention and named incident/update owners.
A mypy/Ruff run, coverage threshold, container or green pipeline is scoped evidence, not proof untested behaviour cannot reach production. Record actual checks, limits and unresolved findings rather than adopting universal delivery/monitoring promises.
Sixteen technology areas to select and maintain.
- FastAPI:actual routes, declarations, dependency/error behaviour and support.
- Python:type/runtime behaviour, packaging and concurrency.
- Layered modules:router, use-case, data and permission ownership.
- Pydantic/settings:chosen coercion/strict/extra/output rules and secret delivery.
- Firebase:explicit identity/data/messaging/analytics scope and permissions.
- Redis/Memcached:cache/session/queue purpose, durability and tenant safety.
- Stripe/Razorpay:account scope, webhooks, ledger and reconciliation.
- WebSockets:protocol, identity, fan-out and recovery.
- GraphQL/REST:selected library/schema and resource/field limits.
- PostgreSQL/MongoDB:chosen data model, queries, migrations and recovery.
- GitHub Actions/chosen CI:scoped secrets, checks and reviewed artefacts.
- pytest/HTTPX:test lifecycle, async client and real integration coverage.
- SQLAlchemy/Alembic:task/session/transaction ownership and schema evolution.
- Sentry:errors/traces, private-data filtering and incident ownership.
- Uvicorn/Nginx or chosen host:workers, proxy trust, capacity and operations.
- Docker/AWS/chosen provider:reproducible inputs, limits, storage, secrets and costs.
Five stages from brief to controlled handover.
- Brief/confidentiality:callers, records, existing code, models and receiving-team needs.
- Scope/design:base/custom fit, API/data/provider contracts, acceptance, current quote and owners.
- Build/demonstrate:inspect actual routes, models, admin/jobs, tests and open issues at agreed checkpoints.
- QA/load/release preparation:permissions, data, claims, concurrency, integration/security, migration and recovery evidence.
- Deploy/handover:approval, controlled release, secure access transfer, receiver runbook/training, monitoring and agreed support.
Provider onboarding, compliance reviews, model/data readiness and any mobile-store work have separate owners and dependencies. No source first-endpoint, NDA-turnaround, build or response-hours interval is a current guarantee.
Quote API, model and operating scope separately.
Get a current itemised quote separating base adaptation, custom API, model development/serving, takeover and ongoing work. Define milestone acceptance, change control, third-party rights, hosting/provider bills and exit support. Historical bands and no-hidden-fee slogans are not current terms.
- Endpoints, roles, tenant/field access, admin and contract compatibility.
- Providers, webhooks, payments/logistics, idempotency and reconciliation.
- Streaming/WebSockets, GraphQL, queues and expected failure/load behaviour.
- Model/data preparation, evaluation, CPU/GPU, batching, memory and privacy.
- Database/schema migration, existing dependencies/tests, host/CI/monitoring, recovery and receiving-team operation.
Do not infer a separate admin with production environment editing is included or safe for every build. Scope actual API-key, user, analytics, webhook and configuration screens with least privilege, audit and secure change controls.
Upgrade dependencies and contracts through tested steps.
Inventory Python, FastAPI, Starlette, Pydantic, SQLAlchemy, drivers, model libraries, settings, jobs and deployed configuration. Pin/review compatible versions and relevant migration guides. A framework version bump alone does not repair application permissions, old schema assumptions or model/data quality.
Test validation/coercion, error/schema and serialization changes, dependency-yield lifecycle, sessions, async clients, proxy headers and authentication behaviour. Review generated-client compatibility and real responses, not only an unchanged endpoint path. Rehearse Alembic/data migrations with rollback/forward-fix and restore evidence.
For rescue, confirm authorised repository/host/database/provider/model access, backups and isolated boot/tests. Compare repair, staged update or selective replacement through a written risk assessment. Do not assume all untyped code is broken or a rewrite pays for itself without inspecting the actual system.
Recorded healthcare and delivery stories need separate verification.
The source describes a Canadian healthcare AI API using Pydantic/FHIR-shaped data, patient monitoring, model serving, Redis pub/sub and a BaaS integration. Preserve those as requirements, not proof of HIPAA safeguards, FHIR conformance, clinical suitability or a verified client deployment. Its headline and quoted completion intervals disagree; do not choose one as authoritative.
A separate illustrative Singapore delivery story retains vendor webhooks, Stripe, logistics integration, driver tracking, REST, Socket. IO/WebSocket and admin on a proposed container host. The narrative and project brief also give different delivery intervals. Verify actual protocol, base reuse, provider scope, data and acceptance rather than converting either number into a schedule.
Funding, partner counts, daily calls, load-test completion, PCI controls, live deployment and client outcomes are unverified and not adopted. Ask for code/configuration, permission/failure tests and primary operating evidence for any claimed reusable base.
FastAPI delivery review and handover.
The acceptance review can cover missing/expired/wrong-purpose tokens, forbidden record access, private-field output, direct responses, blocking operations, concurrent sessions, a failed/retried job and uncertain provider outcomes. Review actual requests/responses, queries, worker/model resource evidence and receiver release/backup restoration.
Product patterns to consider include utility billing with metering, dunning, tax rules, customer portals and tenant reporting; security dashboards with collectors, alerts, scoring and playbooks; and B2B commerce with orders, payments, credit, distributor pricing and reconciliation. Define the exact records, permissions, integrations and failure states for the selected product. These are possible project scopes, not a client portfolio.
The written scope should name the selected implementation, source and third-party rights, account ownership, release responsibilities and support terms. Include a receiving-owner walkthrough of the agreed build, tests and recovery steps, with open items recorded before acceptance.
Eight sectors become acceptance questions.
- Healthcare/life sciences:patient access, appointment data, audit and specialist privacy/regulatory review.
- Telemedicine:consultation/signalling state, scheduling, secure messages and participant permissions.
- Fintech:ledger, KYC/payment boundaries, reconciliation and controlled effects.
- Retail/eCommerce:catalogue, inventory, checkout concurrency and peak/recovery tests.
- Media/entertainment:billing, rights and entitlements.
- Creator economy:payouts, paywalls, analytics and moderation.
- Transportation/mobility:dispatch/location assumptions, stale updates and settlement.
- Food/beverage:order routing, kitchen/menu state, pricing changes and refunds.
Twelve questions before a FastAPI engagement.
Can it handle enterprise traffic?
Measure bounded requests/connections, CPU/model memory, workers, pools, providers, overload and recovery on the actual deployment.
What does it cost?
Get a current itemised quote for APIs, data, providers, model scope, migration and operations.
What source is delivered?
Specify history, locked dependencies, schemas/settings, OpenAPI, Alembic, tests, workers, build/release/configuration and runbook.
How quickly can it launch?
Agree a scope-specific schedule, acceptance and external dependencies after inspecting the base or existing code.
FastAPI or Express?
Compare Python/npm dependencies, team, contracts, workload and measured operation; neither is universally better.
What admin is included?
Inspect actual management screens and permissions; API-key, analytics, user, webhook and configuration features need explicit scope.
Who handles hosting and monitoring?
Name build/host, proxy/TLS, secrets, data, workers, health, rollout, restore and incident duties rather than assuming a cloud stack is managed.
What if bugs appear?
Agree defect scope, incident process, support, updates and additional-feature terms in writing.
How is confidentiality handled?
Confirm current confidentiality, access, subcontracting and custom/third-party/model-data rights before disclosure or implementation.
Which serverless platform?
Compare actual container/function limits, cold starts, model packages, networking, timeout and connection architecture against traffic.
What does the service include?
List actual contracts, validation, data, auth/providers/jobs, tests, release and handover instead of treating every stack item as installed.
What makes it ready to operate?
Verify permission/failure tests, dependency compatibility, bounded concurrency, secure configuration, migrations, restore and named operators; framework choice alone is insufficient.
Primary references for technical qualification.
Official platform, framework and API documentation checked on 17 November 2026. These support the technical checks here, not Omnistu staffing, pricing, rights, delivery or client outcomes. Recheck installed versions and configuration before implementation.
- Concurrency and async / await - FastAPI - fastapi.tiangolo.com
- Response Model - Return Type - FastAPI - fastapi.tiangolo.com
- Server Workers - Uvicorn with Workers - FastAPI - fastapi.tiangolo.com
- Background Tasks - FastAPI - fastapi.tiangolo.com
- API Reference - pyjwt.readthedocs.io
- OAuth2 with Password (and hashing), Bearer with JWT tokens - FastAPI - fastapi.tiangolo.com
- Lifespan Events - FastAPI - fastapi.tiangolo.com
- Dependencies with yield - FastAPI - fastapi.tiangolo.com
- Metadata and Docs URLs - FastAPI - fastapi.tiangolo.com
- Models - docs.pydantic.dev
- Configuration - docs.pydantic.dev
- Usage Examples - pyjwt.readthedocs.io
- Deployments Concepts - FastAPI - fastapi.tiangolo.com
- Return a Response Directly - FastAPI - fastapi.tiangolo.com
- SQLAlchemy asyncio extension
- Behind a proxy
- WebSockets
Bring the domain, dependencies and receiving-team needs.
Describe the records, users, permitted actions, integrations, existing code and operating constraints. Agree base/custom boundaries, acceptance evidence, current quote and handover before implementation.
Discuss FastAPI requirements โ