- Market
- Saudi Arabia
- Written for
- CTO, Head of Digital
- Decision
- Build production services and data systems in Python
- Languages
- EN · AR
Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The gravity
Why the data and AI estate keeps pulling services into Python
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
Few organisations choose Python in the abstract. They arrive at it because the work that matters to them next — analytics, forecasting, document intelligence, machine learning — is overwhelmingly built there, and because the people who do that work think in it. A service written in the same language can import the feature logic the data team wrote, be reviewed by the same engineers, and move a model from a notebook to an endpoint without a translation step that quietly changes its behaviour. That adjacency is Python’s real argument, and it is a strong one.
The honest counterpart is that gravity is not a blank cheque. A high-concurrency gateway, a latency-critical trading path, a heavy computational core — these are workloads where Python is often the wrong resident, and pretending otherwise wastes the goodwill the language earned elsewhere. Our position is unsentimental: Python where the data gravity and the team make it the natural home, something else where measurement says the workload needs it, and both decisions written down with their reasons.
The API layer
Python API frameworks as three categories, not a brand contest
Framework names rotate; the categories are stable, and the choice between them follows from what the service is. We choose the category first and the current, well-maintained representative of it second.
| Option | What it hands you built-in | What it leaves you to assemble | Where it is at home | Best for |
|---|---|---|---|---|
| The batteries-included framework | Admin, ORM, auth, migrations — the whole application skeleton, with conventions to match. | Little — and that is the point, and also the constraint when your shape differs from its conventions. | A conventional data-backed application a team wants running, not designing. | Portals, back offices, content-heavy products. |
| The async-first API framework | Typed request and response models, generated documentation, async I/O through the stack. | The application structure around it — persistence, tasks, project conventions are yours to set. | Service APIs, especially those fronting models and data products. | The default for new Python service APIs. |
| The micro-framework | Routing and little else — a deliberately small core. | Everything else, which is freedom on a small service and a liability on a large one. | Small internal tools and services whose whole shape fits in one reviewer’s head. | Deliberately small surfaces, kept small. |
The regime
The disciplines that separate production Python from a long-running script
Python tolerates indiscipline better than most languages at small scale, which is exactly how large undisciplined codebases happen. These are the practices we enforce in the build so they do not depend on memory.
Typing as the survival tool
Type hints on every public function and boundary, checked in CI — because in a large Python codebase the types are how a stranger, or you in a year, learns what a function actually accepts.
What it protects: A codebase that can be changed by people who did not write it.
Locked, reproducible dependencies
Every environment built from a lock file, never from whatever the index served that morning — the same versions in development, CI and production, refreshed deliberately.
What it protects: Deployments that cannot differ from what was tested.
Packaged, not copied
Services ship as built container images with pinned interpreters, not as source trees assembled on the host — the "works on my machine" class of failure is closed structurally.
What it protects: An artefact that runs the same everywhere it lands.
The notebook boundary
Exploration lives in notebooks; production logic is extracted into tested, typed modules the notebooks import. The two are kept adjacent and never confused.
What it protects: Data science that reaches production without being rewritten blind.
Performance honesty
When Python is fast enough, and what we do when it is not
For most services, the time a request spends is dominated by I/O — the database, the network, the model call — and there Python’s own speed barely appears in the bill. The numerical stack complicates the caricature further: the heavy mathematics in data work executes in compiled libraries that Python merely orchestrates, which is why the language of notebooks can also be the language of serious computation. "Python is slow" is a slogan; whether your service is fast is a measurement, and we take the measurement before forming an opinion.
And sometimes the measurement says no: a hot path of pure Python in a tight loop, a concurrency profile the runtime cannot serve, a latency budget with no room for its overhead. The response is proportionate, in order: profile and fix the algorithm, push the hot work into the compiled layer, and — where a core genuinely needs it — implement that core in a faster language behind a stable interface, leaving the rest of the system in Python where the team is productive. Rewriting an entire estate because one loop was slow is the expensive way to avoid a profiler.
Our role
What a Python engagement with us covers, from notebook to production
- 01
The estate, mapped honestly
We map where Python already lives in your organisation and where its gravity genuinely helps, so services land in it for engineering reasons rather than by default.
- 02
The regime, installed in the build
Typing, dependency locking, packaged deployment and the notebook boundary are enforced by CI from the first week, so the discipline survives staff changes and deadline pressure.
- 03
Performance decided by evidence
Profiling before opinion: we find where the time actually goes, fix it at the cheapest effective layer, and only reach for another language when a measured core justifies it.
What the data should be asked and what the answers are worth stays with your analysts and your business; we make sure the Python underneath them is typed, reproducible and honest about its performance.
Common questions
What buyers ask
Is Python a sensible choice for a production API, or only for data science?+
It is a sensible choice for many production APIs, and the strongest case is where the API fronts data or model work that already lives in Python — the service shares code, people and review with the estate beside it. Modern async-first frameworks give typed contracts and generated documentation out of the box, and for I/O-shaped workloads the language’s own speed is rarely the constraint. The cases to avoid are the ones any honest assessment flags: very high-concurrency gateways, hard latency budgets, compute-heavy request paths. We put each service where its measured workload says it belongs.
Our Python codebase has no type hints. Is it worth adding them now?+
Yes, and incrementally rather than as a campaign. We start at the boundaries — public functions, API contracts, the modules most people touch — because that is where types pay most, then let the checker ratchet: new code must be typed, touched code gets typed, and coverage grows with normal work instead of stopping it. In a large Python codebase the types are the difference between a change you can make confidently and one you make by running everything and hoping. The one approach we advise against is the big-bang annotation sprint, which produces thousands of low-quality hints and no lasting habit.
How do you move a model from a data scientist’s notebook into a real service?+
By extraction, not by rewriting from a description. The logic that must survive — feature preparation, the inference call, the post-processing — is lifted out of the notebook into typed, tested modules, and the notebook is then changed to import those modules, so the exploratory and production paths run the same code and cannot drift apart. Around that core we add what a service needs and a notebook does not: input validation, versioned model artefacts, latency and drift monitoring, and a rollback path. The common failure we prevent is the silent translation, where a reimplementation subtly disagrees with the notebook and nobody can say which is right.
In this cluster
Next step
Assess the fit with us
A review of your services and data estate that says where Python earns its place, and the engineering regime it needs to hold it in production.
Assess the fit with us
What happens next
- 1We reply within one business day.
- 2A 30-minute scoping call with a senior consultant.
- 3A written proposal with scope, team, and timeline.
Or reach us directly
