Loading · Python
Stack Innovations Start a project
Stack Innovations/ Services/ Custom Development/ Python
03 / 08 · Custom Development
000Starting Python

Python

Bespoke Python services, engineered for the ten-year arc.

Start a build →
Median p95 latency62ms
Test coverage92%
Type coverage · mypy strict97%
Deploy time3m
The argument

A Python service is just async I/O wearing a readable syntax.

Each route · a contract. Each model · a guarantee. Each await · a decision held.
02 — Ecosystem

Python,
and the right neighbours.

Framework/01
FastAPI

Async-first, OpenAPI generated automatically from type hints. Our default for new services.

ASGIOpenAPIAsyncType hints
Framework/02
Django

Batteries-included for content-heavy or admin-heavy platforms.

ORMAdmin
Validation/03
Pydantic v2

Rust-core validation; the type system FastAPI is built on.

SchemasRust core
Data layer/04
SQLAlchemy 2.0

Typed, async-capable ORM for Postgres and friends.

Async ORMTyped
Task queue/05
Celery

Background jobs, scheduled tasks, retries.

WorkersBeat
Packaging/06
uv

Rust-built installer and resolver, replacing pip/poetry workflows.

ResolverLockfile
Linting / Formatting/07
Ruff

A single Rust-based tool replacing flake8, isort, and Black.

LintFormat
Type checking/08
mypy

Static analysis on a language that didn't ship with types.

StrictCI gate
Testing/09
pytest

Fixtures, parametrization, the de facto standard test runner.

FixturesParametrize
Serving/10
Uvicorn + Gunicorn

ASGI workers behind a process manager, production-grade. Hot-reload in dev, multi-worker in prod.

ASGIWorkersProcess manager
Observability/11
OpenTelemetry

Tracing across services, vendor-neutral.

TracesMetrics
03 — What we build

Three shapes,
one toolkit.

01 — APIs
APIs &
backends.

FastAPI and Django services. Typed end to end, validated at the edge, documented before the first reviewer asks.

  • →Routers · resource-scopedFastAPI
  • →Request/response modelsPydantic
  • →Auth · OAuth2, JWT scopesOIDC
  • →OpenAPI · generated, not hand-writtenSwagger
GET /v1/orders
02 — Pipelines
Data &
automation.

ETL, scheduled jobs, third-party integrations. Idempotent by default; retried, not re-run by hand.

  • →Scheduled tasks · cron-styleCelery beat
  • →Queue workers · retries, backoffCelery
  • →ETL · extract, transform, loadBatch
  • →Webhook intake · verified, replayedIdempotent
task queue retries next-run
03 — Internal tools
Internal
tools & admin.

Django-admin-style back office, scripting. Operator-grade CRUD that doesn't need its own onboarding doc.

  • →Admin panels · model-drivenDjango admin
  • →Bulk actions · auditableLogged
  • →Scripted ops · one-off + scheduledCLI
  • →Permissions · per role, per fieldRBAC
w1 w6 w12
/ Phase 01 · Discover

Listen first.

Stakeholder interviews, support tickets, session replays. We map the architecture by mapping the work.

Discovery docTech auditRisk map
SCOPE USERS DATA TEAM RISK OUTCOME
app/routers/ routers/auth.py routers/orders.py routers/webhooks.py dependencies.py models/ services/
# schemas/order.py class OrderCreate(BaseModel): sku: str qty: PositiveInt currency: Literal["USD","EUR"] class OrderOut(OrderCreate): id: UUID status: OrderStatus created_at: datetime → openapi.json regenerated → validated on every request → shared with the client SDK
# routers/orders.py router = APIRouter(prefix="/orders") @router.post("/", response_model=OrderOut) async def create_order( body: OrderCreate, db: AsyncSession = Depends(get_db), ): return await orders.create(db, body) → 201 · typed · validated → traced · OpenTelemetry span → tested · pytest + httpx
w1 w6 w12 −38% p95 latency
01
01
05
05 — Architecture

A request,
end to end.

// live · GET /v1/orders?status=open
Request Static
Client HTTP · JSON SDK · fetch Edge LB · TLS term ~10ms API FastAPI · Uvicorn ASGI · async Workers + DB Celery · Postgres SQLAlchemy 2.0 Observability OpenTelemetry Logs · Traces · Metrics
Client → Edge~10ms
Edge → API~16ms
API → DB~9ms
Round-trip · p9562ms
06 — Numbers

Standards,
not anecdotes.

What every Python build leaves with — the floor, not the ceiling.

pytest coverage 0 across last 12 builds
#StandardFloorMethod
01 p95 latencyAPI · cold 0ms RUM
02 Type coveragemypy · strict 0% mypy
03 Test coverageline · branch 0% pytest-cov
04 Ruff lint violationsCI gate 0 Ruff
05 Deploy timecommit → live 0m CI
06 Error rate5xx · p50 0% Sentry
08 — Engagement

Three ways
to start.

01 / Sprint2 weeks
Diagnostic
sprint.
flatfixed scope
  • →Tech audit · current Python stack
  • →Architecture proposal
  • →Risk & cost map
  • →Live walkthrough · written report
Book a sprint →
02 / MVP— Most chosen
MVP ship.
retainer4–8 weeks
  • →One service, end to end
  • →Auth · Background jobs · Telemetry wired
  • →Schema & contract seed · validated models
  • →CI/CD · monitoring · runbook
  • →Two rounds of post-launch iteration
Start an MVP →
03 / Build12+ weeks
Ground-up
platform.
retainerquarterly
  • →Multi-service platform
  • →Internal admin + customer-facing API
  • →Embedded design partner
  • →Hand-off plan, onboarded team
Plan a build →
09 — Questions

Things people
actually ask.

Python wins when the work touches data science, ML inference, or a team that already thinks in Python — the standard library and ecosystem (pandas, NumPy, scikit-learn) have no real equivalent elsewhere. For pure low-latency request handling we'd discuss Go; for a unified TypeScript stack, Node. Most backend and data-pipeline work doesn't need either trade-off, and FastAPI's async runtime closes most of the historical performance gap.
FastAPI for new API-first services — async by default, OpenAPI generated from type hints, no ceremony. Django when the project is content- or admin-heavy and benefits from a built-in ORM, auth, and the Django admin out of the box. We've shipped both, and we pick per project, not per preference.
Celery, backed by Redis or RabbitMQ as the broker. Scheduled tasks run through Celery beat; one-off and retryable jobs go through standard workers with exponential backoff. For lighter workloads we'll sometimes reach for FastAPI's built-in background tasks, but anything that needs retries or visibility gets a real queue.
Yes, in strict mode, run in CI on every PR. Combined with Pydantic models at the request boundary, this catches most of the bugs that would otherwise surface at runtime. We don't chase 100% type coverage on every internal script, but anything in the request path is fully typed.
Yes — a large share of our Python work is brownfield. We start with a tech audit (dependency health, type coverage, test coverage), then ship incrementally behind feature flags rather than proposing a rewrite. Legacy Flask or Django 3 apps are a normal starting point, not a blocker.
pytest for unit and integration tests, with fixtures and parametrization to keep cases readable. httpx's async client drives API-level tests against FastAPI directly, no separate server process required. CI runs the full suite plus Ruff and mypy on every PR; nothing merges on a red build.
10 — Start

Let's build
something worth shipping.

Two-week diagnostic, four-week MVP, twelve-week ground-up. Bring the brief — we'll send a plan, not a pitch deck.

Start a project →
Tweaks
Accent
Motion
Lenis
Sound