Principal Systems Architect & Head of Platform

Engineering at the
intersection of
bare-metal and strategy

Nearly 30 years building high-throughput distributed systems in Rust, C++, and Python. Zero-trust security, every change gated through CI and design review.

Explore Expertise Open Source ↗
Background
Matheus Santos

Matheus Santos

Head of Platform

Started at 14.
Still dismantling things.

I started programming out of obsessive curiosity. I wanted to dismantle things and understand how they work at the base level. Today I work across low-level systems and product decisions, from bare-metal I/O to platform architecture.

I optimize for how the machine actually executes and keep structure consistent so systems stay legible. Over the past decade I've standardised Python orchestration layers, built zero-copy messaging kernels in Rust and C++, and removed latency from the critical path.

I don't rely on default abstractions. I enforce execution isolation and backward planning, creating frameworks and strict CI/CD governance that let developers deploy into mission-critical, ACID-compliant environments without accumulating silent technical debt.

Core Competencies

What I build.
How I think.

Systems architecture

High-throughput distributed systems, event-driven topologies (NATS/ZMQ), and microservice boundary enforcement at scale.

Concurrency & performance

Deep OS-level primitives: epoll/kqueue reactors, POSIX fork safety, sync/async impedance resolution, and latency optimisation in Rust, C++, and Python.

Data integrity & strategy

ACID/BASE compliance, strict tenant-scoping in multi-cloud environments, and aligning deep-tech infrastructure with product monetisation goals.

Engineering leadership

Building developer culture through consistent naming, precise taxonomies, and ADR-driven decision-making. Bridging business vision to bare-metal execution.

Technical Expertise

Languages and tools.

Languages
Rust C++ C Python Go Java Kotlin Lisp JavaScript Bash
Message Brokers
NATS ZeroMQ RabbitMQ (AMQP/MQTT) ActiveMQ SQS (AWS)
Databases
PostgreSQL MongoDB MySQL
Frameworks
Envoxy (Python) Flask (Python) Django (Python) FastAPI (Python) Actix-web (Rust) Zapata (C++) Echo (Go) Spring (Java) EJB (Java) JPA (Java)
Open Source

Code I've
put into the world.

Envoxy Platform Framework

A Python-based modular framework for building scalable, event-driven platform ecosystems. Built around semantic consistency and strict boundary enforcement.

Python github.com/habitio/envoxy
↗

Monocoque

A pure-Rust alternative to libzmq with no FFI boundary. Built on io_uring with zero-copy message fanout, syscall-minimal IO, and memory safety by construction.

Rust github.com/vorjdux/monocoque
↗

Dux

A statically-typed compiled language with Python-like syntax and an LLVM backend. Ref-counted strings, hybrid inline/heap allocation, and a clean type system. Built from scratch to understand language design at the metal level.

C++ C LLVM github.com/vorjdux/dux-lang
↗

Wire Probe

A lightweight TCP telemetry agent that measures Layer 4 handshake latency with no external dependencies. Server mode uses io_uring to handle connections at ~500 KB RSS; probe mode exports RTT metrics to Telegraf or Collectd. Ships as a 370 KB statically-linked binary.

Rust github.com/vorjdux/wire-probe
↗

Zapata

Contributor to this C++ framework for distributed systems. High-performance, low-latency primitives for systems that can't absorb the overhead of conventional approaches.

C++ github.com/naazgull/zapata
↗
Writing

Things I've
figured out the hard way.

2026-06 Rust Systems Networking

Safe Rust, Corrupt Wire

Rust gives you memory safety by construction and stops there. Building Monocoque, a pure-Rust ZeroMQ runtime over io_uring, made that boundary concrete: async cancellation is Drop, which cleans up your buffers and leaves your peer mid-parse. The fix has to be structural for the same reason the memory fix was.

Read →
2026-06 Rust OS Systems

Hardware Is Asynchronous. Most of Our Operating Systems Still Aren't.

A thread about wire-probe turned into a long back-and-forth with someone building a from-scratch OS in Rust. One idea came out of it that I haven't been able to put down: the dominant POSIX model is a synchronous fiction layered over fundamentally asynchronous hardware, and we have spent thirty years bolting async back on rather than starting from it.

Read →
2026-06 Networking Azure Rust

The ICMP Illusion: Bypassing Cloud SDN to Measure True L4 Latency

If you run stateful workloads on Azure, your ICMP telemetry may be lying to you. Under compute load, ICMP rides the contended software path while TCP's accelerated-networking datapath is unaffected, manufacturing a network bottleneck that doesn't exist at L4 or L7. How we diagnosed a persistent 4-6 ms latency floor and built wire-probe to stop trusting ping.

Read →
Contact

Let's build
something precise.

Available for consulting on distributed systems architecture, platform strategy, and engineering leadership.

⌥
GitHub
◈
LinkedIn
✉
Email