About me

As AI coding agents became part of our daily work at CGM, their rapid adoption exposed inconsistent quality, duplicated effort, unreliable outputs, and the absence of common standards. In my role as a Software Engineer with Senior Developer seniority, I responded by leading the creation of a shared framework for the team.

I authored a governance model covering ownership, contribution and review lifecycles, independent testing, preview rollouts, composability, non-overlapping activation rules, and recommended quality thresholds. To make evaluation repeatable, I designed a weighted scoring rubric and implemented a deterministic Python tool that evaluates skills and workflows, reports critical issues, and ranks improvements by impact.

I also built reusable agent skills for safe Kubernetes diagnostics, Jira issue management, GitLab pipelines and merge requests, local Git operations, feature-environment resolution, and automated quality evaluation. Two orchestration workflows combine these capabilities into structured troubleshooting and evaluation processes, with explicit contracts, reusable dependencies, safety guardrails, and failure handling.

These assets are used broadly across the team. I continue to review contributions, help colleagues create and debug their own workflows, support them when they encounter AI-agent or tool-integration issues, and evolve the framework based on practical feedback.

Company-wide Single Sign-On was the next step for a multi-tenant healthcare SaaS platform used in France and Italy. As a Software Engineer with Senior Developer seniority at CGM, I designed and implemented the enterprise identity-provider integration end to end.

The key architectural boundary was to delegate authentication while keeping roles, permissions, and organizational access under the platform’s control, without removing the existing username-and-password login.

I owned the architecture, stakeholder coordination, Java/Quarkus implementation, security model, and technical documentation. The integration uses the OIDC Authorization Code Flow with PKCE, Pushed Authorization Requests, state, and nonce validation.

I designed server-side management of authentication state and external tokens, including refresh and session-coupled cleanup, as well as a provider-agnostic identity-mapping model that rejects ambiguous account matches. I also solved callback routing for dynamic test environments without weakening redirect validation.

The integration is now in production and actively used by healthcare professionals, providing secure federated authentication while preserving internal authorization boundaries.

Third-party integrations did not all use the same connection settings: endpoints varied by deployment environment and user profile, while the relevant configuration was scattered across files and application code. As a Software Engineer with Senior Developer seniority at CGM, I took ownership of replacing that fragmented model with a centralized configuration-resolution system.

Routing a test or pilot user to a non-production endpoint while healthcare professionals continued using the production endpoint often required a code change and redeployment, with no simple way to create an isolated exception for one user.

I replaced this with a three-tier resolution model evaluated for each user and integration: an explicit user override takes priority, an integration-specific strategy applies routing rules, and a database-managed default provides the fallback. This made routine endpoint changes and individual overrides configurable without redeploying the application.

I used Strategy and Factory patterns to keep custom routing logic isolated and extensible. I also designed the JPA data model, implemented the Java/Quarkus service and API, and documented the architecture through a formal RFC and technical diagrams. The system is actively used in production.

CGM products in multiple countries needed to reuse selected platform services on behalf of already authenticated users without requiring another sign-in or introducing multiple external token formats into the platform.

To create that secure bridge, I designed and implemented an OAuth 2.0 Token Exchange capability end to end as a Software Engineer with Senior Developer seniority at CGM.

I chose RFC 8693 and owned the full lifecycle, from protocol architecture and security design to the Java/Quarkus implementation, OpenAPI contract, and consumer documentation. I designed a Strategy and Factory architecture that isolates partner-specific token validation, allowing new integrations to be added without changing the core exchange flow.

Requested scopes are constrained by partner-specific permissions before a uniform internal platform token is issued, enforcing least privilege across downstream services. The capability is now in production and actively used by CGM products, providing a single, auditable security boundary for cross-product service access.

French healthcare smart cards and the DMP introduced an entirely new integration surface for the platform: physical readers, workstation-local software, real-time card events, regulated transactions, and unfamiliar healthcare protocols all had to work together.

As an Intermediate Software Engineer at CGM, I led the initial technical investigation and built a working proof of concept for CPS and Carte Vitale readers and France’s DMP shared medical record system.

I mapped and tested the end-to-end ecosystem, including reader sessions, practitioner and patient card access, asynchronous insertion and removal events, and key DMP document workflows. I created reproducible Postman examples and comprehensive technical documentation, and helped define an architecture separating frontend event handling from backend transactional operations.

My role was to make the integration path actionable, not to build the final production feature: I delivered working examples, architecture diagrams, live demonstrations, knowledge-transfer sessions, and implementation support to the delivery teams. Those teams used this foundation to complete the production capability, which is now heavily used by doctors.

A single healthcare codebase had to vary services, interface components, and business behavior by country, region, practitioner type, and specialization without becoming a maze of conditional branches. As an Intermediate Software Engineer at CGM, I helped investigate and implement the classification system designed to solve that problem.

