Python Development
Services and jobs in Python
We build Python web services and the scripts that move data around them. Django when the product needs an application and an admin. FastAPI or Flask when it needs a smaller HTTP API. A separate entry point when the work is a job, not a request.
What we build with Python
Python is readable, and that is only an advantage if the project has one way to run, one way to install, and a clear split between the web process and the jobs.
Django applications
Django fits an application with models, an admin, and server-rendered or API views. We use Django REST framework when the same models need a JSON API, and we keep business rules on the model or a service module rather than in the view.
Migrations ship with the code that depends on them. The admin is configured for the people who will use it, including which fields they must not edit.
FastAPI and Flask APIs
FastAPI is the usual choice for a typed HTTP API: Pydantic models on the boundary, dependency injection for the database session, and OpenAPI generated from those types. Flask remains a good fit for a small service or for an application that already uses it.
We do not grow a Flask app into an informal Django. If the project needs an admin, auth, and a migration story, we start with Django or we add those pieces on purpose.
Jobs and automation
A report, a file ingest, or a sync with another system gets its own module and its own command. Celery, RQ, or a scheduled container runs it. The web worker does not import a script that takes minutes.
pandas is available when the job is tabular. It is not the application framework. Data frames stay inside the job that needs them.
Environments and tests
Dependencies are locked, with uv, pip-tools, or Poetry, and the choice is written down. The same lock installs in CI and in the image that runs production. pytest covers the service and the job, including the database the ORM or the SQL actually hits.
Typical use cases
Python earns its place when the team wants one language for the HTTP service and for the automation around it, without pretending those are the same process.
An internal tool with an admin
A team needs to review records, correct a field, and export a slice. Django gives them that admin and a permission model. We build the models around the review step, not around every column in the source system.
A small API next to a data store
One or two resources, a clear schema, and a few callers. FastAPI or Flask is enough. We publish the schema and the error format, and we stop before the service accumulates unused apps.
A file or report that someone runs by hand
A workbook arrives, a person cleans it, and a system of record is updated. We turn that into a Python job with validation, a reject file, and a way to rerun the failed rows.
A glue service between two APIs
Python is a direct way to translate one provider's payload into another's. We keep the translation in a tested module, with timeouts and a record of what was sent, rather than in a notebook that only one person can run.
How we work
Python projects fail quietly when the environment is tribal knowledge. We make the install, the framework, and the job boundary boring on purpose.
Lock the interpreter and the dependencies
The Python version is the one production runs. The lockfile is the install. A developer machine that needs extra undocumented packages is a bug in the repo, and we fix it before adding features.
Choose Django, FastAPI, or Flask once
The framework matches the product: Django for an application with an admin, FastAPI for a typed API, Flask for a small existing or narrow service. Mixing them inside one deployable is not a phase we plan for.
Keep jobs out of the web process
Anything that waits on a file, a large query, or another company's API is a command or a queue task. The web process validates, records the request, and returns. The job reports success or a specific failure.
Test the boundary that can break
pytest, with the database and the HTTP client the code uses. A typed schema is checked against an example payload. A job is tested with the bad file we expect, not only the happy path.
Say whether this is a service or a job
Django, FastAPI, Flask, or a scheduled script. The shape of the work matters more than a preference for the language.
Why OLIANT
Python at OLIANT keeps the web service and the data job in the same language and in different processes.
One framework, named up front
Django, FastAPI, or Flask is a project decision with a reason. Later features follow it.
Jobs are first-class
Ingest, sync, and reports have a command, a failure mode, and a test. They are not hidden inside a view.
The environment is in the repo
Interpreter version and locked dependencies install the same way in CI and in production. Setup is a command, not a checklist in chat.
Frequently asked questions
Questions we answer before choosing a Python stack.
Django when you need models, an admin, and the batteries that come with a full application. FastAPI when you are publishing a typed HTTP API and you do not need that admin. Flask when the service is small or already written in Flask. We pick one.
We build the Python services and jobs around data: APIs, ingest, validation, and the code that puts rows where the application can read them. Training and evaluating a machine-learning model is a different engagement, and we will not describe a data job as if it were one.
A locked install in a container or a host virtual environment, with the web server named: gunicorn or uvicorn, depending on the framework. The start command, the worker count, and the health check are part of the repository.
Yes. A Python service can sit beside Java, Node, or .NET systems and talk to them over HTTP or a queue. Custom development is the wider page when the Python piece is one part of a product.
Python with a way to run it
Tell us whether you need an application, an API, or a job. We will name the framework and the process split.