Ex-Disney · Ex-Globant · Freelance since 2014
Hire a senior Python developer — modern backends, LLM layers, data pipelines.
I ship Python that's typed, tested and production-ready. FastAPI for modern APIs, Django when the admin panel pays for itself, LLM integration layers for Claude / OpenAI / local models, and data pipelines that don't break when someone changes a column name.
Start a projectModern Python, not legacy scripts
Python 3.12+, type hints everywhere, Pydantic for validation, dataclasses for structure, pytest with proper fixtures, pre-commit hooks running black + ruff + mypy. If you've inherited a Python codebase with implicit types and no tests, this is what it can become.
FastAPI or Django — picked right
FastAPI is my default for new API-only backends (type-safe, fast, OpenAPI docs for free). Django when you need the admin panel, ORM maturity, and out-of-the-box auth — still the best for content-heavy apps with an editorial workflow. Flask rarely, only for legacy or when simplicity genuinely outweighs features.
LLM integration layers done right
Python is the LLM ecosystem's first language — the Anthropic SDK, OpenAI SDK, LangChain, LlamaIndex, Instructor all live there first. I build LLM layers in Python when the project already lives in Python, with the same discipline as any production backend — retries, observability, structured logging, cost tracking.
Data pipelines that survive reality
Celery for async tasks, Prefect / Airflow for orchestration, Pandas for classic data work, Polars when performance matters, SQLAlchemy 2.0 for typed DB access. Data pipelines break at the edges — I build defensively with schema validation and explicit error handling, not happy-path assumptions.
The Python stack I work with
- Python 3.12+Modern Python — type hints, pattern matching, asyncio
- FastAPIAPI-first backend — OpenAPI-docs-free, Pydantic-validated
- DjangoContent-heavy apps with admin panel, ORM, auth out of the box
- FlaskLegacy maintenance or deliberately minimal services
- PydanticValidation, serialization, settings — type-checked throughout
- SQLAlchemy2.0 typed ORM — async-capable, no magic
- CeleryBackground jobs, scheduled tasks, distributed work
- Poetry / uvDeterministic dependencies, lock files, fast installs (uv-first)
- pytestFixtures, parametrize, integration tests — all of it
- Pandas / PolarsClassic data vs performance — pick based on size
- LLM toolingAnthropic SDK, OpenAI SDK, LangChain, LlamaIndex, Instructor
- DockerContainerized deploys with proper multi-stage builds
When Python is the right backend choice
Python makes sense when the project sits in an ecosystem where Python has the best tooling: LLM and AI work (the SDKs, the evaluation frameworks, the notebooks all live in Python first), data and analytics pipelines (Pandas / Polars / DuckDB ecosystem), scientific computing (NumPy / SciPy), ML / inference serving (PyTorch / TensorFlow / Hugging Face). For these domains, Python isn't just one option — it's the default.
Where Python stops being the obvious choice: high-throughput APIs where latency matters at the millisecond level (Go or Rust win), frontend work (nothing Python does here, it's a browser problem), or team composition that already knows TypeScript deeply (use NestJS and keep one language across frontend and backend). I'll tell you if your team should use NestJS instead of Python — even though I offer Python work — because picking the right tool matters more than picking my tool.
On typing: modern Python with strict type hints, mypy in CI, and Pydantic validation closes 80% of the gap between Python and TypeScript on safety. It's not the same as Rust — nothing is — but it's enough for production backends to catch real bugs at commit time. Type hints are non-negotiable in the Python I ship.
I've worked on Python codebases spanning FastAPI-based LLM orchestration layers, Django CMS migrations for content-heavy sites, data pipelines for analytics and reporting, and automation scripts for ops workflows. The common thread is treating Python like a production language — tests, types, observability, dependency management with Poetry or uv — not like a prototyping tool that somehow made it to production without growing up.
FAQs
FastAPI for new API-only backends — modern, fast, great DX. Django when you need the admin, ORM, auth, and content workflow built-in. Flask only for legacy maintenance or genuinely minimal services where Django is overkill. I'll recommend based on your project needs, not on framework allegiance.
uv for new projects — it's 10-100x faster than Poetry/pip and the lock file format is compatible. Poetry for existing projects that are deeply invested in it. Both are better than plain requirements.txt; if you're still on that, migrating is a quick win.
Yes — this is a core part of my work now. Anthropic's official Python SDK, OpenAI's SDK, LangChain when structure genuinely helps, Instructor for structured output. I've built production LLM layers in Python handling prompt caching, tool use, RAG retrieval, and agent loops with proper observability.
Celery for async task queues, Prefect or Airflow for orchestration, Pandas for standard data manipulation, Polars when working with large datasets where performance matters. SQLAlchemy 2.0 typed ORM for database access. For one-off scripts I keep it simple; for recurring pipelines I invest in proper error handling and monitoring.
I integrate with existing ML services (Hugging Face, vendor APIs, self-hosted models) and build serving layers around trained models, but I don't train models from scratch or do data science research. If you need someone to train a custom model, you want a data scientist or ML engineer — I'll partner with them but won't be the primary on that work.
Yes, this is common. The migration path depends on what's there: Python 2 to 3 requires more work than Python 3.6 to 3.12, Django 1.x to 5.x is a multi-step upgrade, adding type hints to a 50K-line codebase is a 2-4 week project depending on scope. I audit first, then propose an incremental migration plan.
Need a senior Python engineer for production backends or LLM layers?
FastAPI, Django, modern typing, data pipelines, LLM integration. Reply within 24 hours.
Start the conversation