Python for the data and AI layer, engineered like the rest of the estate.
Python engineers who ship Django and FastAPI services, data pipelines and model-serving APIs with the tests, typing and observability an enterprise expects — not notebooks promoted to production.
- Python
- FastAPI
- Django
- pydantic
- pytest
- PyTorch
Python is where our data and AI work lives.
Every model we train, every evaluation harness we run and most of the pipelines that feed them are Python — because that is where the libraries are, and where the people who understand the maths already work. FastAPI turns that work into services: typed, asynchronous, documented from the code, and fast enough to sit on a request path. Django covers the other end — content-heavy back-offices, admin-driven applications and anything where a mature ORM, authentication and an admin interface save work.
The problem with Python in the enterprise has never been the language. It is the gap between a notebook that works once and a service that works every day. We close that gap with the same discipline we apply to TypeScript and Java: type hints checked in CI, tests that mirror the risk, containers built once, traces on every request.
We do not put Python on hot transactional paths that need predictable, very low latency, and we do not use it where a JVM or Go service already owns the domain. It is the right tool for data, models and glue — and an honest one for a great deal else.
Six things we ship in Python.
Model-serving APIs
FastAPI services in front of classifiers, forecasters and embedding models — with request validation, batching, timeouts and the latency dashboard that tells you when the model is slower than the agreed target.
LLM applications and RAG
Retrieval pipelines on pgvector or Pinecone, prompt and tool orchestration with the Anthropic and OpenAI SDKs, and an evaluation suite that runs in CI so a prompt change is a tested change.
Data pipelines
Airflow DAGs and dbt models that move data from operational systems to warehouses, with Great Expectations checks on the way — so the dashboard is wrong less often, and loudly when it is.
Django back-offices
Admin-driven applications for operations teams: catalogue management, case handling, content workflows. The Django admin gets you a working screen out of the box; we build it to stay maintainable.
Integration and automation services
Connectors to ERPs, CRMs and file-based partners, scheduled jobs and event consumers — the unglamorous services that keep an estate consistent, written with retries and idempotency from the start.
MLOps tooling
Training pipelines, experiment tracking in MLflow, model registries and the promotion path from candidate to production, with the evals that gate it.
When to choose it.
Choose Python when the work touches data science, machine learning or LLMs — the libraries, the tooling and the talent are there. Choose FastAPI when you need a typed, asynchronous service and want OpenAPI documentation for free. Choose Django when the application is form- and admin-heavy and you would rather configure authentication, permissions and an ORM than write them. All three suit teams that already have Python skills in analytics or data engineering and want to ship them to production.
Do not choose it for CPU-bound request paths that need consistently very low latency, for high-concurrency real-time channels where Node.js or Go are better matched, or for a domain your organisation already runs on the JVM with the operational tooling to match. And do not let a proof-of-concept notebook become the production service by accident — we will insist on the rewrite.
A scoring endpoint with validation, tracing and a timeout.
class ScoreRequest(BaseModel):
member_id: UUID
features: dict[str, float] = Field(min_length=1)
@router.post('/score', response_model=ScoreResponse)
async def score(req: ScoreRequest, model: Model = Depends(get_model)):
with tracer.start_as_current_span('churn.score'):
# bounded — a slow model degrades, it never blocks the pool
result = await asyncio.wait_for(model.predict(req.features), timeout=0.25)
return ScoreResponse(member_id=req.member_id, score=result.p, version=model.version)Where Python sits in an Odeontech estate.
What the Python codebases we hand over look like.
- Typed and checked. Type hints throughout, mypy or pyright in CI, and pydantic models at every boundary — the service refuses malformed input rather than failing three calls later.
- Reproducible environments. Locked dependencies with uv or Poetry, pinned base images, and no
pip installat runtime. The container that passed tests is the container that runs. - Tests that mirror the risk. pytest for domain logic, contract tests for integrations, and for models an evaluation suite with a baseline that a change must not regress.
- Async where it helps, not everywhere. I/O-bound work is asynchronous; CPU-bound work runs in a worker process or a queue, away from the request pool.
- Observability from the first commit. OpenTelemetry traces, structured logs, and for model services the extra signals: input drift, score distribution, latency per version.
- Data checks in the pipeline. Great Expectations or equivalent on every load; a failed expectation stops the DAG and pages someone, rather than publishing a wrong number.
- Secrets and PII handled deliberately. Secrets from a vault, personal data minimised and masked in logs, KVKK and GDPR obligations reviewed with the data controller before the first extract.
- Formatted, linted, consistent. ruff and black on save and in CI, so reviews are about logic rather than style.
What usually ships alongside it.
- A FastAPI or Django service template with auth, validation, tracing, health checks and a Dockerfile that builds reproducibly
- An evaluation harness for any model or LLM feature, wired into CI with a stored baseline
- Airflow DAGs and dbt models with data-quality checks and lineage documentation
- MLflow experiment tracking and a model registry with a documented promotion path
- Runbooks and dashboards for each service, including model-specific signals
Frequently asked questions
Neighbouring technologies and the services that use them.
Need Python engineers who ship to production?
Tell us whether the work is a model API, a pipeline, a Django back-office or an LLM feature, and the seniority you need. We will propose a named team or place specialists into yours.