
10+ years building software across embedded Linux, cloud infrastructure, and applied AI. C++ and Python. Systems that are measured, not guessed.
I build software that has to work: aircraft mission systems, secure payment terminals, and broadband gateways shipping to millions of homes. Ten years of it, mostly in C++ and Python on Linux. My range is unusually wide — I have written kernel drivers and device trees for embedded Linux, and I have architected microservices on Kubernetes. I have debugged hardware bring-up, and I have written the Terraform that provisions the cloud.
That span means I can reason about performance and reliability across the whole stack rather than just one layer of it. I am currently focused on low-latency systems, Linux performance analysis, quantitative finance, and AI systems built with real engineering boundaries. The way I work is fairly consistent: measure before optimizing, write the design down including what the system deliberately does not do, state the trade-off, and finish what I start.
Each project below is complete, benchmarked, and documented — including an explicit statement of its trade-offs and limitations.
An investigation tool that diagnoses tail-latency regressions in a low-latency C++ system. The model has no shell access — it selects from restricted, typed diagnostic tools, and every conclusion in the generated report must cite concrete benchmark, profiling, or diff evidence. Metric calculation and CI gating stay in deterministic code. The evaluation suite deliberately includes a case where the correct answer is to abstain.
Stack: Python, C++, Linux perf, OpenTelemetry.
A limit order book matching engine implementing strict price-time priority, with a modular pre-trade risk layer handling max-order-size and fat-finger price checks. Single-threaded core for determinism. Benchmarked with Google Benchmark; the README states the measurement methodology and where the risk model is deliberately simplified.
Stack: C++20, CMake, Google Benchmark, Google Test.
A one-command AWS research environment. Terraform provisions an isolated VPC and a locked-down EC2 instance running Dockerized JupyterLab, with S3 access granted through an IAM instance role rather than stored credentials. Security groups restrict ingress to the invoking IP. Built to address the reproducibility problem in research environments.
Stack: Terraform, Docker, AWS, Python.
A real-time anomaly detection pipeline over a simulated market data stream. A PyTorch autoencoder scores each tick by reconstruction error; flagged anomalies are pushed over WebSockets to a live dashboard. The whole multi-service stack runs from a single docker-compose command.
Stack: Python, FastAPI, PyTorch, Next.js, Docker.
A pre-trained image classifier optimized for inference on constrained ARM64 hardware using post-training INT8 quantization, paired with a cross-compiled C++ TFLite inference application. Roughly 3x model size reduction and 2x latency improvement, with under 2 percentage points of top-1 accuracy loss. The README carries the full results table and the cross-compilation instructions.
Stack: C++17, TensorFlow Lite, CMake, ARM64.
Designed and built a data processing system for aircraft mission-critical applications using a microservices architecture in C++, Java, and Python, deployed on Kubernetes. Contributed to the technical design decisions that improved data throughput and system reliability, working across the stack from service implementation through container orchestration and deployment configuration.
Modernized the CI/CD pipeline for a large-scale embedded Linux platform using Yocto and GitLab CI, substantially reducing build and test cycle times. Integrated core networking features — IPv6, NAT, and firewall rule sets — for xDSL and GPON broadband gateways deployed at consumer scale, and worked on build reproducibility across a large Yocto layer stack.
Designed, implemented, and maintained firmware components in C and C++ for secure payment and identity terminals operating under strict certification requirements. Balanced compliance constraints against performance and memory limits on resource-constrained hardware, across multiple hardware revisions and product lines.
Developed and optimized telemetry data processing software for aerospace ground systems, collaborating with cross-functional teams to hit project milestones under a compressed schedule.
Built and maintained a custom embedded Linux distribution for network gateways using Yocto and Buildroot, including hardware bring-up and device tree configuration. Wrote and debugged Linux kernel drivers and worked on low-level network performance in the data path, alongside U-Boot, OpenWrt, and the surrounding embedded toolchain.
French Grande École of Engineering. Multidisciplinary curriculum spanning electronics, embedded systems, computer science, signal processing, and telecommunications.