A colleague and I led the initial technology spike. I evaluated Apache AGE against the previously proposed Neo4j solution, reproducing the critical taxonomy and traversal queries in both technologies. Apache AGE retained Cypher-based graph modeling while running inside the platform’s existing PostgreSQL infrastructure, avoiding another database technology to deploy and operate.

After the decision was approved, I contributed substantially to the shared Java/Quarkus implementation, documentation, developer guidelines, demonstrations, and onboarding support.

The resulting production system combines graph-based resolution, Redis caching, and a Gizmo-powered Quarkus extension that lets services select context-appropriate implementations declaratively. It is actively used across the platform, supporting multi-country behavior from one codebase while keeping variation logic isolated and maintainable.

KimiaPay wanted to validate a digital salary-advance product for employees with limited access to traditional credit, with partner employers participating in request approval and repayment assurance. During my final-year engineering internship, I served as the Software Engineer Intern and sole technical owner within the small startup team.

The central challenge was architectural: translating a financial product with several actors, approval stages, security requirements, and future extension needs into a coherent system that one developer could deliver within four months.

I designed a service-oriented architecture comprising a cross-platform mobile application for borrowers, a web back office for administrators and employer monitors, backend business services, and a centralized data layer connected through REST/JSON APIs. I then carried that architecture through implementation, testing, and deployment.

The product included token-based authentication, identity and employment-data collection, role-based access, multi-level approval, loan tracking, and a complete request lifecycle from submission through repayment or dispute. I deliberately selected AppGyver and Backendless to accelerate delivery under the project constraints while retaining custom JavaScript integrations where needed. The completed product was deployed and ready for a pilot phase.

Amadeus wanted to understand whether migrating a flight-search application server from Spring/JBoss to Quarkus was technically feasible and worth the investment. My second-year engineering internship focused on that evaluation. The goal was not to change the application’s business behavior, but to determine how it could run on Quarkus and document the implications for future migrations.

Embedded in an agile engineering team, I created the Quarkus-based application and investigated compatibility issues involving external dependencies, CDI, unsupported Spring annotations, and class loading. Depending on the constraint, I used CDI producers, adapted selected components, developed Quarkus extensions, and compared both applications side by side in debug mode. I also escalated genuine framework limitations to the Quarkus community.

The migration was intentionally left incomplete when its scope exceeded the four-month placement. I instead delivered a decision-ready technical reference documenting blockers, solutions, trade-offs, and migration costs. Early measurements indicated substantial startup improvements, while I clearly documented their limitations.

The study gave Amadeus a reusable basis for evaluating future migrations and strengthened my judgment around framework compatibility and migration ROI. Working entirely in English within an international team also strengthened my professional communication through daily collaboration, meetings, technical discussions, and documentation.

École Centrale de Lyon kept its computer rooms open at night so students could study after regular staff had left. A team of paid student monitors supervised the rooms; as their coordinator, I organized the group and served as the administration’s primary contact.

I collected monitor availability, prepared schedules, handled last-minute absences, and balanced monthly hours so the workload and compensation remained broadly equitable. I also helped ensure that the rooms were used appropriately, responded to user incidents, escalated unresolved problems, and kept the administration informed when operational issues arose.

This role developed my ability to coordinate people fairly, maintain continuity when plans changed, and act as a reliable link between a team and institutional stakeholders.

École Centrale de Lyon’s intensive curriculum sometimes left students needing more time and another way into difficult concepts. Based on my computer-science background, the school selected and paid me to lead the computer-science reinforcement sessions for that subject area.

I prepared lessons and exercises, re-explained difficult concepts, reviewed assignments, ran practical workshops, and provided one-to-one support. The sessions focused on algorithms taught through Python, UML and application design, and broader computer-science engineering concepts.

This role taught me to identify where understanding breaks down, adapt an explanation to the student rather than repeat the original course, and translate technical ideas into clear, practical steps.

SUITE was exploring a collaborative mobile application that could make niche and local know-how easier to share and discover through training content, help requests, service offers, and online or in-person events. During my DUT internship, I worked as the Software Developer Intern and sole developer of the mobile client.

I owned the mobile work from requirements analysis through architecture and implementation. I modeled the user roles and domain with UML, then built the cross-platform application in React Native and integrated it with an existing Django REST Framework API provided by the SUITE team. The client consumed REST/JSON endpoints and supported distinct visitor, learner, trainer, and administrator capabilities.

By the end of the internship, I had implemented and presented the core mobile views and end-to-end flows, including browsing training content, authentication, posting help requests, and publishing trainings, events, and offers. This was my first substantial experience owning a mobile product lifecycle, from object-oriented design and technology selection to API integration and product demonstration.