Precision
Python
Engineering

A CPython Core Developer contributes directly to the source code of the official Python interpreter (CPython), hosted at github.com/python/cpython. CPython is the reference implementation of the language: it is the engine that runs your code in the vast majority of production environments. Becoming a core developer requires years of contributions recognised by the community, followed by co-option by existing contributors. At mgx.io, we have been participating in language evolution discussions (PEPs), code reviews and bug fixes since 2019. This knowledge of Python's internals — bytecode, GIL, garbage collector, import system — directly informs our architectural decisions and performance diagnostics.

Yes. Mgx.io works fully remote across Europe from Belgium (CET/CEST). Collaboration is structured as follows: kick-off meetings and sprint reviews via video call; development and code reviews asynchronously through the client team's tools (Slack, Linear, GitHub, Jira…). We adapt to your existing processes rather than imposing our own. For engagements that require it, occasional on-site visits in Europe are possible. Experience shows that a disciplined asynchronous setup — clear documentation, commit conventions, well-described PRs — produces better code quality and traceability than physical presence without methodology.

TDD (Test-Driven Development) means writing the test before the production code. This Red-Green-Refactor cycle forces clear interface design upfront and eliminates business ambiguities before they become bugs. In practice at mgx.io: pytest as the testing framework, hypothesis for property-based testing (automatically generating edge cases), factory-boy with faker for generating realistic test fixtures, and test suites that document the expected behaviour of every component. Writing tests after the code often produces tests that validate the implementation rather than the expected behaviour — and pass even when the logic is wrong. TDD reverses that dynamic.

DevSecOps integrates security at every stage of the CI/CD pipeline rather than at the end of the project. In practice: static Python code analysis (bandit), dependency scanning (pip-audit, trivy for Docker images), automatic dependency updates (Renovate or Dependabot), and checks on every PR via GitHub Actions. Commit hooks (prek) ensure every contribution meets quality rules and best practices before even reaching CI. Result: known vulnerabilities are detected within minutes of being published in CVE databases, and none reach production without being addressed.

Mgx.io is proficient across the modern Python ecosystem. For APIs and microservices: FastAPI (default choice for its performance and native typing via Pydantic) and Django REST Framework for projects with complex ORM needs. For data pipelines: Pandas, Polars and Apache Kafka (via confluent-kafka). For testing: pytest with hypothesis for property-based testing, factory-boy with faker for fixtures. Infrastructure: Docker, Kubernetes, PostgreSQL, Redis. The guiding principle: choose the right tool for the context — no over-engineering with a heavy framework for a simple service, no bespoke solution when an industry standard exists.

Our process follows five steps. (1) Scoping: understanding the business context, technical constraints and success criteria before writing a single line of code. (2) Architecture: proposing a documented architecture with explicit trade-offs. (3) Setup: scaffolding the project with CI/CD, tests, linting and security configured from the first commit. (4) Iterative development: short sprints with regular demos, reviewed PRs and automated tests at every stage. (5) Handover: careful documentation and handoff so the internal team can take over without friction. This sequence prevents silently accumulated technical debt.

An independent Python consultant integrates directly into your team: you work with the person writing the code, not with a project manager delegating to junior developers. At mgx.io, Stéphane Wirtel — CPython Core Developer since 2019 — is personally involved in every engagement. This means less latency (no intermediate briefing), directly available technical expertise and clear accountability. An agency offers scalability (multiple developers in parallel) but often dilutes expertise across heterogeneous profiles. For complex Python engagements requiring senior-level expertise, the specialised consultant is more effective and more predictable.

Both. Mgx.io works on engagements of varying lengths: technical audit or proof-of-concept (1 to 4 weeks), reinforcement or targeted refactoring (1 to 3 months), or long-term recurring technical consultant (6 months and beyond). There is no minimum duration. Short engagements are scoped precisely upfront with defined deliverables. Long-term engagements include regular check-ins and continuous adaptation. Billing is time-and-materials or fixed-price depending on scope visibility.

Mgx.io uses LLMs as a development assistant: accelerating repetitive code writing, automating refactoring, generating tests and exploring solutions faster. What AI does not replace: architectural judgement, business context knowledge, and critical review of generated code. Every line — human-written or LLM-assisted — goes through the same checks: automated tests (pytest, hypothesis, factory-boy), commit hooks (prek), rigorous code review. Result: faster delivery, without compromising quality. AI is a productivity multiplier in the hands of a senior developer — not a shortcut to throwaway code.

Yes — and it's a situation we've faced multiple times on large-scale projects. Taking over an untested codebase starts with a technical audit: identifying risk areas, tight coupling, and undocumented behaviour. We then progressively build test coverage — starting with the critical paths — without blocking ongoing deliveries. The approach is iterative: every new feature is developed in TDD, and every bug fix becomes a non-regression test. Within a few sprints, coverage climbs and the team's confidence in the codebase is restored. We don't push for a full rewrite: we rebuild trust where it matters most, in the order that maximises value.

Yes. Mgx.io has led Odoo migrations on real projects, including complex version upgrades from legacy branches (8.0) to modern releases. We also run Odoo 18 in production for our own company operations — this dogfooding gives us a concrete understanding of upgrade constraints, breaking changes between versions, and customisation best practices. Whether you need to migrate an ageing Odoo instance, audit custom modules, or integrate Odoo with third-party systems via Python, we bring the same rigour as on any professional Python project.